Який найпростіший спосіб зробити збій програми C ++?

Я намагаюся зробити програму Python, яка взаємодіє з різними аварійними процесами (це не в моїх руках). На жаль, програма, з якою я взаємодію, навіть не дає краху надійно! Тому я хочу зробити швидку програму C ++, яка спеціально виходить з ладу, але я насправді не знаю найкращого та найкоротшого способу зробити це, хтось знає, що між моїм:

int main() {
    crashyCodeGoesHere();
}

щоб надійно вийти з ладу моя програма C ++

Ця abort()функція, мабуть, найкраща для вас. Він є частиною стандартної бібліотеки С і визначається як "спричинення ненормального припинення програми" (наприклад, фатальна помилка або збій).

Спробуйте:

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

Знайдено в:

#include <signal.h>

Поділ на нуль призведе до краху програми:

int main()
{
    return 1 / 0;
}

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

Що ж, ми перебуваємо в переповненні стека , чи ні?

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

(Не гарантується збій за будь-якими стандартами, але жоден із запропонованих відповідей, включаючи прийнятий, оскільки SIGABRTміг би бути спійманий у будь-якому випадку. На практиці це буде повсюдно.)

 throw 42;

Просто відповідь ... :)

assert(false); дуже добре теж.

Відповідно до ISO / IEC 9899: 1999 гарантується збій, коли NDEBUG не визначено:

Якщо NDEBUG визначений [...], макрос затвердження визначається просто як

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

Макрос затвердження перевизначається відповідно до поточного стану NDEBUG кожного разу, коли він включається.

[...]

Макрос затвердження встановлює діагностичні тести в програми; [...] якщо вираз (який має скалярний тип) є хибним [...]. Потім він викликає функцію переривання.

Оскільки збій є симптомом виклику невизначеної поведінки, а оскільки виклик невизначеної поведінки може призвести до чого завгодно, в тому числі до збоїв, я не думаю, що ви дійсно хочете зірвати вашу програму, а просто впадете в налагоджувач. Напевно, найбільш портативний спосіб зробити це abort().

Хоча raise(SIGABRT)має той же ефект, писати, безумовно, більше. Однак обидва способи можуть бути перехоплені, встановивши обробник сигналу для SIGABRT. Отже, залежно від вашої ситуації, вам може знадобитися підняти ще один сигнал. SIGFPE, SIGILL, SIGINT, SIGTERMАбо SIGSEGVможе бути шлях, але всі вони можуть бути перехоплені.

Коли ви можете бути невідповідними, ваш вибір може бути ще ширшим, як, наприклад, використання SIGBUSв Linux.

Єдиний спалах, який я мав, - це функція abort () :

Він припиняє процес з ненормальним завершенням програми. Він генерує сигнал SIGABRT , який за замовчуванням змушує програму припиняти повернення невдалого коду помилки припинення в середовище хоста. Програма припиняється без виконання деструкторів для об'єктів автоматичної або статичної тривалості зберігання. , і не викликаючи жодної функції atexit (яка викликається випуском () до завершення програми). Він ніколи не повертається до свого абонента.

Відповідь конкретна для платформи і залежить від ваших цілей. Але ось функція збоїв у Mozilla Javascript, яка, на мою думку, ілюструє безліч труднощів у виконанні цієї роботи:

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
}

Я бачу, що тут розміщено багато відповідей, які потраплять у щасливі випадки, коли можна виконати роботу, але жоден з них не на 100% детермінований для краху. Деякі вийдуть з ладу на одному апаратному забезпеченні та ОС, інші не будуть. Однак існує стандартний спосіб, згідно з офіційним стандартом C ++, щоб зробити його крахом.

Цитуючи з C ++ стандарту ISO / IEC 14882 §15.1-7 :

Якщо механізм обробки винятків, після завершення ініціалізації об'єкта винятку, але до активації обробника для винятку, викликає функцію, яка виходить через виняток, викликається std :: термінація (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) { }
}

