Cách kết thúc mã C ++

Tôi muốn mã C ++ của tôi ngừng chạy nếu đáp ứng một điều kiện nhất định, nhưng tôi không chắc làm thế nào để làm điều đó. Vì vậy, tại bất kỳ thời điểm nào nếu một iftuyên bố là đúng chấm dứt mã như thế này:

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

Có một số cách, nhưng trước tiên bạn cần hiểu tại sao việc dọn dẹp đối tượng lại quan trọng và do đó lý do std::exitbị gạt ra ngoài lề giữa các lập trình viên C ++.

RAII và Stack Unwinding

C ++ sử dụng một thành ngữ gọi là RAII , trong thuật ngữ đơn giản có nghĩa là các đối tượng nên thực hiện khởi tạo trong hàm tạo và dọn dẹp trong hàm hủy. Ví dụ, std::ofstreamlớp [có thể] mở tệp trong hàm tạo, sau đó người dùng thực hiện các thao tác đầu ra trên nó và cuối cùng ở cuối vòng đời của nó, thường được xác định bởi phạm vi của nó, hàm hủy được gọi là về cơ bản đóng tệp và xả bất kỳ nội dung bằng văn bản vào đĩa.

Điều gì xảy ra nếu bạn không truy cập vào hàm hủy để xóa và đóng tệp? Ai biết! Nhưng có lẽ nó sẽ không ghi tất cả dữ liệu mà nó được cho là ghi vào tệp.

Ví dụ, hãy xem xét mã này

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

Điều gì xảy ra trong mỗi khả năng là:

• Khả năng 1: Trả về cơ bản rời khỏi phạm vi chức năng hiện tại, vì vậy nó biết về sự kết thúc của vòng đời osdo đó gọi hàm hủy của nó và thực hiện dọn dẹp đúng cách bằng cách đóng và xả tệp vào đĩa.
• Khả năng 2: Ném một ngoại lệ cũng đảm nhiệm vòng đời của các đối tượng trong phạm vi hiện tại, do đó thực hiện dọn dẹp đúng cách ...
• Khả năng 3: Ở đây stack uninding đi vào hành động! Mặc dù ngoại lệ được ném vào inner_mad, trình duyệt sẽ chuyển qua ngăn xếp madvà mainđể thực hiện dọn dẹp đúng cách, tất cả các đối tượng sẽ bị phá hủy đúng cách, bao gồm ptrvà os.
• Khả năng 4: Vâng, đây? exitlà một hàm C và nó không nhận biết cũng không tương thích với các thành ngữ C ++. Nó không thực hiện dọn dẹp trên các đối tượng của bạn, kể cả ostrong cùng một phạm vi. Vì vậy, tệp của bạn sẽ không được đóng đúng cách và vì lý do này, nội dung có thể không bao giờ được ghi vào đó!
• Các khả năng khác: Nó sẽ chỉ để lại phạm vi chính, bằng cách thực hiện một ẩn return 0và do đó có tác dụng tương tự như khả năng 1, tức là dọn dẹp đúng cách.

Nhưng đừng quá chắc chắn về những gì tôi vừa nói với bạn (chủ yếu là khả năng 2 và 3); tiếp tục đọc và chúng tôi sẽ tìm hiểu làm thế nào để thực hiện dọn dẹp dựa trên ngoại lệ thích hợp.

Những cách có thể kết thúc

Trở về từ chính!

Bạn nên làm điều này bất cứ khi nào có thể; luôn luôn thích quay lại chương trình của bạn bằng cách trả về trạng thái thoát thích hợp từ chính.

Người gọi chương trình của bạn, và có thể là hệ điều hành, có thể muốn biết liệu chương trình của bạn được thực hiện có thành công hay không. Vì lý do tương tự, bạn nên trả về 0 hoặc EXIT_SUCCESSđể báo hiệu rằng chương trình đã kết thúc thành công và EXIT_FAILUREđể báo hiệu chương trình kết thúc không thành công, bất kỳ hình thức giá trị trả về nào khác đều được xác định theo thực hiện ( §18.5 / 8 ).

Tuy nhiên, bạn có thể rất sâu trong ngăn xếp cuộc gọi và trả lại tất cả số đó có thể gây đau đớn ...

[Đừng] ném ngoại lệ

Ném một ngoại lệ sẽ thực hiện dọn dẹp đối tượng thích hợp bằng cách sử dụng ngăn xếp ngăn xếp, bằng cách gọi hàm hủy của mọi đối tượng trong bất kỳ phạm vi nào trước đó.

