Throw std runtime error

Defines a type of object to be thrown as exception. It reports errors that are due to events beyond the scope of the program and can not be easily predicted.

Exceptions of type std::runtime_error are thrown by the following standard library components: std::locale::locale and std::locale::combine.

In addition, the following standard exception types are derived from std::runtime_error:

• std::range_error
• std::overflow_error
• std::underflow_error

[edit] Member functions

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

Что такое исключение? Это ситуация, которая не предусмотрена стандартным поведением программы. Например, попытка доступа к элементу в классе Vector (который мы разбирали в статье про

классы

), который не существует. То есть происходит выход за пределы вектора. В данном случае можно воспользоваться исключениями, чтобы прервать выполнение программы. Это необходимо потому, что

• Как правило в таких случаях, автор класса
  
  Vector
  
  не знает, как пользователь захочет использовать его класс, а также не знает в какой программе этот класс будет использоваться.
• Пользователь класса
  
  Vector
  
  не может всегда контролировать правильность работы этого класса, поэтому ему нужно сообщить о том, что что-то пошло не так.

Для разрешения таких ситуация в C++ можно использовать технику исключений.

Рассмотрим, как написать вызов исключения в случае попытки доступа к элементу по индексу, который не существует в классе Vector.

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


  Здесь применяется исключение

  

   out_of_range.

  

  Данное исключение определено в заголовочном файле

  

    .

   

  Оператор

  

   throw

  

  передаёт контроль обработчику для исключений типа

  

   out_of_range

  

  в некоторой функции, которая прямо или косвенно вызывает

  

   Vector::operator

   

  . Для того, чтобы обработать исключения необходимо воспользоваться блоком операторов

  

   try catch.

  
void f(Vector& v)
{
    // ...
    try { // блок обработки функции с исключением
        v[v.size()] = 7; // попытка доступа к элементу за пределами вектора
    }
    catch (out_of_range) { // ловим ошибку out_of_range 
        // ... обработки ошибки out_of_range ...
    }
    // ...
}


  Инварианты

 

  Также блоки

  

   try catch

  

  позволяют производить обработку нескольких различных исключений, что вносит инвариантность в работу механизма исключений C++.
 

  Например, класс вектор при создании может получить неправильный размер вектора или не найти свободную память для элементов, которые он будет содержать.
 
Vector::Vector(int s)
{
    if (s < 0) throw length_error{};
    elem = new double[s];
    sz = s;
}


  Данный конструктор может выбросить исключение в двух случаях:
 


   Если в качестве аргумента

   

    size

   

   будет передано отрицательное значение
  

   Если оператор

   

    new

   

   не сможет выделить память
  



   length_error

  

  — это стандартный оператор исключений, поскольку библиотека std часто использует данные исключения при своей работе.
 

  Обработка исключений будет выглядеть следующим образом:
 
void test()
{
    try {
        Vector v(−27);
    }
    catch (std::length_error) {
        // обработка отрицательного размера вектора
    }
    catch (std::bad_alloc) {
        // обработка ошибки выделения памяти
    }
}


  Также можно выделить свои собственные исключения.
 



  


                       
  





  Виды исключений

 

  Все исключения стандартной библиотеки наследуются от

  

   std::exception.

  

  На данный момент существуют следующие виды исключений:
 


   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)
  


  std::logic_error

 

  Исключение определено в заголовочном файле
  

  Определяет тип объекта, который будет брошен как исключение. Он сообщает об ошибках, которые являются следствием неправильной логики в рамках программы, такие как нарушение логической предпосылки или класс инвариантов, которые возможно предотвратить.
 

  Этот класс используется как основа для ошибок, которые могут быть определены только во время выполнения программы.
 

  std::invalid_argument

 

  Исключение определено в заголовочном файле
  

  Наследован от std::logic_error. Определяет исключение, которое должно быть брошено в случае неправильного аргумента.
 

  Например, на MSDN приведён пример, когда в объект класса bitset из стандартной библиотеки
 
// invalid_arg.cpp  
// compile with: /EHsc /GR  
#include <bitset>  
#include <iostream>  

using namespace std;  

int main( )  
{  
   try   
   {  
      bitset< 32 > bitset( string( "11001010101100001b100101010110000") );  
   }  
   catch ( exception &e )   
   {  
      cerr << "Caught " << e.what( ) << endl;  
      cerr << "Type " << typeid( e ).name( ) << endl;  
   };  
}  
* Output:   
Caught invalid bitset<N> char  
Type class std::invalid_argument  
* 


  В данном примере передаётся неправильная строка, внутри которой имеется символ ‘b’, который будет ошибочным.
 

  std::domain_error

 

  Исключение определено в заголовочном файле
  



  


                       
  





  Наследован от std::logic_error. Определяет исключение, которое должно быть брошено в случае если математическая функция не определена для того аргумента, который ей передаётся, например:
 
