วิธีที่ง่ายที่สุดในการทำให้โปรแกรม C ++ ผิดพลาดคืออะไร

ฉันกำลังพยายามสร้างโปรแกรม Python ที่เชื่อมต่อกับกระบวนการขัดข้องที่แตกต่างกัน น่าเสียดายที่โปรแกรมที่ฉันกำลังเชื่อมต่ออยู่นั้นไม่ได้ผิดพลาดอย่างน่าเชื่อถือ! ดังนั้นฉันต้องการสร้างโปรแกรม C ++ อย่างรวดเร็วที่ล้มเหลวในจุดประสงค์ แต่จริงๆแล้วฉันไม่รู้วิธีที่ดีที่สุดและสั้นที่สุดในการทำเช่นนั้นไม่มีใครรู้ว่าควรใส่อะไรระหว่าง:

int main() {
    crashyCodeGoesHere();
}

เพื่อทำให้โปรแกรม C ++ ของฉันทำงานล้มเหลวอย่างน่าเชื่อถือ

abort()ฟังก์ชั่นน่าจะเป็นทางออกที่ดีที่สุดของคุณ มันเป็นส่วนหนึ่งของไลบรารี่มาตรฐาน C และถูกกำหนดให้เป็น "ก่อให้เกิดการยุติโปรแกรมที่ผิดปกติ" (เช่นข้อผิดพลาดร้ายแรงหรือล้มเหลว)

ลอง:

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 [... ] แมโคร assert จะถูกกำหนดอย่างง่าย ๆ ดังนี้

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

แมโครยืนยันจะถูกกำหนดใหม่ตามสถานะปัจจุบันของ NDEBUG ทุกครั้งที่รวม

[ ... ]

แมโคร assert ทำการทดสอบวินิจฉัยลงในโปรแกรม [... ] ถ้าการแสดงออก (ซึ่งจะมีประเภทสเกลาร์) เป็นเท็จ [... ] จากนั้นจะเรียกใช้ฟังก์ชันยกเลิก

เนื่องจากความผิดพลาดเป็นอาการของการเรียกใช้พฤติกรรมที่ไม่ได้กำหนดและเนื่องจากการเรียกใช้พฤติกรรมที่ไม่ได้กำหนดสามารถนำไปสู่การใด ๆ รวมถึงความผิดพลาดฉันไม่คิดว่าคุณต้องการที่จะผิดพลาดโปรแกรมของคุณจริงๆ วิธีพกพาที่น่าทำที่สุดน่าจะเป็นabort()วิธีแบบพกพามากที่สุดในการทำเช่นนั้นอาจจะเป็น

ในขณะที่raise(SIGABRT)มีเอฟเฟกต์เหมือนกัน ทั้งสองวิธี SIGABRTแต่สามารถดักโดยการติดตั้งจัดการสัญญาณสำหรับ ดังนั้นขึ้นอยู่กับสถานการณ์ของคุณคุณอาจต้องการ / ต้องการเพิ่มสัญญาณอื่น SIGFPE,SIGILL , SIGINT, SIGTERMหรือSIGSEGVอาจจะมีวิธีที่จะไป แต่พวกเขาทั้งหมดสามารถดัก

เมื่อคุณไม่สามารถถอดออกได้ตัวเลือกของคุณอาจกว้างขึ้นเช่นใช้งานSIGBUSบน linux

แฟลชเดียวที่ฉันมีคือยกเลิก () ฟังก์ชั่น :

มันยกเลิกกระบวนการที่มีการยกเลิกโปรแกรมที่ผิดปกติซึ่งจะสร้างสัญญาณ SIGABRTซึ่งโดยปกติจะทำให้โปรแกรมยุติการส่งคืนรหัสข้อผิดพลาดการเลิกจ้างที่ไม่สำเร็จไปยังสภาพแวดล้อมโฮสต์โปรแกรมจะถูกยกเลิกโดยไม่ต้องดำเนินการ destructorsสำหรับวัตถุ และโดยไม่ต้องเรียกใช้atexitใด ๆ(ซึ่งถูกเรียกโดย exit () ก่อนที่โปรแกรมจะสิ้นสุด) ฟังก์ชัน มันจะไม่ส่งกลับไปยังผู้เรียก

คำตอบคือแพลตฟอร์มเฉพาะและขึ้นอยู่กับเป้าหมายของคุณ แต่นี่คือฟังก์ชันการทำงานผิดพลาดของ 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 :: ยุติ ()

คนอื่น ๆ รวมถึง: โยนจาก destructor: 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);
}

สิ่งนี้รับประกันได้ว่าจะฆ่า subprocess เพื่อเปรียบเทียบกับ SIGSEGV

นี่เป็นเวอร์ชันที่ยกเลิกการรับประกันเพิ่มเติมที่แสดงในคำตอบข้างต้นมันจะดูแลสถานการณ์เมื่อ sigabrt ถูกบล็อกคุณสามารถ infact ใช้สัญญาณใด ๆ แทนการยกเลิกที่มีการดำเนินการเริ่มต้นของการทำงานล้มเหลวของโปรแกรม

#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 BUT ของคุณINT 3เท่านั้นสำหรับระบบ x86 ระบบอื่น ๆ อาจมีคำสั่ง trap / breakpoint อื่น ๆ

int main()
{
    __asm int 3;

    return 0;
}

INT 3 ทำให้เกิดการขัดจังหวะและเรียกเวกเตอร์ขัดจังหวะที่ตั้งค่าโดยระบบปฏิบัติการ

ใช้ __builtin_trap () ใน GCC หรือเสียงดังกราวหรือ __debugbreak () ใน MSVC การไม่จัดการกับจุดพัก / กับดักเหล่านี้จะนำไปสู่ข้อยกเว้น / ข้อผิดพลาดของจุดพักที่ไม่สามารถจัดการได้ คำแนะนำอื่น ๆ ที่ใช้ abort () หรือ exit (): อาจถูกจัดการโดยเธรดอื่นทำให้ยากต่อการดูสแต็กของเธรดที่แพร่กระจายความล้มเหลว

char*freeThis;
free(freeThis);

การเพิ่มตัวชี้ที่ไม่ได้กำหนดค่าเริ่มต้นนั้นเป็นพฤติกรรมที่ไม่ได้กำหนดไว้ ในหลาย ๆ แพลตฟอร์ม / คอมไพเลอร์freeThisจะมีค่าสุ่ม (อะไรก็ตามที่อยู่ในตำแหน่งหน่วยความจำนั้นมาก่อน) การปล่อยให้ว่างจะขอให้ระบบเพิ่มหน่วยความจำตามที่อยู่นั้นซึ่งโดยปกติจะทำให้เกิดการแบ่งเซ็กเมนต์และทำให้โปรแกรมขัดข้อง