Segnali di cattura: utilizzare una funzione membro come gestore di segnale

Question

Ho un oggetto che funziona in un ciclo infinito. Lo main() crea un'istanza dell'oggetto e chiama il metodo run(). Dal momento che non voglio usare i thread, ho bisogno di una soluzione per far sì che il mio oggetto smetta di funzionare. Sotto vedi quello che ho scoperto.

struct Foo 
{ 
    void run() 
    { 
     running = 1; 
     while (running) 
      do_something_useful(); 

     std::cout << "Execution stopped." << std::endl; 
    } 

    bool running; 

    void catch_signal(int signal) 
    { 
     std::cout << "Caught signal " << signal << std::endl; 
     if(signal == SIGTERM) 
      running = false; 
    } 

}; 

Come si vede, ho bisogno di inviare un segnale in modo asincrono. Pertanto, io uso un gestore di segnale e sigaction. Sotto il main posso immaginare di usare.

int main(int argc, char** argv) 
{ 
    Foo foo; 
    struct sigaction sigIntHandler; 

    boost::function< void (int) > f; 
    f = std::bind1st(
     std::mem_fun(&Foo::catch_signal), &foo); 
    f(5); // this call works 

    sigIntHandler.sa_handler = f;   // compiler complains, "cannot assign ..." 
    sigemptyset(&sigIntHandler.sa_mask); 
    sigIntHandler.sa_flags = 0; 
    sigaction(SIGTERM, &sigIntHandler, NULL); 
    s.run(); 

} 

Cosa mi aspetto ora: il programma viene eseguito fino a quando io mando SIGTERM che viene catturata e farà sì che il mio oggetto di fermare l'iterazione e tornare alla principale.

Ho due domande ora:

(a) il codice che vedi una linea contrassegnata con "compilatore si lamenta", il messaggio è come

boost::function<void(int)> cannot be converted to __sighandler_t {aka void (*)(int)} 

Di cosa ho bisogno di cambiare per rendere questo lavoro? Penso che f sia come void f(int), come le funzioni che il gestore di segnali riceve in alcuni esempi.

(b) Per quelli di voi che si chiedono "cosa sta facendo quel ragazzo?": Avete qualche consiglio su come risolvere meglio questo tipo di cose?

Answer 1

• Cosa devo cambiare per farlo funzionare? Penso che f sia come void f (int), come le funzioni che il gestore del segnale ottiene in alcuni esempi.

Il compilatore si lamenta del tipo, quindi, è necessario passare un puntatore a funzione, non è un oggetto di tipo boost::function<void(int)>. Creazione di una variabile globale di questo tipo, e l'aggiunta di una funzione che chiama questo oggetto dovrebbe funzionare:

boost::function<void(int)> myCb; 
void CallCb(int value) 
{ 
    myCb(value); 
} 

int main(int argc, char** argv) 
{ 
    Foo foo; 
    struct sigaction sigIntHandler; 

    myCb = std::bind1st(
     std::mem_fun(&Foo::catch_signal), &foo); 
    f(5); // this call works 

    sigIntHandler.sa_handler = CallCb; 
    sigemptyset(&sigIntHandler.sa_mask); 
    sigIntHandler.sa_flags = 0; 
    sigaction(SIGTERM, &sigIntHandler, NULL); 
    s.run(); 

} 

• Hai qualche consiglio come risolvere questo genere di cose meglio?

Non proprio. L'idea è ok. Vorrei solo C++ 11 lambda invece

Answer 2

C'è pochissimo che puoi fare in modo portabile in un gestore di segnale. In sostanza, è possibile memorizzare un valore in un oggetto il cui tipo è sig_atomic_t. L'inserimento in cout, ad esempio, non deve funzionare. Se hai C++ 11 puoi fare un po 'di più, usando i tipi atomici o le recinzioni esplicite, ma a qualsiasi altra chiamata nella libreria standard non è richiesto di fare qualcosa di sensato.

Quindi, con tutto ciò che detto, ciò che puoi fare è scrivere una funzione (una funzione libera o una funzione membro statica (ma qui c'è un problema sottile con il collegamento C++: formalmente una funzione membro statica non funzionerà , ma in pratica lo fa sempre)) che chiama la funzione membro, che a sua volta imposta running su false (presumendo che tu abbia cambiato il tipo di running in sig_atomic_t).