std::sqrt(-1)


  std::length_error

 

  Исключение определено в заголовочном файле
  

  Наследован от std::logic_error. Определяет исключение, которое должно быть броше в том случае, когда осуществляется попытка реализации превышения допустим пределов для объекта. Как это было показано для размера вектора в начале статьи.
 

  std::out_of_range

 

  Исключение определено в заголовочном файле
  

  Наследован от std::logic_error. Определяет исключение, которое должно быть брошено в том случае, когда происходит выход за пределы допустимого диапазона значений объекта. Как это было показано для диапазона значений ветора в начале статьи.
 

  std::future_error

 

  Исключение определено в заголовочном файле
  

  Наследован от std::logic_error. Данное исключение может быть выброшено в том случае, если не удалось выполнить функцию, которая работает в асинхронном режиме и зависит от библиотеки потоков. Это исключение несет код ошибки совместимый с

  

   std::error_code

  

  .
 

  std::runtime_error

 

  Исключение определено в заголовочном файле
  

  Является базовым исключением для исключений, которые не могут быть легко предсказаны и должны быть брошены во время выполнения программы.
 

  std::range_error

 

  Исключение определено в заголовочном файле
  



  


                       
  





  Исключение используется при ошибках при вычислении значений с плавающей запятой, когда компьютер не может обработать значение, поскольку оно является либо слишком большим, либо слишком маленьким. Если значение является значение интегрального типа, то должны использоваться исключения

  

   underflow_error

  

  или

  

   overflow_error

  

  .
 

  std::overflow_error

 

  Исключение определено в заголовочном файле
  

  Исключение используется при ошибках при вычислении значений с плавающей запятой интегрального типа, когда число имеет слишком большое положительное значение, положительную бесконечность, при которой происходит потеря точности, т.е. результат настолько большой, что не может быть представлен числом в формате IEEE754.
 

  std::underflow_error

 

  Исключение определено в заголовочном файле
  

  Исключение используется при ошибках при вычислении значений с плавающей запятой интегрального типа, при которой происходит потеря точности, т.е. результат настолько мал, что не может быть представлен числом в формате IEEE754.
 

  std::system_error

 

  Исключение определено в заголовочном файле
  


   std::system_error

  

  — это тип исключения, которое вызывается различными функциями стандартной библиотеки (как правило, функции, которые взаимодействуют с операционной системой, например, конструктор

  

   std::thread

  

  ), при этом исключение имеет соответствующий

  

   std::error_code

  

  .
 

  std::ios_base::failure

 

  Исключение определено в заголовочном файле
  

  Отвечает за исключения, которые выбрасываются при ошибках функций ввода вывода.
 

  std::bad_typeid

 

  Исключение определено в заголовочном файле
  



  


                       
  





  Исключение этого типа возникает, когда оператор

  

   typeid

  

  применяется к нулевому указателю полиморфного типа.
 
#include <iostream>
#include <typeinfo>

struct S { // Тип должен быть полиморфным
    virtual void f();
}; 

int main()
{
    S* p = nullptr;
    try {
        std::cout << typeid(*p).name() << 'n';
    } catch(const std::bad_typeid& e) {
        std::cout << e.what() << 'n';
    }
}


  std::bad_cast

 

  Исключение определено в заголовочном файле
  

  Данное исключение возникает в том случае, когда производится попытка каста объекта в тот тип объекта, который не входит с ним отношения наследования.
 
#include <iostream>
#include <typeinfo>

struct Foo { virtual ~Foo() {} };
struct Bar { virtual ~Bar() {} };

int main()
{
    Bar b;
    try {
        Foo& f = dynamic_cast<Foo&>(b);
    } catch(const std::bad_cast& e)
    {
        std::cout << e.what() << 'n';
    }
}


  std::bad_weak_ptr

 

  Исключение определено в заголовочном файле
  


   std::bad_weak_ptr

  

  – тип объекта, генерируемый в качестве исключения конструкторами

  

   std::shared_ptr

  

  , которые принимают

  

   std::weak_ptr

  

  в качестве аргумента, когда

  

   std::weak_ptr

  

  ссылается на уже удаленный объект.
 
#include <memory>
#include <iostream>
int main()
{
    std::shared_ptr<int> p1(new int(42));
    std::weak_ptr<int> wp(p1);
    p1.reset();
    try {
        std::shared_ptr<int> p2(wp);
    } catch(const std::bad_weak_ptr& e) {
        std::cout << e.what() << 'n';
    }
}


  std::bad_function_call

 

  Исключение определено в заголовочном файле
  

  Данное исключение генерируется в том случае, если был вызван метод

  

   std::function::operator()

  

  объекта

  

   std::function

  

  , который не получил объекта функции, то есть ему был передан в качестве инициализатора nullptr, например, а объект функции так и не был передан.
 
#include <iostream>
#include <functional>

int main()
{
    std::function<int()> f = nullptr;
    try {
        f();
    } catch(const std::bad_function_call& e) {
        std::cout << e.what() << 'n';
    }
}


  std::bad_alloc

 

  Исключение определено в заголовочном файле
  

  Вызывается в том случае, когда не удаётся выделить память.
 

  std::bad_array_new_length

 

  Исключение определено в заголовочном файле
  



  


                       
  





  Исключение вызывается в следующих случаях:
 


   Массив имеет отрицательный размер
  

   Общий размер нового массива превысил максимальное значение, определяемое реализацией
  

   Количество элементов инициализации превышает предлагаемое количество инициализирующих элементов
  

#include <iostream>
#include <new>
#include <climits>

int main()
{
    int negative = -1;
    int small = 1;
    int large = INT_MAX;
    try {
        new int[negative];           // negative size
        new int[small]{1,2,3};       // too many initializers
        new int[large][1000000];     // too large
    } catch(const std::bad_array_new_length &e) {
        std::cout << e.what() << 'n';
    }
}


  std::bad_exception

 

  Исключение определено в заголовочном файле
  


   std::bad_exception

  

  — это тип исключения в C++, которое выполняется в следующих ситуациях:
 


   Если нарушается динамическая спецификация исключений
  

   Если

   

    std::exception_ptr

   

   хранит копию пойманного исключения, и если конструктор копирования объекта исключения поймал current_exception, тогда генерируется исключение захваченных исключений.
  

#include <iostream>
#include <exception>
#include <stdexcept>

void my_unexp() { throw; }

void test() throw(std::bad_exception)
{
    throw std::runtime_error("test");
}

int main()
{
    std::set_unexpected(my_unexp);
    try {
         test();
    } catch(const std::bad_exception& e)
    {
        std::cerr << "Caught " << e.what() << 'n';
    }
}

В интернете довольно много говорят о новых возможностях C++11: auto, lambda, variadic templates. Но как-то обошли стороной новые возможности работы с исключениями, которые предоставляет язык и стандартная библиотека.

От предыдущей версии стандарта остался механизм генерации исключений (throw), проверка того, что мы находимся в процессе обработки исключения (std::uncaught_exception), механизм остановки, если исключение не было обработано. Также есть иерархия стандартных исключений на базе класса std::exception.

Новый стандарт добавляет к этим вещам еще несколько сущностей, которые, на мой взгляд, могут существенно упростить работу с исключениями в C++.

exception_ptr

