Qual è il modo più semplice per arrestare un programma C ++?

Sto cercando di creare un programma Python che si interfaccia con un diverso processo anomalo (che è fuori dalle mie mani). Sfortunatamente il programma con cui mi sto interfaccia non si blocca nemmeno in modo affidabile! Quindi voglio creare un programma C ++ rapido che si blocchi di proposito ma in realtà non conosco il modo migliore e più breve per farlo, qualcuno sa cosa mettere tra i miei:

int main() {
    crashyCodeGoesHere();
}

per rendere affidabile il mio programma C ++ in modo affidabile

La abort()funzione è probabilmente la soluzione migliore. Fa parte della libreria standard C ed è definito come "causa della chiusura anomala del programma" (ad esempio, un errore irreversibile o un arresto anomalo).

Provare:

raise(SIGSEGV);  // simulates a standard crash when access invalid memory
                 // ie anything that can go wrong with pointers.

Trovato in:

#include <signal.h>

La divisione per zero causerà l'arresto anomalo dell'applicazione:

int main()
{
    return 1 / 0;
}

*((unsigned int*)0) = 0xDEAD;

Bene, siamo in overflow dello stack o no?

for (long long int i = 0; ++i; (&i)[i] = i);

(Non è garantito il crash di alcuno standard, ma nessuna delle risposte suggerite, inclusa quella accettata, SIGABRTpotrebbe essere stata catturata comunque. In pratica, si bloccherà ovunque.)

 throw 42;

Solo la risposta ... :)

assert(false); è anche abbastanza buono.

Secondo ISO / IEC 9899: 1999 è garantito un arresto anomalo quando NDEBUG non è definito:

Se NDEBUG è definito [...] la macro assert è definita semplicemente come

#define assert(ignore) ((void)0)

La macro assert viene ridefinita in base allo stato corrente di NDEBUG ogni volta che viene inclusa.

[...]

La macro assert inserisce test diagnostici nei programmi; [...] se espressione (che deve avere un tipo scalare) è falsa [...]. Quindi chiama la funzione di interruzione.

Poiché un arresto anomalo è un sintomo dell'invocazione di comportamenti indefiniti, e poiché l'invocazione di comportamenti indefiniti può portare a qualsiasi cosa, incluso un arresto anomalo, non penso che tu voglia davvero interrompere il tuo programma, ma fallo cadere in un debugger. Il modo più portatile per farlo è probabilmenteabort() .

Mentre raise(SIGABRT)ha lo stesso effetto, è sicuramente più da scrivere. Entrambi i modi possono tuttavia essere intercettati installando un gestore di segnale per SIGABRT. Pertanto, a seconda della situazione, potrebbe essere necessario / necessario aumentare un altro segnale. SIGFPE, SIGILL, SIGINT, SIGTERMO SIGSEGVpotrebbe essere la strada da percorrere, ma tutti possono essere intercettati.

Quando puoi essere insostituibile, le tue scelte potrebbero essere anche più ampie, come usare SIGBUSsu Linux.

L'unico flash che ho avuto è la funzione abort () :

Interrompe il processo con un'interruzione anomala del programma e genera il segnale SIGABRT , che per impostazione predefinita provoca la chiusura del programma restituendo un codice di errore di interruzione non riuscito nell'ambiente host. Il programma viene terminato senza eseguire distruttori per oggetti con durata di memorizzazione automatica o statica e senza chiamare alcuna funzione atexit (che viene chiamata da exit () prima che il programma termini). Non torna mai al suo chiamante.

La risposta è specifica per la piattaforma e dipende dai tuoi obiettivi. Ma ecco la funzione di crash di Mozilla Javascript, che a mio avviso illustra molte delle sfide per far funzionare questo:

