วิธีสิ้นสุดรหัส C ++

ฉันต้องการให้รหัส C ++ หยุดทำงานหากตรงตามเงื่อนไขบางประการ แต่ฉันไม่แน่ใจว่าจะทำอย่างไร ดังนั้น ณ จุดใดถ้าifคำสั่งเป็นจริงยุติโค้ดเช่นนี้:

if (x==1)
{
    kill code;
}

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

ไร่และคลี่คลายคลี่คลาย

C ++ ใช้ประโยชน์จากสำนวนที่เรียกว่าRAIIซึ่งในแง่ง่ายๆหมายความว่าวัตถุควรทำการเริ่มต้นในตัวสร้างและการล้างข้อมูลใน destructor ตัวอย่างเช่นstd::ofstreamคลาส [อาจ] เปิดไฟล์ในระหว่างตัวสร้างจากนั้นผู้ใช้ทำการดำเนินการกับมันและในที่สุดในตอนท้ายของวงจรชีวิตของมันมักจะถูกกำหนดโดยขอบเขตของมัน destructor ที่เรียกว่าปิดไฟล์และวูบวาบ เนื้อหาที่เป็นลายลักษณ์อักษรใด ๆ ลงในดิสก์

จะเกิดอะไรขึ้นถ้าคุณไม่ไปที่ destructor เพื่อล้างข้อมูลและปิดไฟล์ ใครจะรู้! แต่อาจจะไม่เขียนข้อมูลทั้งหมดที่ควรจะเขียนลงในไฟล์

เช่นพิจารณารหัสนี้

#include <fstream>
#include <exception>
#include <memory>

void inner_mad()
{
    throw std::exception();
}

void mad()
{
    auto ptr = std::make_unique<int>();
    inner_mad();
}

int main()
{
    std::ofstream os("file.txt");
    os << "Content!!!";

    int possibility = /* either 1, 2, 3 or 4 */;

    if(possibility == 1)
        return 0;
    else if(possibility == 2)
        throw std::exception();
    else if(possibility == 3)
        mad();
    else if(possibility == 4)
        exit(0);
}

เกิดอะไรขึ้นในแต่ละความเป็นไปได้คือ:

• ความเป็นไปได้ที่ 1: การส่งคืนจะออกจากขอบเขตของฟังก์ชันปัจจุบันดังนั้นจึงทราบเกี่ยวกับจุดสิ้นสุดของวงจรชีวิตของการosเรียกใช้ destructor และทำการล้างข้อมูลที่เหมาะสมโดยการปิดและล้างแฟ้มไปยังดิสก์
• ความเป็นไปได้ที่ 2: การโยนข้อยกเว้นยังช่วยดูแลวงจรชีวิตของวัตถุในขอบเขตปัจจุบันด้วยดังนั้นการทำความสะอาดที่เหมาะสม ...
• ความเป็นไปได้ที่ 3: ที่นี่สแต็คคลี่คลายเข้าสู่การกระทำ! แม้ว่าข้อยกเว้นจะถูกโยนทิ้งที่inner_mad, unwinder จะไปแม้ว่าสแต็คของmadและmainจะดำเนินการล้างที่เหมาะสมวัตถุทั้งหมดจะได้รับการ destructed อย่างถูกต้องรวมทั้งและptros
• ความเป็นไปได้ที่ 4:นี่ไง exitเป็นฟังก์ชั่น C และไม่ทราบหรือไม่เข้ากันกับสำนวน C ++ มันไม่ได้ทำการล้างข้อมูลบนวัตถุของคุณรวมถึงosในขอบเขตเดียวกัน ดังนั้นไฟล์ของคุณจะไม่ถูกปิดอย่างถูกต้องและด้วยเหตุนี้เนื้อหาจึงอาจไม่ถูกเขียนลงไป!
• ความเป็นไปได้อื่น ๆ :มันจะออกจากขอบเขตหลักโดยการดำเนินการโดยปริยายreturn 0และทำให้มีผลเช่นเดียวกับความเป็นไปได้ 1 เช่นการล้างที่เหมาะสม

แต่ไม่แน่ใจเกี่ยวกับสิ่งที่ฉันเพิ่งบอกคุณ (ส่วนใหญ่เป็นไปได้ที่ 2 และ 3); อ่านต่อและเราจะค้นหาวิธีดำเนินการล้างข้อมูลตามข้อยกเว้นที่เหมาะสม

วิธีที่เป็นไปได้เพื่อยุติ

กลับจากหลัก!