Nhưng đây là cái bẫy ! Nó được xác định theo thực thi cho dù việc hủy xếp chồng được thực hiện khi một ngoại lệ bị ném không được xử lý (bởi mệnh đề Catch (...)) hoặc ngay cả khi bạn có một noexcepthàm ở giữa ngăn xếp cuộc gọi. Điều này được nêu trong §15.5.1 [trừ.terminate] :

1. Trong một số tình huống xử lý ngoại lệ phải được bỏ qua cho các kỹ thuật xử lý lỗi kém tinh tế. [Lưu ý: Những tình huống này là:

   [...]

   - khi cơ chế xử lý ngoại lệ không thể tìm thấy một handler cho một ngoại lệ ném (15.3), hoặc khi việc tìm kiếm một handler (15.3) gặp khối ngoài cùng của một hàm với một noexcept-specification rằng không cho phép ngoại lệ (15,4), hoặc [...]

   [...]

2. Trong các trường hợp như vậy, std :: terminating () được gọi là (18.8.3). Trong trường hợp không tìm thấy trình xử lý phù hợp, nó được xác định theo thực thi cho dù ngăn xếp có bị hủy hay không trước khi std :: terminating () được gọi là [...]

Vì vậy, chúng ta phải bắt nó!

Đừng ném một ngoại lệ và bắt nó ở chính!

Vì các trường hợp ngoại lệ chưa được thực hiện có thể không thực hiện hủy bỏ ngăn xếp (và do đó sẽ không thực hiện dọn dẹp đúng cách) , chúng ta nên bắt ngoại lệ trong chính và sau đó trả về trạng thái thoát ( EXIT_SUCCESShoặc EXIT_FAILURE).

Vì vậy, một thiết lập có thể tốt sẽ là:

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;
    }
    /* ... */
}

[Đừng] std :: thoát

Điều này không thực hiện bất kỳ loại ngăn xếp ngăn xếp nào và không có đối tượng còn sống nào trên ngăn xếp sẽ gọi hàm hủy tương ứng của nó để thực hiện dọn dẹp.

Điều này được thi hành trong §3.6.1 / 4 [basic.start.init] :

Việc kết thúc chương trình mà không rời khỏi khối hiện tại (ví dụ: bằng cách gọi hàm std :: exit (int) (18.5)) không phá hủy bất kỳ đối tượng nào có thời gian lưu trữ tự động (12.4) . Nếu std :: exit được gọi để kết thúc chương trình trong quá trình hủy đối tượng có thời gian lưu trữ tĩnh hoặc luồng, chương trình có hành vi không xác định.

Hãy suy nghĩ về nó bây giờ, tại sao bạn sẽ làm một điều như vậy? Có bao nhiêu đồ vật đã làm bạn đau đớn?

Các lựa chọn thay thế [xấu khác]

Có nhiều cách khác để chấm dứt chương trình (trừ sự cố) , nhưng chúng không được khuyến nghị. Chỉ để làm rõ, họ sẽ được trình bày ở đây. Lưu ý cách kết thúc chương trình bình thường không có nghĩa là ngăn xếp ngăn xếp mà là trạng thái ổn cho hệ điều hành.

• std::_Exit gây ra chấm dứt chương trình bình thường, và đó là nó.
• std::quick_exitgây ra chấm dứt chương trình bình thường và gọi std::at_quick_exittrình xử lý, không thực hiện dọn dẹp nào khác.
• std::exitgây ra một chấm dứt chương trình bình thường và sau đó gọi std::atexitxử lý. Các loại dọn dẹp khác được thực hiện như gọi các hàm hủy đối tượng tĩnh.
• std::abortgây ra một chấm dứt chương trình bất thường, không có dọn dẹp được thực hiện. Điều này nên được gọi nếu chương trình kết thúc một cách thực sự, thực sự bất ngờ. Nó sẽ không làm gì ngoài việc báo hiệu cho HĐH về việc chấm dứt bất thường. Một số hệ thống thực hiện một bãi chứa lõi trong trường hợp này.
• std::terminategọi các std::terminate_handlercuộc gọi std::aborttheo mặc định.

Như Martin York đã đề cập, lối ra không thực hiện việc dọn dẹp cần thiết như trả lại.

Luôn luôn tốt hơn để sử dụng trở lại ở nơi thoát. Trong trường hợp nếu bạn không ở trong main, bất cứ nơi nào bạn muốn thoát khỏi chương trình, hãy quay lại main trước.

Hãy xem xét ví dụ dưới đây. Với chương trình sau, một tệp sẽ được tạo với nội dung được đề cập. Nhưng nếu trả về được nhận xét & thoát không ghi chú (0), trình biên dịch không đảm bảo với bạn rằng tệp sẽ có văn bản được yêu cầu.

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

Không chỉ thế này, việc có nhiều điểm thoát trong một chương trình sẽ khiến việc gỡ lỗi khó khăn hơn. Chỉ sử dụng lối thoát khi nó có thể được biện minh.

