Nel seguente frammento di codice,C++ 11 'native_handle' non è un membro di 'std :: this_thread'
void foo() {
std::this_thread::native_handle().... //error here
}
int main() {
std::thread t1(foo);
t1.join();
return 0;
}
Come si ottiene il native_handle da std::this_thread dall'interno della funzione foo?
Non è possibile per un thread accedere autonomamente al proprio std::thread. Questo è di proposito poiché std::thread è un tipo di spostamento.
Credo che quello che stai richiedendo è un membro native_handle() di std::thread::id, e questo è un suggerimento interessante. Per quanto ne so, non è attualmente possibile. Sarebbe stato usato come:
void foo()
{
auto native_me = std::this_thread::get_id().native_handle();
// ...
}
Non sarebbe garantito funzionare o esistere. Tuttavia, immagino che la maggior parte delle piattaforme POSIX possa supportarlo.
Un modo per provare a cambiare lo standard C++ è inviare problemi. Here sono le indicazioni su come farlo.
C++ 11 non fornisce un meccanismo per ottenere i thread correnti native_handle. È necessario utilizzare chiamate specifiche della piattaforma, vale a dire GetCurrentThread() su Windows:
void foo()
{
auto native_me = ::GetCurrentThread();
}
Come sottolineato Howard, non v'è alcun supporto per questo nella ISO C++ ancora.
Ma thread::id ha un sovraccarico operator<< per stampa stesso per un ostream.
#include <iostream>
#include <thread>
int main()
{
std::cout << "Current thread ID: " << std::this_thread::get_id() << std::endl;
}
Senza conoscere la semantica del valore effettivo (che è fortemente dipendente dalla piattaforma), la stampa o l'utilizzo come una chiave in una mappa è la più si dovrebbe fare in ogni caso.
pensi che una cosa del genere vada presentata come una proposta per C++ 14? – pyCthon
@NicholasPezolano: In questo momento no. Tuttavia, potrei essere persuaso da un caso d'uso motivante e da un'implementazione che lo dimostri. Cioè Penso di conoscere il costo/rischio. Ma non penso di conoscere il beneficio. Se il vantaggio è zero, non importa quanto sia basso il costo, il rapporto benefici/costi è scarso. Quindi avresti bisogno di dimostrare un grande vantaggio. –
Non penso che l'OP voglia necessariamente 'std :: thread :: id :: native_handle'. Penso che il punto interessante sia: non dovrebbe l'interfaccia di 'std :: this_thread' imitare quella di' std :: thread'? Tranne, naturalmente, per quei membri che si riferiscono alla gestione della durata del thread, che, come giustamente fai notare, non ha molto senso. Ciò non lascia molto, ma "native_handle" mi sembra costernamente assente. –