Я написав невеликий код, щоб продемонструвати це, і його можна знайти та спробувати на Ideone тут .

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 згадує кидок без спроб блоку, що призводить до неявного виклику перервати:

Якщо зараз не обходиться жоден виняток, виконуючи вираз викиду без викликів операнда std :: terminate ()

До інших належать: кидок із руйнівника: ISO / IEC 14882 §15.2 / 3

*( ( char* ) NULL ) = 0;

Це призведе до помилки сегментації.

Цього немає:

int main = 42;

Що з переповненням стека викликом методу рекурсивного методу?

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

Дивіться оригінальний приклад в Microsoft KB

Це виходить з ладу в моїй системі Linux, тому що рядкові літерали зберігаються в пам'яті лише для читання:

0[""]--;

До речі, g ++ відмовляється компілювати це. Компілятори стають розумнішими та розумнішими :)

int i = 1 / 0;

Ваш компілятор, ймовірно, попередить вас про це, але він компілюється чудово під GCC 4.4.3 Це, ймовірно, спричинить SIGFPE (виняток з плаваючою комою), що, можливо, не є таким імовірним у реальній програмі, як SIGSEGV (порушення сегментації пам'яті), як інші відповіді викликають, але це все-таки крах. На мою думку, це набагато читабельніше.

Ще один спосіб, якщо ми збираємося обманювати і використовувати signal.h, це:

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

Це гарантовано знищить підпроцес, на відміну від SIGSEGV.

Це більш гарантована версія переривання, представлена ​​у вищезазначених відповідях. Вона піклується про ситуацію, коли сигабрт заблокований. Ви можете замість перерви застосувати будь-який сигнал замість переривання, який має за замовчуванням збій програми.

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

Це також повинно бути аварійним. У Windows він виходить з ладу з AccessViolation, і він повинен робити те саме на всіх ОС, я думаю.

Це фрагмент, наданий Google в 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;
}

Хоча на це питання вже є прийнята відповідь ...

void main(){
    throw 1;
}

Або ... void main(){throw 1;}

Запис у пам'ять, доступну лише для читання, спричинить помилку сегментації, якщо ваша система не підтримує блоки пам'яті лише для читання.

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

Я протестував його з MingGW 5.3.0 на Windows 7 і GCC на Linux Mint. Я припускаю, що інші компілятори та системи дадуть подібний ефект.

Або іншим способом, оскільки ми перебуваємо на фургоні.

Прекрасний шматок нескінченної рекурсії. Гарантовано підірвати ваш стек.

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

Друкує:

Помилка сегментації (ядро скинуто)

Той, про який ще не було сказано:

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

Це буде розглядати нульовий покажчик як покажчик функції, а потім викликати його. Як і більшість методів, це не гарантує збій програми, але шанси ОС, що дозволяють це не перевірити, і програма, що повертається, незначні.

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

}

Сподіваюсь, що це зазнає краху. Ура.

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

Стильний спосіб зробити це чистий віртуальний виклик функції:

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

Складений з gcc, цей принт:

чистий віртуальний метод називається

завершити виклик без активного винятку

Аборт (ядро скинуто)

Ви можете використовувати збірку у вашому c ++, code але INT 3 тільки для систем x86, інші системи можуть мати інші інструкції щодо захоплення / перерви.

int main()
{
    __asm int 3;

    return 0;
}

INT 3 викликає переривання і викликає вектор переривання, встановлений ОС.

Використовуйте __builtin_trap () у GCC чи clang, або __debugbreak () у MSVC. Якщо не працювати з цими точками переривання / пастки, це призведе до невпорядкованого виключення / аварії. Інші пропозиції, які використовують abort () або exit (): вони можуть оброблятися іншими потоками, що ускладнює бачення стека потоку, який поширює збій.

char*freeThis;
free(freeThis);

Звільнення неініціалізованого покажчика - це невизначена поведінка. На багатьох платформах / компіляторах freeThisбуде мати випадкове значення (що б там не було в цій пам'яті раніше). При звільненні він попросить систему звільнити пам'ять за цією адресою, що, як правило, призведе до помилки сегментації та призведе до збою програми.