Итак, самое первое, с чем мы можем столкнуться — это std::exception_ptr. Этот тип позволяет в себе хранить исключение абсолютно любого типа. Стандарт не оговаривает каким образом получен этот тип. Это может быть typedef, это может быть реализация класса. Его поведение сходно поведению std::shared_ptr, то есть его можно копировать, передавать в качестве параметра, при этом само исключение не копируется. Основное предназначение exception_ptr — это передача исключений в качестве параметров функции, возможна передача исключений между потоками. Таким образом, объекты данного типа позволяют сделать обработку ошибок более гибкой:

struct some_exception {
	explicit some_exception(int x): v(x) {
		std::cout << " int ctor" << std::endl;
	}

	some_exception(const some_exception & e): v(e.v) {
		std::cout << " copy ctor" << std::endl;
	}

	int v;
};

std::exception_ptr throwExceptionAndCaptureExceptionPtr() {
	std::exception_ptr currentException;
	try {
		const int throwValue = 10;
		std::cout << "throwing           " << throwValue << "..." << std::endl;
		throw some_exception(throwValue);

	} catch (...) {
		 currentException = std::current_exception();
	}

	return currentException;
}

void rethrowException(std::exception_ptr ePtr) {
	try {
		if (ePtr) {
			std::rethrow_exception(ePtr);
		}

	} catch (const some_exception & e) {
		std::cout << "catched int value: " << e.v << std::endl;
	}

	std::exception_ptr anotherExceptionPtr = ePtr;
	try {
		if (anotherExceptionPtr) {
			std::rethrow_exception(anotherExceptionPtr);
		}

	} catch (const some_exception & e) {
		std::cout << "catched int value: " << e.v << std::endl;
	}
}

void checkMakeExceptionPtr() {
	std::exception_ptr currentException = std::make_exception_ptr(some_exception(20));
	std::cout << "exception_ptr constructed" << std::endl;

	rethrowException(currentException);
}

void exceptionPtrSample() {
	rethrowException(throwExceptionAndCaptureExceptionPtr());
	checkMakeExceptionPtr();
}

Если мы запустим функцию exceptionPtrSample на выполнение, то увидим примерно следующий результат:

throwing 10…
int ctor
catched int value: 10
catched int value: 10
int ctor
copy ctor
copy ctor
exception_ptr constructed
catched int value: 20
catched int value: 20

Для того чтобы можно было удобно работать с exception_ptr, есть несколько вспомогательных функций:

• current_exception — данная функция возвращает exception_ptr. Если мы находимся внутри блока catch, то возвращает exception_ptr, который содержит обрабатываемое в данный момент текущим потоком исключение, если вызывать ее вне блока catch, то она вернет пустой объект exception_ptr
• rethrow_exception — данная функция бросает исключение, которое содержится в exception_ptr. Если входной параметр не содержит исключения (пустой объект), то результат не определен. При этом msvc кидает std::bad_exception, а программа собранная с помощью gcc-4.7.2 неожиданно завершается.
• make_exception_ptr — данная функция, может сконструировать exception_ptr без бросания исключения. Ее предназначение аналогично функции std::make_shared — конструирование объекта. Ее выполнение аналогично функции throwExceptionAndCaptureExceptionPtr. В реализации от gcc-4.7.2 make_exception_ptr делает два копирования объекта some_exception.

Передача исключений между потоками

Как мне кажется, тип exception_ptr создавался именно для решения проблемы передачи исключений между потоками, поэтому давайте разберемся, каким образом мы можем передать исключение из одного потока в другой:

void worker(std::promise<void> & p) {
	try {
		throw std::runtime_error("exception from thread");
	} catch (...) {
		p.set_exception(std::current_exception());
	}
}

void checkThreadAndException() {
	std::promise<void> p;
	auto result = p.get_future();

	std::thread t(worker, ref(p));
	t.detach();

	try {
		result.get();
	} catch (const std::runtime_error & e) {
		std::cout << "runtime error catched from async worker" << std::endl;
	}
}

Вообще, многопоточность в C++11 — это обширная тема, там есть свои тонкости, нюансы и о них следует писать отдельно. Сейчас мы рассмотрим этот пример только ради передачи исключения. Запускаем функцию worker в отдельном потоке, и эта функция кидает исключение. Объект класса promise позволяет организовать связь между разными потоками, и атомарно передать значения из одного потока в другой (или исключение). В данном примере мы как раз пользуемся методом set_exception, который принимает exception_ptr в качестве параметра. Для того чтобы получить значение, мы создаем объект класса future — это наш result и вызываем метод get. Также необходимо у потока вызвать метод detach или join, так как при разрушении объекта t в деструкторе проверяется, чтобы joinable() == false, иначе вызывается std::terminate. Скорее всего, это связано с тем, чтобы программист не «отпускал потоки на волю», а всегда следил за ними (либо отпускал явно с помощью метода detach)

Отдельно стоит сказать об использовании многопоточности в gcc-4.7. Изначально этот пример у меня не работал (выбрасывал исключение), погуглив, я выяснил, что для использования std::thread необходимо передать линкеру флаг -pthread. Так как я использую CMake в качестве системы сборки, то эта задача упрощается (тут сложность может возникнуть при использовании gcc на разных платформах, например на sparc solaris используется флаг -thread вместо -pthread) — есть специальный CMake модуль Threads, в котором эта проблема решена:

find_package(Threads REQUIRED)
#…
target_link_libraries(cxx_exceptions ${CMAKE_THREAD_LIBS_INIT})

Nested exceptions

Как видно из названия, данный механизм позволяет «прицепить» к кидаемому исключению другие исключения (которые могли быть брошены раньше). Например, если у нас есть своя иерархия исключений, то мы можем ловить все «сторонние» исключения, прицеплять их к своим исключениям, а при обработке своих исключений мы можем выводить доп. информацию, которая к ним «прицеплена» (например, при отладке, мы можем печатать информацию о сторонних исключениях). Хороший пример использования nested exception приведен на cppreference.com, мой пример, отчасти пересекается с ним:

struct third_party_exception {
	explicit third_party_exception(int e) : code(e) {
	}

	int code;
};


void third_party_worker() {
	throw third_party_exception(100);
}

class our_exception : public std::runtime_error {
public:
	our_exception(const std::string & e) : std::runtime_error("our error: " + e) {
	}
};