static JS_NEVER_INLINE void
CrashInJS()
{
    /*
     * We write 123 here so that the machine code for this function is
     * unique. Otherwise the linker, trying to be smart, might use the
     * same code for CrashInJS and for some other function. That
     * messes up the signature in minidumps.
     */

#if defined(WIN32)
    /*
     * We used to call DebugBreak() on Windows, but amazingly, it causes
     * the MSVS 2010 debugger not to be able to recover a call stack.
     */
    *((int *) NULL) = 123;
    exit(3);
#elif defined(__APPLE__)
    /*
     * On Mac OS X, Breakpad ignores signals. Only real Mach exceptions are
     * trapped.
     */
    *((int *) NULL) = 123;  /* To continue from here in GDB: "return" then "continue". */
    raise(SIGABRT);  /* In case above statement gets nixed by the optimizer. */
#else
    raise(SIGABRT);  /* To continue from here in GDB: "signal 0". */
#endif
}

Vedo che ci sono molte risposte pubblicate qui che cadranno in casi fortunati per portare a termine il lavoro, ma nessuna di esse è deterministica al 100% per il crash. Alcuni si arresteranno in modo anomalo su un hardware e sistema operativo, altri no. Tuttavia, esiste un modo standard secondo lo standard C ++ ufficiale per farlo arrestare.

Citando dalla norma C ++ ISO / IEC 14882 §15.1-7 :

Se il meccanismo di gestione delle eccezioni, dopo aver completato l'inizializzazione dell'oggetto dell'eccezione ma prima dell'attivazione di un gestore per l'eccezione, chiama una funzione che esce tramite un'eccezione, viene chiamato std :: terminate (15.5.1).

struct C {
    C() { }
    C(const C&) {
        if (std::uncaught_exceptions()) {
            throw 0; // throw during copy to handler’s exception-declaration object (15.3)
        }
    }
};
int main() {
    try {
    throw C(); // calls std::terminate() if construction of the handler’s
    // exception-declaration object is not elided (12.8)
    } catch(C) { }
}

Ho scritto un piccolo codice per dimostrarlo e può essere trovato e provato su Ideone qui .

class MyClass{
    public:
    ~MyClass() throw(int) { throw 0;}
};

int main() {
  try {
    MyClass myobj; // its destructor will cause an exception

    // This is another exception along with exception due to destructor of myobj and will cause app to terminate
     throw 1;      // It could be some function call which can result in exception.
  }
  catch(...)
  {
    std::cout<<"Exception catched"<<endl;
  }
  return 0;
}

Le menzioni ISO / IEC 14882 §15.1 / 9 lanciano senza provare il blocco con conseguente chiamata implicita ad interrompere:

Se al momento non viene gestita alcuna eccezione, l'esecuzione di un'espressione di lancio senza operando chiama std :: terminate ()

Altri includono: lancio dal distruttore: ISO / IEC 14882 §15.2 / 3

*( ( char* ) NULL ) = 0;

Ciò produrrà un errore di segmentazione.

Questo manca:

int main = 42;

Che dire dello overflow dello stack tramite una chiamata al metodo ricorsivo dead loop?

#include <windows.h>
#include <stdio.h>

void main()
{
    StackOverflow(0);
}

void StackOverflow(int depth)
{
    char blockdata[10000];
    printf("Overflow: %d\n", depth);
    StackOverflow(depth+1);
}

Vedi esempio originale su Microsoft KB

Questo si arresta in modo anomalo sul mio sistema Linux, perché i valori letterali delle stringhe sono memorizzati nella memoria di sola lettura:

0[""]--;

A proposito, g ++ rifiuta di compilare questo. I compilatori stanno diventando sempre più intelligenti :)

int i = 1 / 0;

Il compilatore probabilmente ti avvertirà di questo, ma si compila bene sotto GCC 4.4.3 Questo probabilmente causerà un SIGFPE (eccezione in virgola mobile), che forse non è così probabile in un'applicazione reale come SIGSEGV (violazione della segmentazione della memoria) come le altre risposte causano, ma è ancora un incidente. Secondo me, questo è molto più leggibile.

Un altro modo, se vogliamo imbrogliare e usare signal.h, è:

#include <signal.h>
int main() {
    raise(SIGKILL);
}

Questo è garantito per uccidere il sottoprocesso, in contrasto con SIGSEGV.