Gọi std::exithàm.   

Mọi người đang nói "thoát cuộc gọi (mã trả về)", nhưng đây là hình thức xấu. Trong các chương trình nhỏ thì tốt, nhưng có một số vấn đề với điều này:

1. Cuối cùng, bạn sẽ có nhiều điểm thoát khỏi chương trình
2. Nó làm cho mã phức tạp hơn (như sử dụng goto)
3. Nó không thể giải phóng bộ nhớ được phân bổ trong thời gian chạy

Thực sự, lần duy nhất bạn nên thoát vấn đề là với dòng này trong main.cpp:

return 0;

Nếu bạn đang sử dụng exit () để xử lý lỗi, bạn nên tìm hiểu về các ngoại lệ (và ngoại lệ lồng nhau), như một phương pháp thanh lịch và an toàn hơn nhiều.

return 0;đặt bất cứ nơi nào bạn muốn trong int main()và chương trình sẽ ngay lập tức đóng lại.

Chương trình sẽ chấm dứt khi luồng thực thi đạt đến cuối chức năng chính.

Để chấm dứt nó trước đó, bạn có thể sử dụng hàm exit (int status), trong đó trạng thái là một giá trị được trả về bất cứ thứ gì bắt đầu chương trình. 0 thường biểu thị trạng thái không lỗi

Hoặc trả về một giá trị từ của bạn mainhoặc sử dụng exithàm. Cả hai lấy một int. Việc bạn trả về giá trị nào thực sự không quan trọng trừ khi bạn có quy trình bên ngoài đang theo dõi giá trị trả về.

Nếu bạn gặp lỗi ở đâu đó sâu trong mã, thì hãy ném ngoại lệ hoặc đặt mã lỗi. Luôn luôn tốt hơn để ném một ngoại lệ thay vì đặt mã lỗi.

Nói chung, bạn sẽ sử dụng exit()phương thức với trạng thái thoát thích hợp .

Zero có nghĩa là một hoạt động thành công. Một trạng thái khác không cho thấy một số loại vấn đề đã xảy ra. Mã thoát này được sử dụng bởi các quy trình cha (ví dụ: shell script) để xác định xem một quy trình đã chạy thành công chưa.

Ngoài việc gọi thoát (error_code) - gọi trình xử lý atexit, nhưng không phải là hàm hủy RAII, v.v. - ngày càng nhiều tôi đang sử dụng các ngoại lệ.

Càng ngày chương trình chính của tôi càng giống

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

trong đó junior_main trong đó tất cả những thứ ban đầu được đặt - tức là main ban đầu được đổi tên thành junior_main, và main stub ở trên được thêm vào. Đây chỉ là một tính năng tốt, do đó không có quá nhiều mã giữa khay và bắt chính.

Nếu bạn muốn, bắt các loại ngoại lệ khác.
Tôi khá thích bắt các loại lỗi chuỗi, như std :: string hoặc char *, và in các lỗi trong trình xử lý bắt chính.

Sử dụng các ngoại lệ như thế này ít nhất cho phép các hàm hủy RAII được gọi, để chúng có thể dọn dẹp. Mà có thể dễ chịu và hữu ích.

Nhìn chung, xử lý lỗi C - thoát và tín hiệu - và xử lý lỗi C ++ - ngoại lệ thử / bắt / ném - chơi với nhau không nhất quán ở mức tốt nhất.

Sau đó, nơi bạn phát hiện ra một lỗi

throw "error message"

hoặc một số loại ngoại lệ cụ thể hơn.

Nếu câu lệnh if của bạn nằm trong Loop Bạn có thể sử dụng

 break; 

Nếu bạn muốn thoát một số mã và tiếp tục lặp lại Sử dụng:

tiếp tục;

Nếu câu lệnh if của bạn không có trong Loop Bạn có thể sử dụng:

 return 0;

Or 




  exit();

exit()Hàm ... anh chàng được định nghĩa theo stdlib.h

Vì vậy, bạn cần thêm một bộ tiền xử lý.

Đặt include stdlib.htrong phần tiêu đề

Sau đó sử dụng exit();bất cứ nơi nào bạn thích nhưng nhớ đặt một số interger trong ngoặc đơn của lối ra.

ví dụ:

exit(0);

Nếu điều kiện tôi đang thử nghiệm thực sự là tin xấu, tôi sẽ làm điều này:

*(int*) NULL= 0;

Điều này mang lại cho tôi một coredump tốt đẹp từ nơi tôi có thể kiểm tra tình hình.

Để phá vỡ một điều kiện, sử dụng return (0);

Vì vậy, trong trường hợp của bạn, nó sẽ là:

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