void ourWorker() {
	try {
		third_party_worker();
	} catch (...) {
		throw_with_nested(our_exception("worker failed"));
	}
}

void exceptionHandler(const our_exception & e, bool catchNested) {
	std::cerr << "our exception catched: " << e.what();

	if (catchNested) {
		try {
			rethrow_if_nested(e);
		} catch (const third_party_exception & e) {
			std::cerr << ", low level reason is: " << e.code;
		}
	}

	std::cerr << std::endl;
}

void exceptionProcessing() {
	try {
		ourWorker();
	} catch (const our_exception & e) {
		exceptionHandler(e, false);
	}

	try {
		ourWorker();
	} catch (const our_exception & e) {
		exceptionHandler(e, true);
	}
}

Итак, у нас есть сторонняя функция, которая кидает исключение, мы можем написать адаптер, который ловит «сторонние» исключения, и из них делает «наше» исключение: в качестве «сторонней» функции и «нашей» функции выступают соответственно third_party_worker и ourWorker. Мы ловим все исключения, и бросаем далее уже наше (our_exception) исключение, при этом, к нему было прицеплено какое-то (мы в принципе можем и не знать какое) «стороннее» исключение. После этого работаем уже с нашими исключениями. При этом, если нам понадобится более детальная информация о том, что происходило на «нижнем» уровне, то мы всегда можем вызвать функцию rethrow_if_nested. Данная функция анализирует, если ли прицепленное (вложенное) исключение, и если есть, то бросает это вложенное исключение. Функция exceptionHandler принимает «наше» исключение и дополнительный флаг, который разрешает или запрещает вывод информации о стороннем исключении. Мы можем управлять выводом сторонних исключений, управляя параметром catchNested, например, из файла конфигурации (или в зависимости от сборки — Release, Debug).

Для работы с nested exception есть один класс и две функции:

• nested_exception — данный класс «подмешивается» к бросаемому объекту при вызове функции std::throw_with_nested — этот класс также позволяет вернуть вложенное исключение (exception_ptr) с помощью метода nested_ptr. Также этот класс имеет метод rethrow_nested, который бросает вложенное исключение
• throw_with_nested — данная шаблонная функция принимает объект некоторого типа (назовем его InputType), и бросает объект который является наследником std::nested_exception и нашего InputType (в реализации от gcc — это шаблонный тип, который наследуется от nested_exception и InputType). Таким образом, мы можем ловить как объект нашего типа, так и объект типа nested_exception и уже потом получать наш тип через метод nested_ptr
• rethrow_if_nested — данная функция определяет, есть ли у объекта вложенное исключение, и если есть, то бросает его. Реализация может использовать dynamic_cast для определения наследования

В принципе, механизм nested exception довольно интересный, хотя реализация может быть довольно тривиальна, ее можно сделать самому, с помощью ранее описанных функций current_exception и rethrow_exception. В той же реализации gcc, класс nested_exception содержит одно поле типа exception_ptr, которое инициализируется в конструкторе с помощью функции current_exception, а реализация метода rethrow_nested просто вызывает функцию rethrow_exception.

Спецификация noexcept

Данный механизм можно рассматривать как расширенный (и ныне устаревший) механизм throw(). Основное его предназначение как и раньше — гарантия того что, функция не бросит исключение (если гарантия нарушается, то вызывается std::terminate).

Используется этот механизм в двух видах, аналогично старому throw()

void func() noexcept {
//...
}

И в новом виде:

void func() noexcept(boolean_expression_known_at_compile_time) {
//...
}

При этом, если значение выражения вычислено как истина, то функция помечается как noexcept, иначе, такой гарантии нет.
Также есть соответствующий оператор noexcept(expression), который тоже выполняется в compile time, этот оператор возвращает истину, если выражение не бросает исключение:

void noexceptSample() {
	cout << "noexcept int():         " << noexcept(int()) << endl;
	cout << "noexcept vector<int>(): " << noexcept(vector<int>()) << endl;
}

Данный код для gcc-4.7.2 выводит:

noexcept int(): 1
noexcept vector<int>(): 0

Здесь мы видим, что конструктор встроенного типа int не бросает исключение, а конструктор вектора может бросить (не помечен как noexcept).
Это удобно применять в шаблонном метапрограмировании, используя данный оператор мы можем написать шаблонную функцию, которая в зависимости от параметра шаблона может быть помечена как noexcept или нет:

template <typename InputTypeT>
void func() noexcept(noexcept(InputTypeT())) {
	InputTypeT var;
	/// do smth with var
	std::cout << "func called, object size: " << sizeof(var) << std::endl;
}

void noexceptSample() {
	std::cout << "noexcept int():         " << noexcept(int()) << std::endl;
	std::cout << "noexcept vector<int>(): " << noexcept(std::vector<int>()) << std::endl << std::endl;

	/// @note function is not actually called
	std::cout << "noexcept func<int>:         " << noexcept(func<int>()) << std::endl;
	std::cout << "noexcept func<vector<int>>: " << noexcept(func<std::vector<int>>()) << std::endl;
}

Данный пример выводит:

noexcept int(): 1
noexcept vector<int>(): 0

noexcept func<int>: 1
noexcept func<vector<int>>: 0

Резюме

Стандарт C++11 привнес много нового в обработку ошибок, конечно, ключевой особенностью здесь остается exception_ptr и возможность передачи произвольных исключений как обычные объекты (в функции, передавать исключения между потоками). Раньше, в каждом потоке приходилось писать развесистый try… catch для всех исключений, а этот функционал существенно минимизирует количество try… catch кода.

Также появилась возможность создавать вложенные исключения, в принципе в библиотеке boost есть механизм boost::exception, который позволяет прикреплять к объекту произвольные данные (например коды ошибок, свои сообщения и пр), но он решает другие задачи — передачу произвольных данных внутри исключения.

Ну и наконец, для тех, кому нужны гарантии, что код не бросит исключения, есть noexcept, в частности, многие части стандартной библиотеки используют этот механизм.

Как обычно, все примеры выложены на github

Update 1. Убрал из примеров using namespace std, теперь видно какие сущности относятся к стандартной библиотеке, а какие нет.

Типы исключений

Последнее обновление: 05.10.2017

