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

Intenta:

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

Se encuentra en:

#include <signal.h>

Dividir por cero bloqueará la aplicación:

int main()
{
    return 1 / 0;
}

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

Bien, estamos en piladesbordamiento, 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 ninguna de las respuestas sugeridas, incluida la aceptada, ya que SIGABRT podría haber sido atrapada de todos modos. En la práctica, esto se estrellará en todas partes.)

 throw 42;

Solo la respuesta... :)

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

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

Si se define NDEBUG [...] la macro assert se define simplemente como

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

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

[...]

La macro assert pone pruebas diagnósticas en programas; [...] si la expresión (que tendrá un tipo escalar) es false [...]. Se luego llama a la función abortar.

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

Mientras que raise(SIGABRT) tiene el mismo efecto, ciertamente es más escribir. Sin embargo, ambas formas pueden ser interceptadas instalando un manejador de señal para SIGABRT. Así que dependiendo de su situación, es posible que desee / necesite para elevar otra señal. SIGFPE, SIGILL, SIGINT, SIGTERM o SIGSEGV podría ser el camino a seguir, pero todos pueden ser interceptados.

Cuando puede ser importable, sus opciones pueden ser aún más amplias, como usar SIGBUS en linux.

El único flash que tenía es abort() function :

Aborta el proceso con un programa anormal termination.It genera la señal SIGABRT , que de forma predeterminada hace que el programa termine devolviendo un código de error de terminación fallido al entorno host.El programa se termina sin ejecutar destructores para objetos de duración de almacenamiento automática o estática, y sin llamar a cualquier atexit (que se llama por exit () antes el programa termina la función). Nunca regresa a su persona que llama.

La respuesta es específica de la plataforma y depende de sus 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
}

C++ se puede estrelló determinista por tener 2 excepciones en paralelo! El estándar dice nunca lanzar ninguna excepción de un destructor O nunca usar ninguna función en un destructor que pueda lanzar excepción.

Tenemos que hacer una función para dejar el destructor etc etc.

Un ejemplo de ISO/IEC 14882 §15.1-7. Debe ser un bloqueo según el estándar de C++. Ideun ejemplo se puede encontrar 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 menciones throw sin try block resultando en una llamada implícita para abortar:

Si no se está manejando ninguna excepción, ejecutar un expresión throw sin llamadas a operando std:: terminate ()

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

*( ( char* ) NULL ) = 0;

Esto producirá un error de segmentación.

¿Qué pasa con el desbordamiento de pila por una llamada al 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

Esta es una versión más garantizada de abortar presentada anteriormente answers.It se encarga de la situación cuando sigabrt está bloqueado.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();
}

Esta falta:

int main = 42;

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 compila muy bien bajo GCC 4.4.3 Esto probablemente causará una SIGFPE (excepción de coma flotante), que quizás no sea tan probable en una aplicación real como SIGSEGV (violación de segmentación de memoria) como las otras respuestas, pero sigue siendo un bloqueo. 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, a contraste con SIGSEGV.

int* p=0;
*p=0;

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

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

Este es el fragmento proporcionado por Google en Breakpad.

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

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

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

Lo he probado 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 vagón de la banda.

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

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

Imprime:

Falla de segmentación (núcleo volcado)

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 bloquee. Aclamaciones.

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

Una forma elegante de hacer esto es una llamada a una 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 llamada sin una excepción activa

Abortado (núcleo volcado)

Uno que aún no ha sido 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 esto bloquee el programa, pero las posibilidades de que el sistema operativo permita que esto no se controle y de que el programa regrese son insignificantes.

char*freeThis;
free(freeThis);

Liberar un puntero no iniciado es un comportamiento indefinido. En muchas plataformas/compiladores, freeThis tendrá un valor aleatorio (lo que estaba en esa ubicación de memoria antes). Liberarlo le pedirá al sistema que libere la memoria en esa dirección, lo que generalmente causará un error de segmentación y hará que el programa se bloquee.