C++ Thử-Bắt-Cuối cùng

C Thu Bat Cuoi Cung



C++ cung cấp phương thức “try-catch” để xử lý các ngoại lệ. Khi một ngoại lệ xảy ra trong chương trình C++, các phương pháp “thử bắt” này sẽ hỗ trợ chuyển điều khiển từ phần này của mã chương trình sang phần khác. Một ngoại lệ là trục trặc xuất hiện khi chương trình đang chạy. Khi một tình huống bất thường, chẳng hạn như cố gắng chia cho 0, xảy ra trong khi một chương trình đang thực thi, một ngoại lệ C++ sẽ xuất hiện và chúng tôi xử lý tình huống này bằng cách chỉ cần sử dụng phương pháp 'thử bắt' trong mã của mình. Nó chứa ba từ khóa: “thử”, “bắt” và “ném”. Từ khóa “ném” được sử dụng để ném ngoại lệ vào các phần của mã khác. Lập trình C++ không hỗ trợ chúng ta sử dụng từ khóa “cuối cùng”, nhưng chúng ta có thể sử dụng các từ khóa “thử”, “bắt” và “ném” trong mã C++.

Ví dụ 1:

“iostream” được bao gồm ở đây, tệp tiêu đề trong đó một số hàm được khai báo. Chúng tôi sử dụng các hàm được khai báo trong tệp tiêu đề này trong mã của mình, vì vậy chúng tôi đưa vào tệp tiêu đề này. Sau đó, chúng ta có “std” được đặt ở đây vì các hàm như “cin” và “cout” cũng được xác định trong đó. Chúng ta không cần nhập “std” với tất cả các hàm này nếu chúng ta thêm “không gian tên std” vào đầu mã của mình. Sau đó, hàm “main()” được gọi ở đây, hàm này còn được gọi là mã trình điều khiển của chương trình C++.

Sau đó, chúng tôi sử dụng từ khóa “thử” ở đây, trong đó chúng tôi khởi tạo “my_num1” với giá trị “35”. Ở đây là biến kiểu dữ liệu “int”. Bây giờ, chúng ta đặt biến này bên trong “if” và đặt một điều kiện cho biết “my_num1” phải lớn hơn hoặc bằng “98”. Nếu điều kiện đã cho được thỏa mãn, nó sẽ di chuyển về phía trước bên trong “if” và thực thi câu lệnh được viết ở đây. Chúng tôi sử dụng “cout” và chèn một thông báo để hiển thị khi điều kiện được thỏa mãn.







Sau đó, chúng ta sử dụng từ khóa “ném” sau khi đặt “khác”. Trong từ khóa “ném” này, chúng tôi chuyển “my_num1” làm tham số. Chúng tôi thêm phần “bắt” bên dưới phần này. Chúng ta chèn “my_num2” làm tham số của “catch()” và sau đó sử dụng lại “cout” bên trong phần “catch” này. Phần này chỉ thực thi khi có ngoại lệ xảy ra trong phần “thử”.



Mã 1:



#include
sử dụng không gian tên tiêu chuẩn ;
int chủ yếu ( ) {
thử {
int my_num1 = 35 ;
nếu như ( my_num1 >= 98 ) {
cout << 'Quyền truy cập được cấp ở đây.' ;
} khác {
ném ( my_num1 ) ;
}
}
nắm lấy ( int my_num2 ) {
cout << 'Quyền truy cập bị từ chối ở đây.' << kết thúc ;
cout << 'Số là: ' << my_num2 ;
}
trở lại 0 ;
}

Đầu ra:
Số mà chúng tôi đã nhập là “35”, nhỏ hơn “98”. Vì vậy, ngoại lệ xảy ra ở đó và phần “catch()” được hiển thị. Quyền truy cập vào phần 'thử' bị từ chối.





Ví dụ 2:

Chúng tôi đặt tệp tiêu đề “iostream” ở đây và “không gian tên std”. Sau đó, chúng ta tạo một hàm “divion()” trong đó chúng ta đặt hai tham số là “tử số” và “mẫu số” của kiểu dữ liệu “int”. Chúng tôi đặt kiểu dữ liệu của hàm “chia” này thành “double”.



Bên dưới phần này, chúng ta thêm “if()” trong đó chúng ta thêm điều kiện là mẫu số bằng 0. Sau đó, chúng tôi sử dụng từ khóa “ném” và nhập tin nhắn vào đó. Thông báo này được hiển thị bất cứ khi nào ngoại lệ xảy ra trong mã này theo điều kiện. Bên dưới điều này, chúng tôi sử dụng từ khóa “return” trong đó chúng tôi đặt “tử số/mẫu số”. Vì vậy, nó trả về kết quả của phép chia. Bây giờ, hàm “main()” được gọi.

Sau đó, “num1” và “num2” được khởi tạo dưới dạng biến “int” và gán “89” và “0” cho chúng tương ứng. Sau đó, chúng ta khởi tạo “kết quả” của kiểu dữ liệu “double”. Ở đây, chúng tôi sử dụng từ khóa “thử”. Trong phần này, chúng ta thêm biến “kết quả” này và gán hàm “divion()” cho biến này. Chúng ta truyền hai tham số cho hàm này: “num1” và “num2”. Bên dưới phần này, chúng tôi hiển thị “kết quả” mà chúng tôi nhận được sau khi áp dụng hàm “divide()”. Sau đó, chúng tôi cũng sử dụng “catch” và đặt “const char* msg” để hiển thị thông báo mà chúng tôi đã thêm trước đó.

Mã 2:

