¿Cuál es la forma más fácil de hacer que un programa C ++ se bloquee?

Estoy tratando de hacer un programa Python que interactúe con un proceso diferente (que está fuera de mis manos). ¡Desafortunadamente, el programa con el que estoy interactuando ni siquiera se bloquea de manera confiable! Así que quiero hacer un programa C ++ rápido que se cuelgue a propósito, pero en realidad no sé cuál es la mejor y más corta forma de hacerlo, ¿alguien sabe qué poner entre mis:

int main() {
    crashyCodeGoesHere();
}

hacer que mi programa C ++ se bloquee de manera confiable

La abort()función es probablemente tu mejor apuesta. Forma parte de la biblioteca estándar de C y se define como "causante de la finalización anormal del programa" (p. Ej., Un error fatal o bloqueo).

Tratar:

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

Encontrado en:

#include <signal.h>

Dividir por cero bloqueará la aplicación:

int main()
{
    return 1 / 0;
}

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

Bueno, ¿estamos en desbordamiento de pila o no?

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

(No se garantiza que se bloquee según ningún estándar, pero tampoco se incluye ninguna de las respuestas sugeridas, incluida la aceptada, ya que SIGABRTpodría haberse detectado de todos modos. En la práctica, esto se bloqueará en todas partes).

 throw 42;

Solo la respuesta ... :)

assert(false); También es bastante bueno.

De acuerdo con ISO / IEC 9899: 1999, se garantiza que se bloqueará cuando NDEBUG no esté definido:

Si se define NDEBUG [...] la macro de aserción se define simplemente como

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

La macro de aserción se redefine de acuerdo con el estado actual de NDEBUG cada vez que se incluye.

[...]

La macro de aserción coloca pruebas de diagnóstico en programas; [...] si la expresión (que tendrá un tipo escalar) es falsa [...]. Luego llama a la función abortar.

Dado que un bloqueo es un síntoma de invocar un comportamiento indefinido, y dado que invocar un comportamiento indefinido puede conducir a cualquier cosa, incluido un bloqueo, no creo que realmente quiera bloquear su programa, sino que simplemente lo deje caer en un depurador. La forma más portátil de hacerlo es probablemente abort().

Si bien raise(SIGABRT)tiene el mismo efecto, ciertamente es más para escribir. Sin embargo, ambas formas se pueden interceptar instalando un controlador de señal para SIGABRT. Entonces, dependiendo de su situación, es posible que desee / necesite generar otra señal. SIGFPE, SIGILL, SIGINT, SIGTERMO SIGSEGVpodría ser el camino a seguir, pero todos ellos pueden ser interceptados.

Cuando puede ser inportable, sus opciones pueden ser aún más amplias, como usar SIGBUSen Linux.

El único flash que tuve es la función abort () :

Anula el proceso con una terminación anormal del programa. Genera la señal SIGABRT , que por defecto hace que el programa termine devolviendo un código de error de terminación sin éxito al entorno host. El programa finaliza sin ejecutar destructores para objetos de duración de almacenamiento automático o estático , y sin llamar a ninguna función atexit (que se llama mediante exit () antes de que el programa finalice). Nunca vuelve a su llamador.

La respuesta es específica de la plataforma y depende de tus objetivos. Pero aquí está la función de bloqueo de Javascript de Mozilla, que creo que ilustra muchos de los desafíos para hacer que esto funcione:

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
}

Veo que hay muchas respuestas publicadas aquí que caerán en casos afortunados para hacer el trabajo, pero ninguna de ellas es 100% determinista para fallar. Algunos fallarán en un hardware y sistema operativo, los otros no. Sin embargo, hay una forma estándar según el estándar oficial de C ++ para hacer que se bloquee.

Citando del Estándar C ++ ISO / IEC 14882 §15.1-7 :

Si el mecanismo de manejo de excepciones, después de completar la inicialización del objeto de excepción pero antes de la activación de un controlador para la excepción, llama a una función que sale a través de una excepción, se llama 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) { }
}

He escrito un pequeño código para demostrar esto y puedo encontrarlo y probarlo en Ideone aquí .

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;
}

