Come posso gestire il segnale di interruzione e chiamare il distruttore in C++?

Question

Eventuali duplicati:
Is destructor called if SIGINT or SIGSTP issued?

mio codice come questo:

#include <iostream> 
#include <signal.h> 
#include <cstdlib> 

void handler(int) { 
    std::cout << "will exit..." << std::endl; 
    exit(0); 
} 

class A { 
public: 
    A() {std::cout << "constructor" << std::endl;} 
    ~A() {std::cout << "destructor" << std::endl;} 
}; 

int main(void) { 
    signal(SIGINT, &handler); 

    A a; 
    for (;;); 

    return 0; 
} 

Quando ho premuto Ctrl-C, è stampato:

constructor 
^Cwill exit... 

Non è stato stampato alcun "distruttore". Quindi, come posso uscire in modo pulito?

Answer 1

Con difficoltà. Già, il codice che hai scritto non ha un comportamento definito da ; non ti è permesso uscire in un flusso in un gestore di segnali; per questo, non sei autorizzato a chiamare exit neanche. (Sto basando mie asserzioni qui sullo standard Posix. In puro C++, tutti i sei permesso di fare è assegnare a una variabile di tipo sig_atomic_t.)

In un caso semplice come il tuo codice, si potrebbe fare qualcosa di simile:

sig_atomic_t stopFlag = 0; 

void 
handler(int) 
{ 
    stopFlag = 1; 
} 

int 
main() 
{ 
    signal(SIGINT, &handler); 
    A a; 
    while (stopFlag == 0) { 
    } 
    std::cout << "will exit..." << std::endl; 
    return 0; 
} 

a seconda dell'applicazione, si può essere in grado di fare qualcosa di simile, controllando il stopFlag in luoghi appropriati.Ma in generale, se provi a fare questo, ci saranno le condizioni della gara: controlli stopFlag prima del avviando una chiamata di sistema interrotta, quindi esegui la chiamata; il segnale arriva tra il controllo e la chiamata, si effettua la chiamata e non è interrotto. (Ho usato questa tecnica, ma in un'applicazione in cui la chiamata di sistema unico interrompibile è stata una presa di corrente letta con un brevissimo timeout.)

Tipicamente, almeno sotto Posix, si finirà per dover creare un filo di comando ; questo può quindi essere utilizzato per chiudere in modo pulito tutti gli altri thread . Fondamentalmente, si avvia impostando la maschera di segnale per bloccare tutti i segnali, quindi nel thread di gestione dei segnali, una volta avviato, impostare per accettare i segnali a cui si è interessati e chiamare sigwait(). Questo implica, tuttavia, che si eseguano tutte le normali azioni necessarie per uno shutdown pulito dei thread : il thread di gestione del segnale deve conoscere su tutti gli altri thread, chiamare pthread_cancel su di essi, ecc. E si è il compilatore deve generare il codice corretto per gestire pthread_cancel o è necessario sviluppare altri mezzi per garantire che tutti i thread siano stati notificati correttamente . (Si potrebbe sperare, oggi, che tutti i compilatori gestiscono pthread_cancel correttamente, ma non si sa mai,.. Così facendo ha significativa dei costi di esecuzione, e non è di solito necessario)

Answer 2

La memoria dovrebbe essere liberata comunque. ma se hai il codice da gestire, suppongo che dovrai tenere traccia di tutti i tuoi oggetti e poi distruggerli secondo necessità (ad esempio facendo in modo che il costruttore li aggiunga a std::set, mentre il distruttore li rimuove di nuovo). Tuttavia ciò non garantirebbe un ordine di distruzione appropriato (che potrebbe richiedere una soluzione più complessa).

Si potrebbe anche usare il gestore del segnale per impostare un flag che lascerà il loop infinito (o qualunque cosa si stia facendo nel loop principale) invece di terminare semplicemente usando exit().

Answer 3

è necessario uscire dal campo di applicazione della funzione principale di avere il lavoro distruttore:

#include <iostream> 
#include <signal.h> 
#include <cstdlib> 

bool stop = false; 
void handler(int) { 
    std::cout << "will exit..." << std::endl; 
    stop = true; 
} 

class A { 
public: 
    A() {std::cout << "constructor" << std::endl;} 
    ~A() {std::cout << "destructor" << std::endl;} 
}; 

int main(void) { 
    A a; 
    signal(SIGINT, &handler); 

    for (;!stop;); 

    return 0; 
} 

Answer 4

E 'perché il contesto del codice normale e il gestore del segnale è diverso. Se metti la variabile a in ambito globale (ad esempio, al di fuori di qualsiasi funzione) vedrai che il distruttore è chiamato correttamente.

Se si desidera gestire la pulizia da soli (invece di lasciare il run-time e OS gestirlo), si può avere un ciclo condizionale, qualcosa di simile:

bool keep_running = true; 

void handler(int) { 
    std::cout << "will exit..." << std::endl; 
    keep_running = false; 
} 

int main(void) { 
    signal(SIGINT, &handler); 

    A a; 
    while (keep_running); 

    return 0; 
} 

Answer 5

exit termina il processo quasi subito ; in particolare, gli oggetti con durata di archiviazione automatica non vengono distrutti. Gli stream sono anche scaricati e chiusi, ma non ti è permesso toccare i flussi dall'interno di un gestore di segnale. Quindi ...

Semplicemente non chiamare exit da un gestore di segnale; imposta un flag atomico per indicare invece che il ciclo termina.

#include <iostream> 
#include <signal.h> 
#include <cstdlib> 

sig_atomic_t exitRequested = 0; 

void handler(int) { 
    std::cout << "will exit..." << std::endl; 
    exitRequested = 1; 
} 

struct A { 
    A() { std::cout << "constructor" << std::endl; } 
    ~A() { std::cout << "destructor" << std::endl; } 
}; 

int main() { 
    signal(SIGINT, &handler); 

    A a; 
    for (; !exitRequested;); 
}