#include
sử dụng không gian tên tiêu chuẩn ;
gấp đôi phân công ( int tử số , int mẫu số ) {
nếu như ( mẫu số == 0 ) {
ném 'Không thể chia cho số 0 ở đây!' ;
}
trở lại ( tử số / mẫu số ) ;
}
int chủ yếu ( ) {
int số 1 = 89 ;
int số 2 = 0 ;
gấp đôi kết quả = 0 ;
thử {
kết quả = phân công ( số 1, số 2 ) ;
cout << kết quả << kết thúc ;
} nắm lấy ( hằng số ký tự * tin nhắn ) {
cer << tin nhắn << kết thúc ;
}
trở lại 0 ;
}

Đầu ra:
Số mà trước đây chúng ta đã chèn làm mẫu số là “0”. Vì vậy, ngoại lệ xảy ra trong mã và nó hiển thị thông báo đã cho.

Ví dụ 3:

Hàm “nhân()” được tạo ở đây, trong đó chúng ta đặt “giá trị” và “số nhân” làm tham số của kiểu dữ liệu “int”. Sau đó, chúng tôi sử dụng “nếu” trong đó chúng tôi thêm một điều kiện nhân bằng 0. Sau đó, “ném” được đặt ở nơi chúng ta thêm một câu lệnh. Sau đó, chúng ta có 'return' trong đó chúng ta đặt các biến 'giá trị * số nhân' mà chúng ta đã khai báo trước đó. Vì vậy, nó trả về kết quả nhân ở đây.

Sau đó, chúng ta gọi “main()”, trong đó chúng ta khai báo “int value1” và “int value2” với các giá trị lần lượt là “34” và “0”. “int m_res” cũng được khai báo và sau đó được gọi là hàm “nhân()” ở đây. Sau khi thực hiện chức năng này, kết quả bây giờ được lưu trong biến “m_res” và sau đó được hiển thị. Sau đó, chúng tôi sử dụng chức năng “bắt” và chèn “const char* msg” để hiển thị thông báo mà trước đó chúng tôi đã thêm vào phần “ném”.

Mã 3:

#include
sử dụng không gian tên tiêu chuẩn ;
gấp đôi phép nhân ( int giá trị , int phép nhân ) {
nếu như ( phép nhân == 0 ) {
ném 'Chúng tôi không nhân giá trị với số 0!' ;
}
trở lại ( giá trị * phép nhân ) ;
}
int chủ yếu ( ) {
int giá trị1 = 3. 4 ;
int giá trị2 = 0 ;
int m_res ;
thử {
m_res = phép nhân ( giá trị1, giá trị2 ) ;
cout << m_res << kết thúc ;
} nắm lấy ( hằng số ký tự * tin nhắn ) {
cer << tin nhắn << kết thúc ;
}
trở lại 0 ;
}

đầu ra :
Vì giá trị mà chúng tôi đã nhập trước đó có “0” làm hệ số nhân nên mã có một ngoại lệ khiến thông báo được hiển thị ở đây.

Ví dụ 4:

Ở đây, chúng ta xây dựng hàm “multiply()” và truyền vào “number1” và “number2” làm tham số của kiểu dữ liệu “int”. Tiếp theo, chúng ta sử dụng toán tử “if” để thêm một điều kiện vào đó là một số nhân nhỏ hơn hoặc bằng 0. Sau đó, câu lệnh được thêm vào vị trí được cho là 'ném'. Kết quả nhân sau đó được trả về trong phần “return” nơi chúng ta chèn biến “number1 * number2” mà chúng ta đã khai báo trước đó.

Sau đó, chúng ta gọi hàm “main()” và gán giá trị “34” và “12” cho “int newNumber1” và “int newNumber2”. Ở đây, hàm “multiply()” được gọi sau khi khai báo “int mResult”. Bây giờ, kết quả của hàm này được lưu trữ trong biến “mResult” và được hiển thị như sau. Sau đó, chúng tôi sử dụng chức năng “bắt” và thêm “const char* msg” để hiển thị thông báo mà chúng tôi đã viết trong phần “ném”.

Mã 4:

#include
sử dụng không gian tên tiêu chuẩn ;
gấp đôi nhân ( int số 1 ​​, int số 2 ) {
nếu như ( số 2 <= 0 ) {
ném 'Chúng tôi không nhân giá trị với giá trị 0 hoặc âm!' ;
}
trở lại ( số 1 * số 2 ) ;
}
int chủ yếu ( ) {
int mớiNum1 = 3. 4 ;
int mớiNum2 = 12 ;
int kết quả ;
thử {
kết quả = nhân ( số mới1, số mới2 ) ;
cout << 'Kết quả của phép nhân là' << kết quả << kết thúc ;
}
nắm lấy ( hằng số ký tự * tin nhắn ) {
cer << tin nhắn << kết thúc ;
}
trở lại 0 ;
}

Đầu ra:
Giá trị mà chúng tôi thêm vào là “12” mà chúng tôi thêm điều kiện vào đó. Vì vậy, hàm “multiply()” được thực hiện do điều kiện không đúng. Kết quả của phép nhân được hiển thị. Phần “thử” được thực hiện ở đây.

Phần kết luận

Khái niệm “thử bắt” và các mã trong hướng dẫn này được nghiên cứu chi tiết. Chúng tôi đã khám phá kỹ lưỡng khái niệm “thử bắt” này và chỉ ra cách nó hoạt động trong lập trình C++. Chúng tôi đã xác định rằng thuật ngữ 'ném' sẽ tạo ra một ngoại lệ khi tìm thấy lỗi cho phép chúng tôi viết mã duy nhất của mình. Bằng cách sử dụng biểu thức “catch”, chúng ta có thể chỉ định một khối mã sẽ chạy nếu có ngoại lệ xuất hiện trong phần “thử”.