Làm thế nào để biết rằng không có kết quả của một hàm có giá trị trả về?

Question

Tôi có một câu hỏi ngắn. Với một hàm trả về một đối tượng của một lớp như là kết quả, tôi nên trả về những gì nếu không có kết quả (giả sử vì một chỉ mục nằm ngoài phạm vi)? Tôi có thể trả về một đối tượng "trống rỗng" nhưng làm thế nào tôi có thể chỉ ra rằng không có tính toán thành công?

Tôi cho rằng có một cách tiếp cận chung.

Answer 1

Bạn có thể ném ngoại lệ khi giá trị không khớp với kết quả mong đợi.

Một hướng dẫn có thể được tìm thấy tại http://www.cplusplus.com/doc/tutorial/exceptions

Một ngoại lệ làm việc với một nguyên tắc thử và nắm bắt.

Một chương trình "cố gắng" để thực thi mã. Nếu có điều gì đó bất ngờ xảy ra, mã được thực hiện "ném" một đối tượng, biến hoặc bất kỳ thứ gì và điều này sẽ bị bắt. Trong tuyên bố khai thác, bạn có thể đặt mã những gì sẽ xảy ra nếu điều bất ngờ xảy ra.

Chỉ cần làm theo hướng dẫn.

Answer 2

Cách tiếp cận chung trong C++ là ném ngoại lệ hoặc sử dụng một số trình bao bọc như boost::optional.

Một ngoại lệ nên được ném nếu đó là lỗi nào đó, số boost::optional -approach phù hợp hơn nếu đó là trường hợp sử dụng hợp lệ của hàm của bạn để trả về kết quả trống. Một ví dụ mà nói đến cái tâm là NULL của NULL. boost::optional bật ra khá tiện dụng trong codebase của chúng tôi.

Answer 3

Đi theo triết lý của phương pháp vector::at ném out_of_range ngoại lệ nếu có thể.

Answer 4

Tùy thuộc vào ngữ nghĩa của thao tác.

Nếu một lỗi xảy ra, bạn chắc chắn nên ném một ngoại lệ:

#include <stdexcept> // Necessary for standard exceptions 

X foo() 
{ 
    ... 
    if (/* something goes wrong... */) 
    { 
     // There may be a more appropriate exception class. You could 
     // also derive your own exception class from std::exception... 
     throw std::logic_error("Whatever!"); 
    } 

    ... 
} 

... 

try 
{ 
    X x = foo(); 
    // Work with x... 
} 
catch (std::logic_error const& e) // Catch what is appropriate... 
{ 
    std::cout << e.what(); 
} 

Nếu trả lại một không có giá trị không biểu thị một điều kiện lỗi, bạn có thể sử dụng Boost.Optional. Ngoài ra, với điều kiện bạn có thể tạo một đối tượng "trống rỗng" của loại X, bạn có thể nghĩ đến việc trả lại một cặp mà thành viên thứ hai là một lá cờ bool mà nói cho dù thành viên đầu tiên là một đối tượng có giá trị hay không, như sau:

std::pair<X, bool> foo(); 

... 

bool valid; 
X x; 
std::tie(x, valid) = foo(); 
if (valid) 
{ 
    // Use x... 
} 

Answer 5

Nếu chúng ta đang nói về tình huống sai lầm, ném một ngoại lệ là giải pháp thích hợp.

#include<exception> 

Object * GenerateObject(int i) 
{ 
    if (i < 0) 
     throw std::out_of_range("i"); 

    return new Object(i); 
} 

int main(int argc, char * argv[]) 
{ 
    try 
    { 
     Object * obj = GenerateObject(-1); 

     // Succeeded 
     return 0; 
    } 
    catch (std::exception & e) 
    { 
     // Failed, exiting with error value 
     return 1; 
    } 
} 

Nếu giá trị rỗng được cho phép, bạn có thể chỉ định giá trị cụ thể cho lớp này, ví dụ:

class Rectangle 
{ 
private: 
    int left, top, width, height; 

public: 
    Rectangle(l, t, w, h) 
    { 
     left = l; 
     top = t; 
     width = w; 
     height = h; 
    } 

    public static Rectangle empty; 
} 

Rectangle Rectangle::empty = Rectangle(0, 0, -1, -1); 

// ... 

Rectangle DoSth(int i) 
{ 
    // i < 0 is NOT considered an error here 
    if (i < 0) 
      return Rectangle::empty; 

    // Further processing 
} 

Answer 6

Bạn có thể ghép một kiểu liệt kê với kiểu đối tượng đang được trả về. Nếu liệt kê trả về là một giá trị nhất định, đối tượng là hợp lệ, nếu không đối tượng ở trạng thái không hợp lệ.

// This is a working C++11 example. 
#include <utility> 
#include <memory> 

enum result 
{ 
    ok, 
    out_of_range, 
    some_other_error 
}; 

class object 
{ 
    public: 
     object() {} 
}; 

typedef std::shared_ptr<object> object_ptr; 

typedef std::pair< result, object_ptr > return_type; 

return_type some_function(int index) 
{ 
    if (index > 5) 
    { 
     return return_type{ result::out_of_range, nullptr }; 
    } 

    return return_type{ result::ok, object_ptr{ new object() } }; 
} 

int main() 
{ 
    return_type res = some_function(10); 
    if (res.first == result::ok) 
    { 
     // Do something with res.second 
    } 
    else 
    { 
     // Handle the error 
    } 
} 

Tôi có thể chỉ cần ném ngoại lệ thay thế.