Bir C ++ program çökmesi yapmanın en kolay yolu nedir?

Farklı bir crashy süreci ile arayüz oluşturan bir Python programı yapmaya çalışıyorum (bu benim ellerim dışında). Maalesef arayüz ile kurduğum program güvenilir bir şekilde çökmüyor bile! Yani bilerek çökmesini hızlı bir C ++ programı yapmak istiyorum ama aslında bunu yapmak için en iyi ve en kısa yolu bilmiyorum, kimse benim arasında ne koymak biliyor mu:

int main() {
    crashyCodeGoesHere();
}

programımı güvenilir bir şekilde çökertmek için nasıl

abort()Fonksiyon muhtemelen en iyi bahistir. C standart kütüphanesinin bir parçasıdır ve "anormal program sonlandırmasına neden olma" olarak tanımlanır (örn. Önemli bir hata veya çökme).

Deneyin:

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

İçinde bulunan:

#include <signal.h>

Sıfıra bölmek uygulamayı kilitler:

int main()
{
    return 1 / 0;
}

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

Peki, yığın taşması üzerinde miyiz, değil miyiz?

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

(Herhangi bir standarda göre çökmesi garanti edilmez, ancak kabul edilen cevap da dahil olmak üzere önerilen cevaplardan herhangi biri SIGABRTyine de yakalanmış olabilir. Uygulamada, bu her yerde çökecektir.)

 throw 42;

Sadece cevap ... :)

assert(false); de oldukça iyi.

ISO / IEC 9899: 1999'a göre NDEBUG tanımlanmadığında çökmesi garanti edilir:

NDEBUG tanımlanmışsa [...] onaylama makrosu basitçe şu şekilde tanımlanır:

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

Assert makrosu, her dahil edildiğinde geçerli NDEBUG durumuna göre yeniden tanımlanır.

[...]

Onay makrosu, tanılama testlerini programlara yerleştirir; [...] ifade (skaler tipte olacaktır) yanlışsa [...]. Daha sonra iptal işlevini çağırır.

Bir kilitlenme, tanımlanmamış davranışları çağırmanın bir belirtisi olduğundan ve tanımlanmamış davranışları çağırmak, kilitlenme de dahil olmak üzere herhangi bir şeye yol açabileceğinden, programınızı gerçekten kilitlemek istediğinizi düşünmüyorum, ancak sadece bir hata ayıklayıcıya düşmesini sağlayın. Bunu yapmanın en taşınabilir yolu muhtemelen abort().

raise(SIGABRT)Aynı etkiye sahip olsa da, kesinlikle yazmak daha fazladır. Bununla birlikte, her iki yol da için bir sinyal işleyici takılarak önlenebilir SIGABRT. Durumunuza bağlı olarak, başka bir sinyal yükseltmek isteyebilir / ihtiyacınız olabilir. SIGFPE, SIGILL, SIGINT, SIGTERMVeya SIGSEGVgitmek için bir yol olabilir, ama hepsi ele geçirilebilir.

Portatif olamayacağınız zaman, linux'da kullanmak gibi seçenekleriniz daha da geniş olabilir SIGBUS.

Sahip olduğum tek flaş abort () işlevidir :

Bu anormal bir program termination.It proses oluşturur iptal SIGABRT sinyali varsayılan program çevreyi programı sonlandırılır konakçıya başarısız bir sonlandırma hata kodu dönen sona neden olur, yıkıcı çalıştırmadan otomatik veya statik depolama süresi nesneler için ve herhangi bir atexit (program sonlanmadan önce exit () tarafından çağrılır) işlevini çağırmadan . Asla arayanına geri dönmez.

Cevap platforma özgüdür ve hedeflerinize bağlıdır. Ama işte Mozilla Javascript kilitlenme işlevi, bence bu işi yapmak için birçok zorluğu gösteriyor:

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
}

Burada işi yapmak için şanslı vakalara düşecek birçok cevap olduğunu görüyorum, ancak hiçbiri çökmeye% 100 belirleyici değil. Bazıları bir donanım ve işletim sisteminde çökecek, diğerleri olmayacak. Ancak, resmi C ++ standardına göre çökmesini sağlamak için standart bir yol vardır.

Alıntı C ++ Standart IEC 14882 §15.1-7 ISO / :

Kural dışı durum işleme mekanizması, kural dışı durum nesnesinin başlatılmasını tamamladıktan sonra ancak kural dışı durum için bir işleyicinin etkinleştirilmesinden önce, kural dışı durum yoluyla çıkan bir işlevi çağırırsa, std :: terminate çağrılır (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) { }
}