คุณควรทำเช่นนี้ทุกครั้งที่ทำได้ ต้องการกลับจากโปรแกรมของคุณเสมอโดยส่งคืนสถานะทางออกที่เหมาะสมจากหลัก

ผู้เรียกโปรแกรมของคุณและอาจเป็นระบบปฏิบัติการอาจต้องการทราบว่าสิ่งที่โปรแกรมของคุณควรทำเสร็จเรียบร้อยหรือไม่ ด้วยเหตุผลเดียวกันนี้คุณควรส่งคืนค่าศูนย์หรือEXIT_SUCCESSเพื่อส่งสัญญาณว่าโปรแกรมสิ้นสุดลงอย่างสมบูรณ์และEXIT_FAILUREเพื่อส่งสัญญาณว่าโปรแกรมหยุดทำงานไม่สำเร็จรูปแบบอื่น ๆ ของค่าตอบแทนจะถูกกำหนดโดยการนำไปใช้ ( §18.5 / 8 )

อย่างไรก็ตามคุณอาจจะลึกมากในสแต็คการโทรและการคืนทั้งหมดอาจเจ็บปวด ...

[อย่า] โยนข้อยกเว้น

การโยนข้อยกเว้นจะทำการล้างวัตถุที่เหมาะสมโดยใช้การคลี่คลายคลี่คลายโดยการเรียก destructor ของทุกวัตถุในขอบเขตก่อนหน้าใด ๆ

แต่นี่คือการจับ ! มันถูกกำหนดให้มีการนำไปใช้งานไม่ว่าจะทำการคลี่คลายสแต็กหรือไม่เมื่อข้อยกเว้นที่ส่งออกมานั้นไม่ได้รับการจัดการ(โดยประโยค catch (... ))หรือแม้ว่าคุณจะมีnoexceptฟังก์ชั่นอยู่ตรงกลางของ call stack นี่คือที่ระบุไว้ใน§15.5.1 [ยกเว้น.terminate] :