Кроме типа exception в C++ есть еще несколько производных типов исключений, которые могут использоваться при различных ситуациях. Основные из них:

• runtime_error: общий тип исключений, которые возникают во время выполнения

• range_error: исключение, которое возникает, когда полученный результат превосходит допустимый диапазон

• overflow_error: исключение, которое возникает, если полученный результат превышает допустимый диапазон

• underflow_error: исключение, которое возникает, если полученный в вычислениях результат имеет недопустимые отрицательное значение (выход за нижнюю допустимую границу значений)

• logic_error: исключение, которое возникает при наличии логических ошбок к коде программы

• domain_error: исключение, которое возникает, если для некоторого значения, передаваемого в функцию, не определено результата

• invalid_argument: исключение, которое возникает при передаче в функцию некорректного аргумента

• length_error: исключение, которое возникает при попытке создать объект большего размера, чем допустим для данного типа

• out_of_range: исключение, которое возникает при попытке доступа к элементам вне допустимого диапазона

Большинство этих типов определено в заголовочном файле stdexcept, за исключением класса bad_alloc,
который определн в файле new, и класса bad_cast, который определен в файле
type_info.

В отличие от классов exception, bad_alloc и bad_cast в конструкторы других типов можно передать строку, то есть таким образом можно передать сообщение об ошибке.

Конструкция try…catch может использовать несколько блоков catch для обработки различных типов исключений. При возникновении исключения
для его обработки будет выбран тот, который использует тип возникшего исключения.

При использовании нескольких блоков catch вначале помещаются блоки catch, которые обрабатывают более частные исключения, а только потом блоки catch с более
общими типами исключений:

#include <iostream>
#include <exception>
#include <stdexcept>

double divide(int, int);

int main()
{
	int x = 500;
	int y = 0;
	try
	{
		double z = divide(x, y);
		std::cout << z << std::endl;
	}
	catch (std::overflow_error err)
	{
		std::cout << "Overflow_error: " << err.what() << std::endl;
	}
	catch (std::runtime_error err)
	{
		std::cout << "Runtime_error: " << err.what() << std::endl;
	}
	catch (std::exception err)
	{
		std::cout << "Exception!!!"<< std::endl;
	}
	std::cout << "The End..." << std::endl;
	return 0;
}

double divide(int a, int b)
{
	if (b == 0)
		throw std::runtime_error("Division by zero!");
	return a / b;
}

Здесь функция divide, если параметр b равен 0, выбрасывает исключение типа runtime_error. Исключение инициализируется
сообщением об ошибке «Division by zero!».

В функции main конструкция try..catch использует три блока catch. Причем последний блок представляет самый общий тип исключений exception. Второй блок
обрабатывает исключения типа runtime_error, производный от exception. А первый блок обрабатывает исключения типа overflow_error, который является производным от
runtime_error.

Также все типы исключений имеют метод what(), который возвращает информацию об ошибке. И в данном случае программа выдаст следующий результат:

Runtime_error: Division by zero!
The End...

Исключение исключений

Блок try/catch используется для обнаружения исключений. Код в разделе try — это код, который может вызывать исключение, а код в выражении (-ах) catch обрабатывает исключение.

#include <iostream>
#include <string>
#include <stdexcept>

int main() {
  std::string str("foo");
  
  try {
      str.at(10); // access element, may throw std::out_of_range
  } catch (const std::out_of_range& e) {
      // what() is inherited from std::exception and contains an explanatory message
      std::cout << e.what();
  }
}

Несколько catch ключем могут использоваться для обработки нескольких типов исключений. Если присутствуют множественные предложения catch , механизм обработки исключений пытается сопоставить их в порядке их появления в коде:

std::string str("foo");
  
try {
    str.reserve(2); // reserve extra capacity, may throw std::length_error
    str.at(10); // access element, may throw std::out_of_range
} catch (const std::length_error& e) {
    std::cout << e.what();
} catch (const std::out_of_range& e) {
    std::cout << e.what();
}

Классы исключений, которые выведены из общего базового класса, могут быть пойманы с помощью одного предложения catch для общего базового класса. Вышеприведенный пример может заменить два предложения catch для std::length_error и std::out_of_range с одним предложением для std:exception :

std::string str("foo");
  
try {
    str.reserve(2); // reserve extra capacity, may throw std::length_error
    str.at(10); // access element, may throw std::out_of_range
} catch (const std::exception& e) {
    std::cout << e.what();
}

Поскольку предложения catch проверяются по порядку, не забудьте сначала написать более конкретные предложения catch, иначе ваш код обработки исключений никогда не будет вызван:

try {
    /* Code throwing exceptions omitted. */
} catch (const std::exception& e) {
    /* Handle all exceptions of type std::exception. */
} catch (const std::runtime_error& e) {
    /* This block of code will never execute, because std::runtime_error inherits
       from std::exception, and all exceptions of type std::exception were already
       caught by the previous catch clause. */
}

Другая возможность — обработчик catch-all, который поймает любой брошенный объект:

try {
    throw 10;
} catch (...) {
    std::cout << "caught an exception";
}

Исключение Rethrow (распространение)

Иногда вы хотите что-то сделать, за исключением того, что вы улавливаете (например, записываете в журнал или печатаете предупреждение) и позволяете ему переходить в верхнюю область обработки. Для этого вы можете восстановить любое исключение, которое вы поймаете:

try {
    ... // some code here
} catch (const SomeException& e) {
    std::cout << "caught an exception";
    throw;
}

Использование throw; без аргументов будет повторно выбрано текущее исключение.

#include <iostream>
#include <string>
#include <exception>
#include <stdexcept>
 
void handle_eptr(std::exception_ptr eptr) // passing by value is ok
{
    try {
        if (eptr) {
            std::rethrow_exception(eptr);
        }
    } catch(const std::exception& e) {
        std::cout << "Caught exception "" << e.what() << ""n";
    }
}
 
int main()
{
    std::exception_ptr eptr;
    try {
        std::string().at(1); // this generates an std::out_of_range
    } catch(...) {
        eptr = std::current_exception(); // capture
    }
    handle_eptr(eptr);
} // destructor for std::out_of_range called here, when the eptr is destructed

