我应该抛出异常吗？

Question

I am C# programmer but now I want to get more into C++.
I know the basics of C++ but I don't know how to handle errors.

For example: I am writing a library. I create an constructor which requests an integer as an argument.
If that integer is bigger than 50, it is an error. In C# I would throw an ArgumentOutOfRange exception, but what should I do in C++?

Answer 1

In C# I would throw an ArgumentOutOfRange exception but what should I do in c++?

First you should consider if that should not be a precondition of your function, leaving the responsibility of checking whether the value is in range to the caller.

If you decide for this option, then invoking the function with an out-of-range value would be undefined behavior, and inside the function you could just have a debug assertion to help you spot possible misuses - without the need of throwing any exception.

If you decide that the function should have a wide contract, on the other hand, and react in a well-defined way by throwing an exception when the argument is outside the permitted range, then you could throw an std::out_of_range exception.

For example: I am writing a libary [...]

If you are writing a library, meaning that you do not know the exact requirements of your clients in terms of performance and robustness, you may consider providing two such functions - one with a wide contract that throws exceptions, and one with a narrow contract that assumes the client provides meaningful input.

This way, the user of your library could decide based on their use cases whether or not it is OK to pay for the overhead of checking the correctness of the input each time your function is called.

This is, for instance, the strategy adopted by the C++ Standard Library for std::vector , which provides a non-throwing operator[] with a narrow contract for accessing elements of the collection based on the index (this function has undefined behavior if the index is out-of-bounds), and a member function at() that performs index checking and throws an exception if the index is out-of-bounds.

Answer 2

It depends on whether an integer larger than 50 could possibly be passed to the constructor as part of normal program flow, or whether that's an exceptional condition. But in general the only way to have object construction fail is by throwing an exception.

Your user code might look like this:

int n = parse_user_input()

if (n < 50)
{
    Foo x(n);
    x.do_cool_stuff();
}
else
{
    // report user error
}

That is, you don't actually use exceptions for normal control flow. With that sort of code pattern, it would be perfectly fine for Foo::Foo(int) to throw an exception if the argument were out of range.

You can find useful standard exception classes in <stdexcept> .

Answer 3

The same thing as in C#: throw an exception. This is the only way to prevent an object from being constructed.

std::invalid_argument is a good standard choice regarding what to throw.

Answer 4

From the C++ FAQ: [17.8] How can I handle a constructor that fails?

Excerpt:

Throw an exception.

Constructors don't have a return type, so it's not possible to use return codes. The best way to signal constructor failure is therefore to throw an exception. If you don't have the option of using exceptions, the "least bad" work-around is to put the object into a "zombie" state by setting an internal status bit so the object acts sort of like it's dead even though it is technically still alive.

So, throwing std::invalid_argument or std::out_of_range would be perfectly acceptable for your situation. You could also throw a custom exception if that would be beneficial in your situation. In the C++ FAQ see: [17.12] What should I throw?