1. ในบางสถานการณ์การจัดการข้อยกเว้นต้องถูกทอดทิ้งสำหรับเทคนิคการจัดการข้อผิดพลาดที่ละเอียดน้อยกว่า [หมายเหตุ: สถานการณ์เหล่านี้คือ:

   [ ... ]

   - เมื่อกลไกการจัดการข้อยกเว้นไม่สามารถหาตัวจัดการสำหรับข้อยกเว้นโยน (15.3) หรือเมื่อการค้นหาตัวจัดการ (15.3) พบบล็อกด้านนอกสุดของฟังก์ชั่นที่มีnoexcept-specificationที่ไม่อนุญาตข้อยกเว้น (15.4) หรือ [ ... ]

   [ ... ]

2. ในกรณีเช่นนี้ std :: terminate () ถูกเรียก (18.8.3) ในสถานการณ์ที่ไม่พบตัวจัดการที่ตรงกันจะมีการกำหนดการนำไปใช้หรือไม่สแต็กไม่ถูกคลายออกก่อนที่ std :: terminate () จะถูกเรียกว่า [... ]

ดังนั้นเราต้องจับมัน!

อย่าโยนข้อยกเว้นและจับมันเป็นหลัก!

เนื่องจากข้อยกเว้นที่ไม่ถูกตรวจจับอาจไม่ทำการคลายสแต็ก(และดังนั้นจะไม่ทำการล้างข้อมูลที่เหมาะสม)เราควรตรวจจับข้อยกเว้นในหลักแล้วจึงกลับสถานะการออก ( EXIT_SUCCESSหรือEXIT_FAILURE)

ดังนั้นการตั้งค่าที่ดีน่าจะเป็น:

int main()
{
    /* ... */
    try
    {
        // Insert code that will return by throwing a exception.
    }
    catch(const std::exception&)  // Consider using a custom exception type for intentional
    {                             // throws. A good idea might be a `return_exception`.
        return EXIT_FAILURE;
    }
    /* ... */
}

[อย่า] std :: exit

สิ่งนี้ไม่ทำการคลี่คลายการเรียงลำดับใด ๆ และไม่มีวัตถุใดที่มีชีวิตบนสแต็กจะเรียก destructor ที่เกี่ยวข้องเพื่อทำการล้างข้อมูล

สิ่งนี้ถูกบังคับใช้ใน§3.6.1 / 4 [basic.start.init] :

ยกเลิกโปรแกรมโดยไม่ออกจากบล็อกปัจจุบัน (เช่นโดยการเรียกฟังก์ชั่นมาตรฐาน :: ออก (int) (18.5)) ไม่ทำลายวัตถุใด ๆ ที่มีระยะเวลาการจัดเก็บข้อมูลอัตโนมัติ (12.4) ถ้า std :: exit ถูกเรียกให้จบโปรแกรมในระหว่างการทำลายวัตถุที่มีระยะเวลาคงที่หรือการจัดเก็บด้ายโปรแกรมมีพฤติกรรมที่ไม่ได้กำหนด

ลองคิดดูสิทำไมคุณจะทำสิ่งนี้ คุณมีวัตถุกี่ชิ้นที่ได้รับความเสียหายอย่างเจ็บปวด?

ทางเลือกอื่น [ไม่ดี]

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

• std::_Exit ทำให้โปรแกรมหยุดทำงานตามปกติและนั่นก็คือ
• std::quick_exitทำให้การยกเลิกโปรแกรมปกติและstd::at_quick_exitตัวจัดการการโทรไม่มีการดำเนินการล้างข้อมูลอื่น
• std::exitทำให้โปรแกรมหยุดทำงานปกติแล้วเรียกเครื่องมือstd::atexitจัดการ การล้างข้อมูลประเภทอื่น ๆ จะดำเนินการเช่นการเรียก destructors วัตถุคงที่
• std::abortทำให้โปรแกรมหยุดทำงานผิดปกติไม่มีการล้างข้อมูล สิ่งนี้ควรถูกเรียกใช้หากโปรแกรมสิ้นสุดลงด้วยวิธีที่ไม่คาดคิดจริงๆ มันจะไม่ทำอะไรเลยนอกจากส่งสัญญาณระบบปฏิบัติการเกี่ยวกับการเลิกจ้างที่ผิดปกติ บางระบบดำเนินการถ่ายโอนข้อมูลหลักในกรณีนี้
• std::terminateโทรstd::terminate_handlerที่โทรstd::abortตามค่าเริ่มต้น

ดังที่มาร์ตินยอร์กเอ่ยถึงทางออกไม่จำเป็นต้องทำความสะอาดเหมือนกลับมา

จะดีกว่าเสมอหากใช้ผลตอบแทนในตำแหน่งทางออก ในกรณีที่คุณไม่ได้อยู่ในหลักไม่ว่าคุณต้องการออกจากโปรแกรมใดให้กลับไปที่หน้าหลักก่อน

ลองพิจารณาตัวอย่างด้านล่าง ด้วยโปรแกรมต่อไปนี้ไฟล์จะถูกสร้างขึ้นด้วยเนื้อหาที่กล่าวถึง แต่ถ้าส่งคืนความคิดเห็น & uncommented exit (0) คอมไพเลอร์ไม่รับรองว่าไฟล์จะมีข้อความที่ต้องการ

int main()
{
    ofstream os("out.txt");
    os << "Hello, Can you see me!\n";
    return(0);
    //exit(0);
}

ไม่เพียงแค่นี้การมีจุดออกหลายจุดในโปรแกรมจะทำให้การดีบักยากขึ้น ใช้ exit เท่านั้นเมื่อสามารถพิสูจน์ได้

เรียกใช้std::exitฟังก์ชัน   

ผู้คนกำลังพูดว่า "call exit (return code)" แต่นี่เป็นรูปแบบที่ไม่ดี ในโปรแกรมขนาดเล็กมันใช้ได้ แต่มีปัญหาหลายประการ:

1. คุณจะพบว่ามีหลายจุดออกจากโปรแกรม
2. มันทำให้รหัสซับซ้อนมากขึ้น (เช่นการใช้ goto)
3. ไม่สามารถปล่อยหน่วยความจำที่จัดสรรในรันไทม์

จริงๆแล้วครั้งเดียวที่คุณควรจะออกจากปัญหาคือใช้บรรทัดนี้ใน main.cpp:

return 0;

หากคุณใช้ exit () เพื่อจัดการข้อผิดพลาดคุณควรเรียนรู้เกี่ยวกับข้อยกเว้น (และข้อยกเว้นการซ้อน) เป็นวิธีที่สวยงามและปลอดภัยกว่า

return 0;ใส่ที่ใดก็ตามที่คุณต้องการภายในint main()และโปรแกรมจะปิดทันที

โปรแกรมจะยุติการทำงานเมื่อโฟลว์การดำเนินการสิ้นสุดฟังก์ชันหลัก

หากต้องการยกเลิกก่อนหน้านี้คุณสามารถใช้ฟังก์ชัน exit (int status) โดยที่ status คือค่าที่ส่งคืนไปยังทุกอย่างที่เริ่มต้นโปรแกรม 0 โดยปกติหมายถึงสถานะที่ไม่ใช่ข้อผิดพลาด

ส่งคืนค่าจากคุณmainหรือใช้exitฟังก์ชัน ทั้งคู่ใช้ int ไม่สำคัญว่าคุณจะส่งคืนค่าใดเว้นแต่ว่าคุณมีกระบวนการภายนอกที่คอยดูค่าที่ส่งคืน

หากคุณมีข้อผิดพลาดที่ลึกลงไปในรหัสแล้วโยนข้อยกเว้นหรือตั้งรหัสข้อผิดพลาด เป็นการดีกว่าเสมอที่จะโยนข้อยกเว้นแทนที่จะตั้งรหัสข้อผิดพลาด

โดยทั่วไปคุณจะใช้exit()วิธีการที่เหมาะสมกับสถานะทางออก

Zero หมายถึงการประสบความสำเร็จ สถานะที่ไม่เป็นศูนย์ระบุว่ามีปัญหาเกิดขึ้น รหัสทางออกนี้ใช้โดยกระบวนการหลัก (เช่นเชลล์สคริปต์) เพื่อตรวจสอบว่ากระบวนการทำงานสำเร็จหรือไม่

นอกเหนือจากการเรียก exit (error_code) - ซึ่งเรียกใช้ตัวจัดการ atexit แต่ไม่ใช่ destructors RAII เป็นต้น - มากขึ้นเรื่อย ๆ ฉันใช้ข้อยกเว้น

ดูเหมือนโปรแกรมหลักของฉันจะมากขึ้นเรื่อย ๆ

int main(int argc, char** argv) 
{
    try {
        exit( secondary_main(argc, argv );
    }
    catch(...) {
        // optionally, print something like "unexpected or unknown exception caught by main"
        exit(1);
    }
}

โดยที่ secondary_main ซึ่งทุกสิ่งที่ถูกวางไว้ในตอนแรก - นั่นคือเปลี่ยนชื่อเดิมเป็น secondary_main และเพิ่ม stub main ไว้ด้านบน นี่เป็นเพียงความดีเพื่อให้มีรหัสไม่มากเกินไประหว่างถาดและตรวจจับในหลัก

ถ้าคุณต้องการจับชนิดข้อยกเว้นอื่น ๆ
ฉันชอบจับประเภทข้อผิดพลาดของสตริงเช่น std :: string หรือ char * และพิมพ์ที่ตัวจัดการ catch ใน main

การใช้ข้อยกเว้นเช่นนี้อย่างน้อยจะทำให้มีตัวเรียกใช้ตัวทำลาย RAII เพื่อให้สามารถล้างข้อมูลได้ ซึ่งน่าพอใจและมีประโยชน์

โดยรวมแล้วการจัดการข้อผิดพลาด C - ออกและสัญญาณ - และการจัดการข้อผิดพลาด C ++ - ลอง / จับ / โยนข้อยกเว้น - เล่นด้วยกันอย่างไม่สอดคล้องกันอย่างดีที่สุด

จากนั้นที่คุณตรวจพบข้อผิดพลาด

throw "error message"

หรือประเภทข้อยกเว้นที่เฉพาะเจาะจงมากขึ้น

หากคำสั่ง if ของคุณอยู่ในลูปคุณสามารถใช้

 break; 

หากคุณต้องการหลีกเลี่ยงรหัสบางอย่างและใช้การวนซ้ำต่อไป:

ยังคง;

หากข้อความ if ของคุณไม่อยู่ในลูปคุณสามารถใช้:

 return 0;

Or 




  exit();

exit()ฟังก์ชั่นDude ... ถูกกำหนดไว้ภายใต้ stdlib.h

ดังนั้นคุณต้องเพิ่มตัวประมวลผลล่วงหน้า

ใส่include stdlib.hในส่วนหัว

จากนั้นใช้exit();ที่ใดก็ได้ที่คุณต้องการ แต่อย่าลืมใส่หมายเลข interger ไว้ในวงเล็บของทางออก

ตัวอย่างเช่น:

exit(0);

หากเงื่อนไขที่ฉันทดสอบเป็นข่าวร้ายจริง ๆ ฉันจะทำสิ่งนี้:

*(int*) NULL= 0;

สิ่งนี้ทำให้ฉันมี coredump ที่ดีจากที่ฉันสามารถตรวจสอบสถานการณ์

ในการทำลายเงื่อนไขให้ใช้ return (0);

ดังนั้นในกรณีของคุณมันจะเป็น:

    if(x==1)
    {
        return 0;
    }