Функция Try Blocks В конструкторе

Единственный способ исключить исключение в списке инициализаторов:

struct A : public B
{
    A() try : B(), foo(1), bar(2)
    {
        // constructor body 
    }
    catch (...)
    {
        // exceptions from the initializer list and constructor are caught here
        // if no exception is thrown here
        // then the caught exception is re-thrown.
    }
 
private:
    Foo foo;
    Bar bar;
};

Функция Try Block для регулярной функции

void function_with_try_block() 
try
{
    // try block body
} 
catch (...) 
{ 
    // catch block body
}

Это эквивалентно

void function_with_try_block() 
{
    try
    {
        // try block body
    } 
    catch (...) 
    { 
        // catch block body
    }
}

Обратите внимание, что для конструкторов и деструкторов поведение отличается от того, что блок catch повторно выбрасывает исключение (пойманное, если в блоке блока catch нет другого броска).

Функция main разрешено иметь функцию попробовать блок , как и любой другой функции, но main функция попытка блока «s не перехватывать исключения , которые происходят во время строительства нелокального статической переменной или уничтожения любой статической переменной. Вместо этого вызывается std::terminate .

Функция Try Blocks В деструкторе

struct A
{
    ~A() noexcept(false) try
    {
        // destructor body 
    }
    catch (...)
    {
        // exceptions of destructor body are caught here
        // if no exception is thrown here
        // then the caught exception is re-thrown.
    }
};

Обратите внимание, что, хотя это возможно, нужно быть очень осторожным с бросанием из деструктора, как если бы деструктор, вызванный во время разматывания стека, выдает исключение, вызывается std::terminate .

Лучшая практика: бросать по значению, вызывать по ссылке const

В общем, считается хорошей практикой бросать по значению (а не по указателю), а ухватить ссылкой (const).

try {
    // throw new std::runtime_error("Error!");   // Don't do this!
    // This creates an exception object
    // on the heap and would require you to catch the
    // pointer and manage the memory yourself. This can
    // cause memory leaks!
    
    throw std::runtime_error("Error!");
} catch (const std::runtime_error& e) {
    std::cout << e.what() << std::endl;
}

Одной из причин, почему ловить по ссылке является хорошей практикой, является то, что она устраняет необходимость в восстановлении объекта при передаче в блок catch (или при распространении на другие блоки catch). Захват по ссылке также позволяет обрабатывать исключения из-за полиморфизма и избегать фрагментации объектов. Однако, если вы воссоздаете исключение (например, throw e; см. Пример ниже), вы все равно можете получить фрагмент объекта, потому что throw e; оператор делает копию исключения как любой тип объявлен:

#include <iostream>

struct BaseException {
    virtual const char* what() const { return "BaseException"; }
};

struct DerivedException : BaseException {
    // "virtual" keyword is optional here
    virtual const char* what() const { return "DerivedException"; }
};

int main(int argc, char** argv) {
    try {
        try {
            throw DerivedException();
        } catch (const BaseException& e) {
            std::cout << "First catch block: " << e.what() << std::endl;
            // Output ==> First catch block: DerivedException

            throw e; // This changes the exception to BaseException
                     // instead of the original DerivedException!
        }
    } catch (const BaseException& e) {
        std::cout << "Second catch block: " << e.what() << std::endl;
        // Output ==> Second catch block: BaseException
    }
    return 0;
}

Если вы уверены, что не собираетесь делать что-либо, чтобы изменить исключение (например, добавить информацию или изменить сообщение), catching by const reference позволяет компилятору сделать оптимизацию и повысить производительность. Но это все равно может привести к сращиванию объектов (как видно из приведенного выше примера).

Предупреждение. Не забывайте бросать непреднамеренные исключения в блоки catch , особенно связанные с распределением дополнительной памяти или ресурсов. Например, при построении logic_error , runtime_error или их подклассов может возникнуть bad_alloc из-за bad_alloc памяти при копировании строки исключения, потоки ввода-вывода могут возникать при регистрации с соответствующими масками маски исключений и т. Д.

Вложенное исключение

#include <stdexcept>
#include <exception>
#include <string>
#include <fstream>
#include <iostream>

struct MyException
{
    MyException(const std::string& message) : message(message) {}
    std::string message;
};

void print_current_exception(int level)
{
    try {
        throw;
    } catch (const std::exception& e) {
        std::cerr << std::string(level, ' ') << "exception: " << e.what() << 'n';
    } catch (const MyException& e) {
        std::cerr << std::string(level, ' ') << "MyException: " << e.message << 'n';
    } catch (...) {
        std::cerr << "Unkown exceptionn";
    }
}

void print_current_exception_with_nested(int level =  0)
{
    try {
        throw;
    } catch (...) {
        print_current_exception(level);
    }    
    try {
        throw;
    } catch (const std::nested_exception& nested) {
        try {
            nested.rethrow_nested();
        } catch (...) {
            print_current_exception_with_nested(level + 1); // recursion
        }
    } catch (...) {
        //Empty // End recursion
    }
}

// sample function that catches an exception and wraps it in a nested exception
void open_file(const std::string& s)
{
    try {
        std::ifstream file(s);
        file.exceptions(std::ios_base::failbit);
    } catch(...) {
        std::throw_with_nested(MyException{"Couldn't open " + s});
    }
}
 
// sample function that catches an exception and wraps it in a nested exception
void run()
{
    try {
        open_file("nonexistent.file");
    } catch(...) {
        std::throw_with_nested( std::runtime_error("run() failed") );
    }
}
 
// runs the sample function above and prints the caught exception
int main()
{
    try {
        run();
    } catch(...) {
        print_current_exception_with_nested();
    }
}

exception: run() failed
 MyException: Couldn't open nonexistent.file
  exception: basic_ios::clear

СТД :: uncaught_exceptions

#include <exception>
#include <string>
#include <iostream>

// Apply change on destruction:
// Rollback in case of exception (failure)
// Else Commit (success)
class Transaction
{
public:
    Transaction(const std::string& s) : message(s) {}
    Transaction(const Transaction&) = delete;
    Transaction& operator =(const Transaction&) = delete;
    void Commit() { std::cout << message << ": Commitn"; }
    void RollBack() noexcept(true) { std::cout << message << ": Rollbackn"; }

