27.x — Podsumowanie i quiz rozdziału 27

Przegląd rozdziału

Obsługa wyjątków zapewnia mechanizm oddzielający obsługę błędów lub innych wyjątkowych okoliczności od typowego przepływu kontroli w kodzie. Pozwala to na większą swobodę obsługi błędów wtedy i w sposób najbardziej przydatny w danej sytuacji, łagodząc wiele (jeśli nie wszystkie) bałaganu powodowanego przez kody zwrotne.

Instrukcja throw służy do zgłaszania wyjątku. Bloki try poszukaj wyjątków zgłaszanych przez kod zapisany lub wywołany w nich. Te wyjątki są kierowane do bloków catch, które wychwytują wyjątki określonych typów (jeśli pasują) i obsługują je. Domyślnie przechwycony wyjątek uważany jest za obsłużony.

Wyjątki są obsługiwane natychmiast. Jeśli zostanie zgłoszony wyjątek, sterowanie przeskakuje do najbliższego otaczającego go bloku try, szukając procedur obsługi catch, które mogą obsłużyć wyjątek. Jeśli zostanie znaleziony pasujący try/catch, stos jest rozwijany do punktu catch bloku, a kontrola zostaje wznowiona na górze pasującego catch. Jeśli nie zostanie znaleziony żaden blok try lub żaden blok catch nie pasuje, program wywołuje std::terminate, które zakończy się nieobsługiwanym błędem wyjątku.

Można zgłaszać wyjątki dowolnego typu danych, w tym klas.

Bloki Catch można skonfigurować tak, aby przechwytywały wyjątki określonego typu danych, lub można skonfigurować procedurę obsługi catch-all za pomocą wielokropka (…). Blok catch przechwytujący odwołanie do klasy bazowej przechwytuje także wyjątki klasy pochodnej. Wszystkie wyjątki zgłaszane przez bibliotekę standardową pochodzą z klasy std::exception (która znajduje się w nagłówku wyjątku), więc przechwycenie std::exception przez referencję wychwyci wszystkie wyjątki z biblioteki standardowej. Za pomocą funkcji członkowskiej what() można określić, jakiego rodzaju std::exception został zgłoszony.

W bloku catch może zostać zgłoszony nowy wyjątek. Ponieważ ten nowy wyjątek jest zgłaszany poza blokiem try powiązanym z tym blokiem catch, nie zostanie przechwycony przez blok catch, w którym został rzucony. Wyjątki można ponownie zgłosić z bloku catch, używając samego słowa kluczowego rzut. Nie zgłaszaj ponownie wyjątku, używając przechwyconej zmiennej wyjątku, w przeciwnym razie może dojść do podzielenia obiektu na kawałki.

Bloki try funkcji umożliwiają przechwycenie dowolnego wyjątku występującego w obrębie funkcji lub powiązanej listy inicjalizacyjnej elementu członkowskiego. Są one zwykle używane tylko z konstruktorami klas pochodnych.

Nigdy nie powinieneś zgłaszać wyjątku z destruktora.

Specyfikator wyjątku noexcept może być użyty do oznaczenia, że funkcja nie jest wyrzucana/nie ma błędu.

std::move_if_noexcept zwróci ruchomą wartość r, jeśli obiekt ma ruch noexcept konstruktor, w przeciwnym razie zwróci wartość l, którą można skopiować. Możemy użyć specyfikatora noexcept w połączeniu ze std::move_if_noexcept, aby użyć semantyki przenoszenia tylko wtedy, gdy istnieje silna gwarancja wyjątku (w przeciwnym razie użyć semantyki kopiowania).

W końcu obsługa wyjątków ma swoją cenę. W większości przypadków kod korzystający z wyjątków będzie działał nieco wolniej, a koszt obsługi wyjątku jest bardzo wysoki. Wyjątków powinieneś używać tylko w wyjątkowych sytuacjach, a nie w normalnych przypadkach obsługi błędów (np. nieprawidłowe dane wejściowe).

Quiz rozdziałowy

1. Napisz klasę Fraction zawierającą konstruktor pobierający licznik i mianownik. Jeśli użytkownik przekaże mianownik 0, zgłoś wyjątek typu std::runtime_error (zawarty w nagłówku stdexcept). W programie głównym poproś użytkownika o wprowadzenie dwóch liczb całkowitych. Jeśli ułamek jest prawidłowy, wydrukuj ułamek. Jeśli ułamek jest nieprawidłowy, przechwyć std::exception i poinformuj użytkownika, że ​​wprowadził nieprawidłowy ułamek.

Oto co powinno wyświetlić się po jednym uruchomieniu programu:

Enter the numerator: 5
Enter the denominator: 0
Invalid denominator

Pokaż rozwiązanie

#include <iostream>
#include <stdexcept> // for std::runtime_error
#include <exception> // for std::exception

class Fraction
{
private:
	int m_numerator = 0;
	int m_denominator = 1;

public:
	Fraction(int numerator = 0, int denominator = 1)
		: m_numerator{ numerator }
		, m_denominator{ denominator }
	{
		if (m_denominator == 0)
			throw std::runtime_error("Invalid denominator");
	}

	friend std::ostream& operator<<(std::ostream& out, const Fraction& f1);

};

std::ostream& operator<<(std::ostream& out, const Fraction& f1)
{
	out << f1.m_numerator << '/' << f1.m_denominator;
	return out;
}

int main()
{
	std::cout << "Enter the numerator: ";
	int numerator{};
	std::cin >> numerator;

	std::cout << "Enter the denominator: ";
	int denominator{};
	std::cin >> denominator;

	try
	{
		Fraction f{ numerator, denominator };
		std::cout << "Your fraction is: " << f << '\n';
	}
	catch (const std::exception& e)
	{
		std::cerr << e.what() << '\n';
	}

	return 0;
}