C++-Anleitung · 5/6

Errors and Testing

Dieses Kapitel ist vorerst nur auf Englisch verfügbar.

C++ offers several ways to deal with failure: exceptions, return types that carry success or failure (std::optional, std::expected), and assertions for catching bugs. This chapter shows when to use each, then writes unit tests with GoogleTest and Catch2.

Exceptions

You raise an exception with throw and handle it with try/catch. All standard library exceptions derive from std::exception, whose what() member returns a description.

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

int parse_port(const std::string& text) {
    int port = std::stoi(text);   // throws std::invalid_argument if not a number
    if (port < 1 || port > 65535) {
        throw std::out_of_range("port out of range: " + text);
    }
    return port;
}

int main() {
    try {
        std::cout << parse_port("8080") << '\n';
        std::cout << parse_port("70000") << '\n';
    } catch (const std::out_of_range& e) {
        std::cerr << "range error: " << e.what() << '\n';
    } catch (const std::exception& e) {
        std::cerr << "other error: " << e.what() << '\n';
    }
}

Catch by const reference. Catching by value makes a copy and can slice away the derived part of the exception. Handlers are tried top to bottom, so list the most specific types first.

As an exception propagates, destructors of the local objects it passes run in turn (stack unwinding). That is why resources tied to objects (RAII, next chapter) don't leak on errors.

noexcept

noexcept promises that no exception escapes a function; if one does, std::terminate is called. It matters in practice: standard containers move elements during reallocation only when the move constructor is noexcept, and copy otherwise. Mark moves, destructors and swap this way.

#include <cstddef>

class Buffer {
public:
    Buffer(Buffer&& other) noexcept;            // move constructor
    Buffer& operator=(Buffer&& other) noexcept; // move assignment
    ~Buffer();                                  // destructors are noexcept by default
    std::size_t size() const noexcept { return size_; }
private:
    std::size_t size_ = 0;
};

std::optional and std::expected

When "no result" is a normal outcome, encoding it in the return type reads better than throwing.

std::optional<T> (C++17, header <optional>) holds either a value or nothing. It doesn't say why the value is missing.
std::expected<T, E> (C++23, header <expected>) holds either a value of type T or an error of type E. You need a compiler and standard library with C++23 support.

Fragen zu diesem Kapitel?

Errors and Testing

Exceptions

noexcept

std::optional and std::expected

Assertions

Unit tests with GoogleTest

Catch2

Summary

0 Kommentare