    // ...

    ~Transaction() {
        if (uncaughtExceptionCount == std::uncaught_exceptions()) {
            Commit(); // May throw.
        } else { // current stack unwinding
            RollBack();
        }
    }

private:
    std::string message;
    int uncaughtExceptionCount = std::uncaught_exceptions();
};

class Foo
{
public:
    ~Foo() {
        try {
            Transaction transaction("In ~Foo"); // Commit,
                                            // even if there is an uncaught exception
            //...
        } catch (const std::exception& e) {
            std::cerr << "exception/~Foo:" << e.what() << std::endl;
        }
    }
};

int main()
{
    try {
        Transaction transaction("In main"); // RollBack
        Foo foo; // ~Foo commit its transaction.
        //...
        throw std::runtime_error("Error");
    } catch (const std::exception& e) {
        std::cerr << "exception/main:" << e.what() << std::endl;
    }
}

In ~Foo: Commit
In main: Rollback
exception/main:Error

Пользовательское исключение

Вы не должны бросать исходные значения в качестве исключений, вместо этого используйте один из стандартных классов исключений или создавайте свои собственные.

Наличие собственного класса исключений, унаследованного от std::exception — хороший способ обойти это. Вот специальный класс исключений, который непосредственно наследуется от std::exception :

#include <exception>

class Except: virtual public std::exception {
    
protected:

    int error_number;               ///< Error number
    int error_offset;               ///< Error offset
    std::string error_message;      ///< Error message
    
public:

    /** Constructor (C++ STL string, int, int).
     *  @param msg The error message
     *  @param err_num Error number
     *  @param err_off Error offset
     */
    explicit 
    Except(const std::string& msg, int err_num, int err_off):
        error_number(err_num),
        error_offset(err_off),
        error_message(msg)
        {}

    /** Destructor.
     *  Virtual to allow for subclassing.
     */
    virtual ~Except() throw () {}

    /** Returns a pointer to the (constant) error description.
     *  @return A pointer to a const char*. The underlying memory
     *  is in possession of the Except object. Callers must
     *  not attempt to free the memory.
     */
    virtual const char* what() const throw () {
       return error_message.c_str();
    }
    
    /** Returns error number.
     *  @return #error_number
     */
    virtual int getErrorNumber() const throw() {
        return error_number;
    }
    
    /**Returns error offset.
     * @return #error_offset
     */
    virtual int getErrorOffset() const throw() {
        return error_offset;
    }

};

Пример броска catch:

try {
    throw(Except("Couldn't do what you were expecting", -12, -34));
} catch (const Except& e) {
    std::cout<<e.what()
             <<"nError number: "<<e.getErrorNumber()
             <<"nError offset: "<<e.getErrorOffset();
}

Поскольку вы не просто бросаете сообщение об ошибке, а также некоторые другие значения, представляющие, что именно было в точности, ваша обработка ошибок становится намного более эффективной и значимой.

Есть класс исключений, который позволяет вам обрабатывать сообщения об ошибках красиво: std::runtime_error

Вы также можете унаследовать этот класс:

#include <stdexcept>

class Except: virtual public std::runtime_error {
    
protected:

    int error_number;               ///< Error number
    int error_offset;               ///< Error offset
    
public:

    /** Constructor (C++ STL string, int, int).
     *  @param msg The error message
     *  @param err_num Error number
     *  @param err_off Error offset
     */
    explicit 
    Except(const std::string& msg, int err_num, int err_off):
        std::runtime_error(msg)
        {
            error_number = err_num;
            error_offset = err_off;
            
        }

    /** Destructor.
     *  Virtual to allow for subclassing.
     */
    virtual ~Except() throw () {}
    
    /** Returns error number.
     *  @return #error_number
     */
    virtual int getErrorNumber() const throw() {
        return error_number;
    }
    
    /**Returns error offset.
     * @return #error_offset
     */
    virtual int getErrorOffset() const throw() {
        return error_offset;
    }

};

Обратите внимание, что я не переопределил функцию what() из базового класса ( std::runtime_error ), то есть мы будем использовать версию класса base what() . Вы можете переопределить его, если у вас есть дальнейшая повестка дня.

std::exception is the class whose only purpose is to serve as the base class in the exception hierarchy. It has no other uses. In other words, conceptually it is an abstract class (even though it is not defined as abstract class in C++ meaning of the term).

std::runtime_error is a more specialized class, descending from std::exception, intended to be thrown in case of various runtime errors. It has a dual purpose. It can be thrown by itself, or it can serve as a base class to various even more specialized types of runtime error exceptions, such as std::range_error, std::overflow_error etc. You can define your own exception classes descending from std::runtime_error, as well as you can define your own exception classes descending from std::exception.

Just like std::runtime_error, standard library contains std::logic_error, also descending from std::exception.

The point of having this hierarchy is to give user the opportunity to use the full power of C++ exception handling mechanism. Since ‘catch’ clause can catch polymorphic exceptions, the user can write ‘catch’ clauses that can catch exception types from a specific subtree of the exception hierarchy. For example, catch (std::runtime_error& e) will catch all exceptions from std::runtime_error subtree, letting all others to pass through (and fly further up the call stack).

P.S. Designing a useful exception class hierarchy (that would let you catch only the exception types you are interested in at each point of your code) is a non-trivial task. What you see in standard C++ library is one possible approach, offered to you by the authors of the language. As you see, they decided to split all exception types into «runtime errors» and «logic errors» and let you proceed from there with your own exception types. There are, of course, alternative ways to structure that hierarchy, which might be more appropriate in your design.

Update: Portability Linux vs Windows

As Loki Astari and unixman83 noted in their answer and comments below, the constructor of the exception class does not take any arguments according to C++ standard. Microsoft C++ has a constructor taking arguments in the exception class, but this is not standard. The runtime_error class has a constructor taking arguments (char*) on both platforms, Windows and Linux. To be portable, better use runtime_error.

(And remember, just because a specification of your project says your code does not have to run on Linux, it does not mean it does never have to run on Linux.)

Signals an erroneous condition and executes an error handler.