Bunu göstermek için küçük bir kod yazdım ve burada bulunabilir ve Ideone üzerinde denenebilir .

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 , engelleme çağrısı yapılmasına neden olan deneme bloğu olmadan atıyor :

Şu anda bir istisna işlenmiyorsa, işlenen çağrısı olmadan bir atma ifadesi yürütmek std :: terminate ()

Diğerleri: yıkıcıdan atma: ISO / IEC 14882 §15.2 / 3

*( ( char* ) NULL ) = 0;

Bu bir segmentasyon hatası üretecektir.

Bu eksik:

int main = 42;

Ölü döngü özyinelemeli yöntem çağrısı ile yığın taşmasına ne dersiniz?

#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'deki Orijinal örneğe bakın

Dize değişmezleri salt okunur bellekte saklandığından, bu benim Linux sistemimde çöküyor:

0[""]--;

Bu arada, g ++ bunu derlemeyi reddediyor. Derleyiciler daha da akıllılaşıyor :)

int i = 1 / 0;

Derleyiciniz muhtemelen sizi bu konuda uyaracaktır, ancak GCC 4.4.3 altında iyi derler. Bu muhtemelen bir SIGFPE'ye (kayan nokta istisnası) neden olur; diğer cevaplar neden olur, ama yine de bir çökme. Bence bu çok daha okunaklı.

Başka bir yol, hile yapacak ve kullanacaksak signal.h:

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

Bu, SIGSEGV ile zıt olmak üzere alt süreci öldürmek için garantilidir.

Bu, yukarıdaki cevaplarda sunulan daha düşük bir garantili sürümdür. Sigabrt engellendiğinde durumla ilgilenir.

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

Bu da çökmeli. Windows'da AccessViolation ile çöküyor ve sanırım tüm işletim sistemlerinde aynı şeyi yapmalı.

Bu, Google tarafından Breakpad'de sağlanan snippet'tir.

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

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

Bu sorunun zaten kabul edilmiş bir yanıtı olmasına rağmen ...

void main(){
    throw 1;
}

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

Salt okunur bir belleğe yazmak, sisteminiz salt okunur bellek bloklarını desteklemediği sürece segmentasyon hatasına neden olur.

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

Windows 7 üzerinde MingGW 5.3.0 ve Linux Mint üzerinde GCC ile test ettim. Sanırım diğer derleyiciler ve sistemler de benzer bir etki yaratacak.

Ya da grup vagonunda olduğumuzdan beri başka bir yol.

Sonsuz bir özyineleme güzel bir parçası. Yığınızı havaya uçurmak garantilidir.

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

Çıktılar:

Segmentasyon hatası (çekirdek boşaltıldı)

Henüz bahsedilmeyen biri:

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

Bu, boş işaretçiyi bir işlev işaretçisi olarak görür ve sonra çağırır. Çoğu yöntem gibi, bunun programın çökmesi garanti edilmez, ancak işletim sisteminin bunun kontrol edilmemesine izin veren ve şimdiye kadar dönen programın şansı ihmal edilebilir.

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

}

Umarım bu çöker. Şerefe.

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

Bunu yapmanın şık bir yolu, saf bir sanal işlev çağrısıdır:

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 ile derlendi, bu yazdırır:

saf sanal yöntem denir

etkin bir istisna olmadan çağrılan sonlandır

Durduruldu (çekirdek boşaltıldı)

code Montajınızı c ++ cihazınızda kullanabilirsiniz, ancakINT 3 sadece x86 sistemleri için diğer sistemlerin diğer tuzak / kesme noktası talimatları olabilir.

int main()
{
    __asm int 3;

    return 0;
}

INT 3 bir kesmeye neden olur ve işletim sistemi tarafından ayarlanan bir kesme vektörünü çağırır.

GCC veya clang'da __builtin_trap () veya MSVC'de __debugbreak () kullanın. Bu kesme noktalarını / tuzakları işlememek işlenmemiş bir kesme noktası istisnasına / çökmesine neden olacaktır. Abort () veya exit () kullanan diğer öneriler: bunlar diğer iş parçacıkları tarafından işlenebilir ve bu da kilitlenmeyi ilerleten iş parçacığının yığınını görmeyi zorlaştırır.

char*freeThis;
free(freeThis);

Başlatılmamış bir işaretçiyi serbest bırakmak tanımlanmamış bir davranıştır. Birçok platformda / derleyicide, freeThisrastgele bir değere sahip olacaktır (daha önce o bellek konumunda ne varsa). Boşaltıldığında, sistemde genellikle bir segmentasyon hatasına neden olacak ve programın çökmesine neden olacak şekilde bu adresteki belleği boşaltması istenir.