Функциональный try-блок в С++ / Ravesli

На этом уроке мы рассмотрим, что такое функциональный try-блок в языке С++, как его использовать и какие есть нюансы.

Оглавление:

Функциональный try-блок
Не используйте функциональный try-блок для очистки памяти
Заключение

Функциональный try-блок

Функционала блоков try и catch вполне достаточно в большинстве случаев, но есть одна конкретная ситуация, в которой их стандартного функционала не хватает. Рассмотрим следующий код:

#include <iostream>

class A
{
private:
	int m_x;
public:
	A(int x) : m_x(x)
	{
		if (x <= 0)
			throw 1;
	}
};
 
class B : public A
{
public:
	B(int x) : A(x)
	{
		// Что произойдет, если создать A не удастся, а исключение нужно обрабатывать здесь?
	}
};
 
int main()
{
	try
	{
		B b(0);
	}
	catch (int)
	{
		std::cout << "Oops!\n";
	}
}

#include <iostream>

class A

{

private:

int m_x;

public:

A(int x) : m_x(x)

{

if (x <= 0)

throw 1;

}

};

class B : public A

{

public:

B(int x) : A(x)

{

// Что произойдет, если создать A не удастся, а исключение нужно обрабатывать здесь?

}

};

int main()

{

try

{

B b(0);

}

catch (int)

{

std::cout << "Oops!\n";

}

В программе, приведенной выше, дочерний класс B вызывает конструктор родительского класса A, который генерирует исключение (при успешном выполнении условия). Поскольку объект b создается в блоке try функции main(), то, если A выбросит исключение, блок try функции main() поймает его и передаст обработчику catch (int).

Следовательно, результат выполнения программы:

Oops!

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

В этой ситуации мы должны использовать слегка модифицированный блок try — функциональный try-блок. Функциональный try-блок используется для расположения обработчика исключений вокруг всего тела функции, а не только вокруг её определенной части (блока кода).

Синтаксис немного сложен для описания, поэтому рассмотрим всё на примере:

#include <iostream>
 
class A
{
private:
	int m_x;
public:
	A(int x) : m_x(x)
	{
		if (x <= 0)
			throw 1;
	}
};
 
class B : public A
{
public:
	B(int x) try : A(x) // обратите внимание на ключевое слово try здесь
	{
	}
	catch (...) // обратите внимание, этот блок находится на том же уровне отступа, что и конструктор
	{
                // Исключения из списка инициализации членов класса B или тела конструктора обрабатываются здесь
 
                std::cerr << "Construction of A failed\n";
 
                // Если мы здесь не будем явно выбрасывать исключение, то текущее (пойманное) исключение будет повторно сгенерировано и отправлено в стек вызовов
	}
};
 
int main()
{
	try
	{
		B b(0);
	}
	catch (int)
	{
		std::cout << "Oops!\n";
	}
}

#include <iostream>

class A

{

private:

int m_x;

public:

A(int x) : m_x(x)

{

if (x <= 0)

throw 1;

}

};

class B : public A

{

public:

B(int x) try : A(x) // обратите внимание на ключевое слово try здесь

{

}

catch (...) // обратите внимание, этот блок находится на том же уровне отступа, что и конструктор

{

// Исключения из списка инициализации членов класса B или тела конструктора обрабатываются здесь

std::cerr << "Construction of A failed\n";

// Если мы здесь не будем явно выбрасывать исключение, то текущее (пойманное) исключение будет повторно сгенерировано и отправлено в стек вызовов

}

};

int main()

{

try

{

B b(0);

}

catch (int)

{

std::cout << "Oops!\n";

}

Результат выполнения программы:

Construction of A failed Oops!

Рассмотрим эту программу более детально.

Во-первых, обратите внимание на добавление ключевого слова try перед списком инициализации членов класса B. Это означает, что всё, что находится после этого ключевого слова (вплоть до конца функции), рассматривается как часть блока try.

Во-вторых, блок catch находится на том же уровне отступа, что и вся функция. Любое исключение, выброшенное между ключевым словом try и концом тела конструктора, будет обработано этим же блоком catch.

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

В программе, приведенной выше, поскольку мы явно не генерируем исключение внутри блока catch, исключение повторно генерируется и передается caller-у на уровень выше, т.е. в функцию main(). Блок catch функции main() ловит и обрабатывает исключение и мы получаем Oops!.

Хотя функциональные try-блоки также могут использоваться и с обычными функциями, которые не являются методами класса, это не распространенная практика, так как случаев, где они могут быть полезны, очень и очень мало. Они почти всегда используются только с конструкторами!

Не используйте функциональный try-блок для очистки памяти

Если операция создания объекта неуспешна, то деструктор класса не вызывается. Следовательно, у вас может возникнуть соблазн использовать функциональный try-блок для очистки классом частично выделенной ему памяти. Однако, обращение к членам объекта, который не создался, считается неопределенным поведением, так как объект «мёртв» еще до начала выполнения блока catch. Это означает, что вы не можете использовать функциональный try-блок для выполнения очистки памяти класса.

Заключение

Функциональные try-блоки полезны в основном для записывания ошибок в лог-файл перед их передачей на уровень выше в стеке вызовов или для изменения типа выбрасываемого исключения.

Оценить статью:

(130 оценок, среднее: 4,86 из 5)

Загрузка...

Комментариев: 4

Alex:

6 мая 2022 в 21:50

"Если операция создания объекта неуспешна, то деструктор класса не вызывается". А если перед генерацией исключения были созданы динамические объекты, они будут удалены или нет? Если нет — то как их удалять

Ответить
1. Dima:
  
  25 декабря 2022 в 16:00
  
  Вызвать деструктор напрямую в блоке catch
  
  Ответить

kmish:

20 марта 2019 в 13:32

В статье:

"Если операция создания объекта неуспешна, то деструктор класса не вызывается. Следовательно, у вас может возникнуть соблазн использовать функциональный try-блок для очистки частично выделенной памяти классом. Однако обращение к членам объекта, который не создался, считается неопределенным поведением, так как объект уже «мертв» до начала выполнения блока catch. Это означает, что вы не можете использовать функциональный try-блок для выполнения очистки памяти класса."

Еще как работает. Следующий пример демонстрирует это:

#include <iostream>
#include <string>

class ArrayInt
{
private:
	int* m_data;
public:
	ArrayInt() try				//наш функциональный try-блок
		{	
//		throw this;				//где выбрасывать исключение? здесь?
		m_data = new int[4];
		std::cout << "ArrayInt constructor\n";
		throw this;				//или здесь?? зависит от задач
	}
	catch (...)						//ловим указатель
	{
		std::cerr << "Construction of ArrayInt failed\n";
									//ничего не указали, this летит дальше
	}
	~ArrayInt()	
	{
		delete[] m_data;			//чистим память
		std::cout << "Memory returned by ArrayInt destructor\n";
	}

	void returnMemory()
	{
		delete[] m_data;			//чистим память
		std::cout << "returnMemory() executed\n";
	}
};

int main()
{
	try
	{	ArrayInt array;	}

	catch (ArrayInt* array)			//ловим указатель на array *this
	{
		array->returnMemory();		//чистим память
		std::cout << "Catch (...) executed\n";
	}								//здесь вызывается деструктор array

	std::cout << "End of main" << std::endl;

	return 0;
}

#include <string>

class ArrayInt

int* m_data;

ArrayInt() try //наш функциональный try-блок

// throw this; //где выбрасывать исключение? здесь?

m_data = new int[4];

std::cout << "ArrayInt constructor\n";

throw this; //или здесь?? зависит от задач

catch (...) //ловим указатель

std::cerr << "Construction of ArrayInt failed\n";

//ничего не указали, this летит дальше

~ArrayInt()

delete[] m_data; //чистим память

std::cout << "Memory returned by ArrayInt destructor\n";

void returnMemory()

std::cout << "returnMemory() executed\n";

{ ArrayInt array; }

catch (ArrayInt* array) //ловим указатель на array *this

array->returnMemory(); //чистим память

std::cout << "Catch (...) executed\n";

} //здесь вызывается деструктор array

std::cout << "End of main" << std::endl;

return 0;

Результат:

ArrayInt constructor Construction of ArrayInt failed returnMemory() executed Catch (...) executed End of main

Указатель this тащит объект по стеку, значит он не «мертв». Функция returnMemory() возвращает память. Программа работает.

Ответить

Cerberus:

5 апреля 2019 в 11:13

Именно этим и опасно неопределённое поведение: в отличие от явной ошибки, код с UB может работать. А может внезапно перестать работать от любого (подчёркиваю: _любого_, вплоть до флага компиляции) изменения в коде или системе сборки.

Ответить

Урок №187. Функциональный try-блок

Функциональный try-блок

Не используйте функциональный try-блок для очистки памяти

Заключение

Комментариев: 4

Добавить комментарий Отменить ответ