To Catch by Value or by Reference in C : When is One Better Than the Other?

Catch Blocks in C : Value vs. Reference

In C , there is a choice to be made between catching exceptions by value or reference. This decision can impact the behavior and correctness of code.

Standard Practice

The standard practice for exceptions in C is to throw by value and catch by reference.

Reasoning

Catching by value can be problematic in the presence of inheritance hierarchies. Consider the following example:

class CustomException {
public:
    int errorCode;
};

class MyException : public CustomException {
public:
    MyException() { errorCode = 5; }
};

If a MyException is thrown and caught by value, it will be converted to a CustomException instance, resulting in the error code being set to 0. This can lead to unexpected behavior.

Catching by Reference

By catching exceptions by reference, the original thrown exception is maintained, allowing for accurate access to the exception's properties. In the example above, catching MyException &e ensures that the error code remains set to 5.

When to Catch by Value

There are rare situations where catching by value may be preferable, such as when:

• The exception type is known not to have any subtypes (i.e., inheritance is not a factor).
• The exception object is large and copying it would be inefficient.

Recommendation

In general, it is strongly recommended to follow the standard practice of throwing by value and catching by reference to ensure correct handling of exceptions, especially in the context of inheritance.

The above is the detailed content of To Catch by Value or by Reference in C : When is One Better Than the Other?. For more information, please follow other related articles on the PHP Chinese website!