ISO / IEC 14882 §15.1 / 9 menciona lanzamiento sin bloqueo de prueba que resulta en una llamada implícita a abortar:

Si actualmente no se maneja ninguna excepción, la ejecución de una expresión de lanzamiento sin operando llama a std :: terminate ()

Otros incluyen: tiro desde el destructor: ISO / IEC 14882 §15.2 / 3

*( ( char* ) NULL ) = 0;

Esto producirá una falla de segmentación.

Este falta:

int main = 42;

¿Qué pasa con el desbordamiento de pila por una llamada de método recursivo de bucle muerto?

#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);
}

Ver ejemplo original en Microsoft KB

Esto se bloquea en mi sistema Linux, porque los literales de cadena se almacenan en la memoria de solo lectura:

0[""]--;

Por cierto, g ++ se niega a compilar esto. Los compiladores son cada vez más inteligentes :)

int i = 1 / 0;

Su compilador probablemente le advertirá sobre esto, pero se compila muy bien en GCC 4.4.3 Esto probablemente causará un SIGFPE (excepción de punto flotante), que tal vez no sea tan probable en una aplicación real como SIGSEGV (violación de segmentación de memoria) como las otras respuestas causan, pero sigue siendo un accidente. En mi opinión, esto es mucho más legible.

Otra forma, si vamos a hacer trampa y usar signal.h, es:

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

Esto está garantizado para matar el subproceso, en contraste con SIGSEGV.

Esta es una versión más garantizada de aborto presentada en las respuestas anteriores. Se ocupa de la situación cuando se bloquea el sigabrt. De hecho, puede usar cualquier señal en lugar de abortar que tenga la acción predeterminada de bloquear el programa.

#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;

Esto también debería bloquearse. En Windows, se bloquea con AccessViolation y supongo que debería hacer lo mismo en todos los sistemas operativos.

Este es el fragmento proporcionado por Google en 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;
}

Aunque esta pregunta ya tiene una respuesta aceptada ...

void main(){
    throw 1;
}

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

Escribir en una memoria de solo lectura provocará un error de segmentación a menos que su sistema no admita bloques de memoria de solo lectura.

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

Lo probé con MingGW 5.3.0 en Windows 7 y GCC en Linux Mint. Supongo que otros compiladores y sistemas darán un efecto similar.

O de otra manera, ya que estamos en el carro de la banda.

Una hermosa pieza de recursión infinita. Garantizado para volar tu pila.

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

Imprime:

Falla de segmentación (núcleo descargado)

Uno que aún no se ha mencionado:

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

Esto tratará el puntero nulo como un puntero de función y luego lo llamará. Al igual que la mayoría de los métodos, no se garantiza que se bloquee el programa, pero las posibilidades de que el sistema operativo permita que esto no se controle y que el programa regrese nunca son insignificantes.

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;
  }

}

Espero que esto se cuelgue. Salud.

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

Una forma elegante de hacer esto es una llamada de función virtual pura:

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;
}

Compilado con gcc, esto imprime:

método virtual puro llamado

terminar llamado sin una excepción activa

Abortado (núcleo descargado)

Puede usar el ensamblaje en su c ++ code PERO INT 3 es solo para sistemas x86, otros sistemas pueden tener otras instrucciones de trampa / punto de interrupción.

int main()
{
    __asm int 3;

    return 0;
}

INT 3 provoca una interrupción y llama a un vector de interrupción configurado por el sistema operativo.

Use __builtin_trap () en GCC o clang, o __debugbreak () en MSVC. No manejar estos puntos de interrupción / trampas conducirá a una excepción / bloqueo de punto de interrupción no manejado. Otras sugerencias que usan abort () o exit (): esas pueden ser manejadas por otros hilos, lo que hace que sea más difícil ver la pila del hilo que propagó el bloqueo.

char*freeThis;
free(freeThis);

Liberar un puntero no inicializado es un comportamiento indefinido. En muchas plataformas / compiladores, freeThistendrá un valor aleatorio (lo que haya estado en esa ubicación de memoria antes). Al liberarlo, el sistema le pedirá al sistema que libere la memoria en esa dirección, lo que generalmente causará un fallo de segmentación y hará que el programa se bloquee.