Questa è una versione più sicura di abort presentata nelle risposte sopra. Si occupa della situazione in cui sigabrt è bloccato. È possibile infatti utilizzare qualsiasi segnale anziché interrompere che ha l'azione predefinita di crash del programma.

#include<stdio.h>
#include<signal.h>
#include<unistd.h> 
#include<stdlib.h>
int main()
{
    sigset_t act;
    sigemptyset(&act);
    sigfillset(&act);
    sigprocmask(SIG_UNBLOCK,&act,NULL);
    abort();
}

int* p=0;
*p=0;

Anche questo dovrebbe andare in crash. Su Windows si arresta in modo anomalo con AccessViolation e dovrebbe fare lo stesso su tutti i sistemi operativi che immagino.

Questo è lo snippet fornito da Google in Breakpad.

  volatile int* a = reinterpret_cast<volatile int*>(NULL);
  *a = 1;

int main(int argc, char *argv[])
{
    char *buf=NULL;buf[0]=0;
    return 0;
}

Sebbene questa domanda abbia già una risposta accettata ...

void main(){
    throw 1;
}

O... void main(){throw 1;}

La scrittura su una memoria di sola lettura provocherà un errore di segmentazione a meno che il sistema non supporti i blocchi di memoria di sola lettura.

int main() {
    (int&)main = 0;
}

L'ho provato con MingGW 5.3.0 su Windows 7 e GCC su Linux Mint. Suppongo che altri compilatori e sistemi daranno un effetto simile.

O in un altro modo da quando siamo sul carro della band.

Un bel pezzo di ricorsione infinita. Garantito per far saltare il tuo stack.

int main(int argv, char* argc)
{
   return main(argv, argc)
}

Stampa:

Errore di segmentazione (core scaricato)

Uno che non è stato ancora menzionato:

((void(*)())0)();

Questo tratterà il puntatore null come un puntatore a funzione e quindi lo chiamerà. Proprio come la maggior parte dei metodi, questo non è garantito per bloccare il programma, ma le possibilità che il sistema operativo permetta che ciò non venga controllato e che il programma che ritorna mai sono trascurabili.

void main()
{

  int *aNumber = (int*) malloc(sizeof(int));
  int j = 10;
  for(int i = 2; i <= j; ++i)
  {
      aNumber = (int*) realloc(aNumber, sizeof(int) * i);
      j += 10;
  }

}

Spero che questo si blocchi. Saluti.

int main()
{
    int *p=3;
    int s;
    while(1) {
        s=*p;
        p++;
    }
}

Un modo elegante per farlo è una pura chiamata di funzione virtuale:

class Base;

void func(Base*);

class Base
{
public:
   virtual void f() = 0;
   Base() 
   {
       func(this);
   }
};

class Derived : Base
{
   virtual void f()
   {
   }
};

void func(Base* p)
{
   p->f();
}


int main()
{
    Derived  d;
}

Compilato con gcc, questo stampa:

metodo virtuale puro chiamato

termina chiamato senza un'eccezione attiva

Interrotto (core scaricato)

Puoi usare assembly nel tuo c ++ code MA INT 3 è solo per sistemi x86, altri sistemi potrebbero avere altre istruzioni trap / breakpoint.

int main()
{
    __asm int 3;

    return 0;
}

INT 3 provoca un interrupt e chiama un vettore di interrupt impostato dal sistema operativo.

Utilizzare __builtin_trap () in GCC o clang o __debugbreak () in MSVC. La mancata gestione di questi punti di interruzione / trappole comporterà un'eccezione / arresto del punto di interruzione non gestita. Altri suggerimenti che usano abort () o exit (): quelli possono essere gestiti da altri thread, rendendo più difficile vedere lo stack del thread che ha propagato il crash.

char*freeThis;
free(freeThis);

Liberare un puntatore non inizializzato è un comportamento indefinito. Su molte piattaforme / compilatori, freeThisavrà un valore casuale (qualunque cosa fosse prima in quella posizione di memoria). Liberarlo chiederà al sistema di liberare la memoria a quell'indirizzo, che di solito causerà un errore di segmentazione e causerà il crash del programma.