Sử dụng lại mã trong xử lý ngoại lệ

Question

Tôi đang phát triển một api C cho một số chức năng được viết bằng C++ và tôi muốn đảm bảo rằng không có ngoại lệ nào được truyền từ bất kỳ hàm C được xuất nào.

Cách đơn giản để làm điều đó là đảm bảo mỗi chức năng xuất khẩu được chứa trong một:

try { 
    // Do the actual code 
} catch (...) { 
    return ERROR_UNHANDLED_EXCEPTION; 
} 

Hãy nói rằng tôi biết một ngoại lệ mà thường bị bỏ lỡ trong C++ là std :: bad_alloc và tôi muốn để đối xử với nó đặc biệt tôi muốn viết một cái gì đó như thế này thay vì:

try { 
    // Run the actual code 
} catch (std::bad_alloc& e) { 
    return ERROR_BAD_ALLOC; 
} catch (...) { 
    return ERROR_UNHANDLED_EXCEPTION; 
} 

có thể phân hủy này trong một số cách thông minh để tôi trên toàn cầu có thể điều trị một số lỗi khác nhau mà không cần thêm một lệnh catch mới cho xử lý ngoại lệ xung quanh mỗi chức năng xuất khẩu?

Tôi biết rằng điều này có thể giải quyết bằng cách sử dụng bộ tiền xử lý, nhưng trước khi đi xuống con đường đó, tôi chắc chắn rằng không có cách nào khác để làm điều đó.

Answer 1

Bạn có thể chỉ sử dụng một hàm điều khiển cho tất cả các trường hợp ngoại lệ có thể, và gọi nó là từ mỗi hoặc các chức năng thực hiện API của bạn, như sau:

int HandleException() 
{ 
    try 
    { 
     throw; 
    } 

    // TODO: add more types of exceptions 

    catch(std::bad_alloc &) 
    { 
     return ERROR_BAD_ALLOC; 
    } 
    catch(...) 
    { 
     return ERROR_UNHANDLED_EXCEPTION; 
    } 
} 

Và trong mỗi chức năng đã xuất:

try 
{ 
    ... 
} 
catch(...) 
{ 
    return HandleException(); 
} 

Answer 2

Không bao giờ sử dụng catch(...), trừ khi bạn có kế hoạch trả lại nhiều hơn hoặc ít hơn ngay lập tức. Bạn chắc chắn sẽ mất bất kỳ thông tin lỗi nào mà bạn có thể có để giúp bạn tìm ra nguyên nhân gây ra lỗi.

Tôi thích kế hoạch thứ hai của bạn tốt hơn một chút - bắt được một bộ ngoại lệ được biết đến, lý tưởng là chúng là mã duy nhất mà mã của bạn sẽ ném và để phần còn lại thông qua - cho phép ứng dụng gặp sự cố. kể từ khi bạn đã gọi hành vi không rõ nó là tốt nhất để "sụp đổ có trách nhiệm".

Answer 3

gì về:

try{ 
    //Your code here 
} catch(std::exception e) 
{ 
    return translateExceptionToErrorCode(e); 
} catch(...) 
{ 
    return UNKNOWN_EXCEPTION_THROWN; 
} 

Answer 4

Sẽ là một điều đáng tiếc khi thông tin lỗi ở ngôn ngữ bo undary. Bạn thực sự nên cố gắng dịch tất cả các ngoại lệ thành mã lỗi có thể sử dụng từ C.

Cách bạn thực hiện điều đó thực sự phụ thuộc vào các lớp ngoại lệ của bạn. Nếu bạn kiểm soát phân cấp lớp ngoại lệ của mình, bạn có thể đảm bảo rằng mỗi lớp cung cấp bản dịch bằng cách sử dụng một phương thức ảo. Nếu không, bạn vẫn có thể thấy nó thực tế để sử dụng một hàm dịch và kiểm tra các loại ngoại lệ 'std :: exception' có nguồn gốc nó nhận được để dịch nó thành một mã lỗi, giống như Jem gợi ý (nhớ: ném ngoại lệ sẽ bị tổn thương hiệu suất anyway, do đó, đừng lo lắng về bản dịch được làm chậm).

Answer 5

Jem câu trả lời đơn giản hơn một chút so với giải pháp này. Nhưng có thể thay thế việc sử dụng macro tiền xử lý bằng việc sử dụng các mẫu. Một cái gì đó như thế này (bạn có thể tinh chỉnh thêm):

template <class T, void (T::*FUNC)()> 
class CatchWrapper 
{ 
public: 

    static void WrapCall(T* instance) 
    { 
     try 
     { 
      (instance->*FUNC)(); 
     } 
     catch (std::bad_alloc&) 
     { 
      // Do Something 1 
     } 
     catch (std::exception& e) 
     { 
      // Do Something 2 
     } 
     catch (...) 
     { 
      // Do Something 3 
     } 
    } 
}; 


class Foo 
{ 
public: 
    void SomeCall() 
    { 
     std::cout << "Do Something" << std::endl; 
    } 
}; 


int main(int argc, char* argv[]) 
{ 
    Foo i; 
    CatchWrapper<Foo, &Foo::SomeCall>::WrapCall(&i); 
    return 0; 
} 

Answer 6

Đã có câu trả lời hay. Nhưng chỉ FYI, được gọi là thành ngữ 'ngoại lệ-điều phối', xem C++ FAQ 17.15. IMHO 17.16 cũng là một nội dung quan trọng.