Evgenii LegotckoiOct. 15, 2017, 5:31 p.m.

C++ - Tutorial 011. Exceptions

Content

1. Invariants
2. Types of Exceptions
3. std::logic_error
4. std::invalid_argument
5. std::domain_error
6. std::length_error
7. std::out_of_range
8. std::future_error
9. std::runtime_error
10. std::range_error
11. std::overflow_error
12. std::underflow_error
13. std::system_error
14. std::ios_base::failure
15. std::bad_typeid
16. std::bad_cast
17. std::bad_weak_ptr
18. std::bad_function_call
19. std::bad_alloc
20. std::bad_array_new_length
21. std::bad_exception

What is an exception? This is a situation that is not provided by the standard behavior of the program. For example, an attempt to access an element in the Vector class (which we discussed in the article about classes ), which does not exist. That is, there is a way out of the vector. In this case, you can use exceptions to interrupt the execution of the program. This is necessary because

As a rule in such cases, the author of the Vector class does not know how the user wants to use its class, and also does not know in which program this class will be used.
A user of the Vector class can not always control the correctness of this class, so he needs to report that something went wrong.

To resolve such a situation in C ++, you can use the exception technique.

Consider how to write an exception call when an element is attempted to access an element that does not exist in the Vector class.

double& Vector::operator[](int i)
{
    if (i<0 || size()<=i) throw out_of_range{"Vector::operator[]"};
    return elem[i];
}

Here, the out_of_range exception is used. This exception is defined in the header file.

The throw statement passes control to the handler for out_of_range exceptions in some function that directly or indirectly calls Vector::operator . In order to handle exceptions, you must use the try catch statement block.

void f(Vector& v)
{
    // ...
    try { // function block with exception
        v[v.size()] = 7; // attempt to access an element outside the vector
    }
    catch (out_of_range) { // catch the error out_of_range
        // ... error handling out_of_range ...
    }
    // ...
}

Invariants

Also, try catch blocks allow processing of several different exceptions, which introduces invariance into the operation of the C ++ exception mechanism....

For example, a vector class can create an invalid vector size when it is created, or it can not find free memory for the elements it will contain.

Vector::Vector(int s)
{
    if (s < 0) throw length_error{};
    elem = new double[s];
    sz = s;
}

This constructor can throw an exception in two cases:

If a negative value is passed as the size argument
If the operator new can not allocate memory

length_error - This is the standard exception operator, because the std library often uses exception data in its work.

Exception handling will look like this:

void test()
{
    try {
        Vector v(−27);
    }
    catch (std::length_error) {
        // processing of negative vector size
    }
    catch (std::bad_alloc) {
        // memory allocation error handling
    }
}

You can also create your own exceptions.

Types of Exceptions

All exceptions to the standard library are inherited from std::exception.

At the moment, there are the following types of exceptions:

logic_error
invalid_argument
domain_error
length_error
out_of_range
future_error (C++11)
runtime_error
range_error
overflow_error
underflow_error
system_error (C++11)
ios_base::failure (начиная с C++11)
bad_typeid
bad_cast
bad_weak_ptr (C++11)
bad_function_call (C++11)
bad_alloc
bad_array_new_length (C++11)
bad_exception
ios_base::failure (до C++11)