Syntax

Explanation

See try-catch block for more information abouttryandcatch(exception handler) blocks 1) First, copy-initializes theexception objectfrom expression

• The copy/move(since C++11) may be subject to copy elision

then transfers control to the exception handler with the matching type for which the compound statement or member initializer list that follows the keyword try was most recently entered and not exited by this thread of execution.

2) Rethrows the currently handled exception. Abandons the execution of the current catch block and passes control to the next matching exception handler (but not to another catch clause after the same try block: its compound-statement is considered to have been ‘exited’), reusing the existing exception object: no new objects are made. This form is only allowed when an exception is presently being handled (it calls std::terminate if used otherwise). The catch clause associated with a function-try-block must exit via rethrowing if used on a constructor.

See std::terminate and std::unexpected(until C++17) for the handling of errors that arise during exception handling.

The exception object

The exception object is a temporary object in unspecified storage that is constructed by the throw expression.

The type of theexception object is the static type of expression with top-level cv-qualifiers removed. Array and function types are adjusted to pointer and pointer to function types, respectively. If the type of the exception object would be an incomplete type, an abstract class type, or pointer to incomplete type other than pointer to (cv-qualified) void, the throw-expression is a compile-time error. If the type of expression is a class type, its copy/move(since C++11) constructor and destructor must be accessible even if copy elision takes place.

Unlike other temporary objects, the exception object is considered to be an lvalue argument when initializing the catch clause parameters, so it can be caught by lvalue reference, modified, and rethrown.

The exception object persists until the last catch clause exits other than by rethrowing (if not by rethrowing, it is destroyed immediately after the destruction of the catch clause’s parameter), or until the last std::exception_ptr that references this object is destroyed (in which case the exception object is destroyed just before the destructor of std::exception_ptr returns.

Stack unwinding

Once the exception object is constructed, the control flow works backwards (up the call stack) until it reaches the start of a try block, at which point the parameters of all associated catch blocks are compared, in order of appearance, with the type of the exception object to find a match (see try-catch for details on this process). If no match is found, the control flow continues to unwind the stack until the next try block, and so on. If a match is found, the control flow jumps to the matching catch block.

As the control flow moves up the call stack, destructors are invoked for all objects with automatic storage duration that are constructed, but not yet destroyed, since the corresponding try-block was entered, in reverse order of completion of their constructors. If an exception is thrown from a destructor of a local variable or of a temporary used in a return statement, the destructor for the object returned from the function is also invoked.

If an exception is thrown from a constructor or (rare) from a destructor of an object (regardless of the object’s storage duration), destructors are called for all fully-constructed non-static non-variant members and base classes, in reverse order of completion of their constructors. Variant members of union-like classes are only destroyed in the case of unwinding from constructor, and if the active member changed between initialization and destruction, the behavior is undefined.

If the exception is thrown from a constructor that is invoked by a new-expression, the matching deallocation function is called, if available.

This process is calledstack unwinding.

If any function that is called directly by the stack unwinding mechanism, after initialization of the exception object and before the start of the exception handler, exits with an exception, std::terminate is called. Such functions include destructors of objects with automatic storage duration whose scopes are exited, and the copy constructor of the exception object that is called (if not elided) to initialize catch-by-value arguments.

If an exception is thrown and not caught, including exceptions that escape the initial function of std::thread, the main function, and the constructor or destructor of any static or thread-local objects, then std::terminate is called. It is implementation-defined whether any stack unwinding takes place for uncaught exceptions.

Notes

When rethrowing exceptions, the second form must be used to avoid object slicing in the (typical) case where exception objects use inheritance:

try
{
    std::string("abc").substr(10); // throws std::length_error
}
catch (const std::exception& e)
{
    std::cout << e.what() << 'n';
//  throw e; // copy-initializes a new exception object of type std::exception
    throw;   // rethrows the exception object of type std::length_error
}

The throw-expression is classified as prvalue expression of type void. Like any other expression, it may be a sub-expression in another expression, most commonly in the conditional operator:

double f(double d)
{
    return d > 1e7 ? throw std::overflow_error("too big") : d;
}
 
int main()  
{
    try
    {
        std::cout << f(1e10) << 'n';
    }
    catch (const std::overflow_error& e)
    {
        std::cout << e.what() << 'n';
    }
}

Keywords

throw.

Example

#include <iostream>
#include <stdexcept>
 
struct A
{
    int n;
 
    A(int n = 0): n(n) { std::cout << "A(" << n << ") constructed successfullyn"; }
    ~A() { std::cout << "A(" << n << ") destroyedn"; }
};
 
int foo()
{
    throw std::runtime_error("error");
}
 
struct B
{
    A a1, a2, a3;
 
    B() try : a1(1), a2(foo()), a3(3)
    {
        std::cout << "B constructed successfullyn";
    }
    catch(...)
    {
            std::cout << "B::B() exiting with exceptionn";
    }
 
    ~B() { std::cout << "B destroyedn"; }
};
 
struct C : A, B
{
    C() try
    {
        std::cout << "C::C() completed successfullyn";
    }
    catch(...)
    {
        std::cout << "C::C() exiting with exceptionn";
    }
 
    ~C() { std::cout << "C destroyedn"; }
};
 
int main () try
{
    
    
    
    
    
    C c;
}
catch (const std::exception& e)
{
    std::cout << "main() failed to create C with: " << e.what();
}

A(0) constructed successfully
A(1) constructed successfully
A(1) destroyed
B::B() exiting with exception
A(0) destroyed
C::C() exiting with exception
main() failed to create C with: error

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also

• copy elision
• try-catch block
• noexcept specifier
• dynamic exception specifications

C++

• Templates

  A template is C++ entity that defines one of the following: Templates are parameterized by one or more parameters, of three kinds: type non-type and When

• The this pointer

  The expression this an rvalue (until C++11)a prvalue (since whose address of implicit object parameter which non-static member function being called).

• Transactional memory

  Transactional memory is concurrency synchronization mechanism that combines groups of statements transactions, are.

• Phases of translation

  The C++ source file is processed by compiler as if following phases take place, this exact order: Newlines are kept, and it’s unspecified whether non-newline