Guida a C++ · 5/6
Per ora questo capitolo è disponibile solo in inglese.
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.
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 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;
};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.#include <map>
#include <optional>
#include <string>
std::optional<int> find_age(const std::map<std::string, int>& people,
const std::string& name) {
if (auto it = people.find(name); it != people.end()) {
return it->second;
}
return std::nullopt;
}
// if (auto age = find_age(people, "Kim")) { use(*age); }
// int a = find_age(people, "Park").value_or(0);#include <expected>
#include <string>
enum class ParseError { Empty, NotNumber };
std::expected<int, ParseError> to_int(const std::string& s) {
if (s.empty()) return std::unexpected(ParseError::Empty);
int value = 0;
for (char c : s) {
if (c < '0' || c > '9') return std::unexpected(ParseError::NotNumber);
value = value * 10 + (c - '0');
}
return value;
}
// auto r = to_int("42");
// if (r) { use(*r); } else if (r.error() == ParseError::Empty) { ... }assert from <cassert> checks conditions that can only fail because of a bug; on failure it prints a diagnostic and aborts. Builds that define NDEBUG (such as CMake's Release configuration) remove the checks, so never use it to validate user input. Compile-time conditions belong in static_assert.
#include <cassert>
#include <cstdint>
#include <vector>
static_assert(sizeof(std::int32_t) == 4, "int32_t must be 4 bytes");
int last(const std::vector<int>& v) {
assert(!v.empty() && "last() called on an empty vector");
return v.back();
}GoogleTest is one of the most popular C++ test frameworks. CMake's FetchContent can build it with your project; set GIT_TAG to a GoogleTest release tag.
include(FetchContent)
FetchContent_Declare(
googletest
GIT_REPOSITORY https://github.com/google/googletest.git
GIT_TAG <release-tag>
)
FetchContent_MakeAvailable(googletest)
enable_testing()
add_executable(math_test tests/math_test.cpp)
target_link_libraries(math_test PRIVATE mathx GTest::gtest_main)
include(GoogleTest)
gtest_discover_tests(math_test)#include <gtest/gtest.h>
#include "math_utils.hpp"
TEST(GcdTest, ReturnsGreatestCommonDivisor) {
EXPECT_EQ(mathx::gcd(12, 18), 6);
EXPECT_EQ(mathx::gcd(7, 5), 1);
}
TEST(GcdTest, ZeroIsHandled) {
ASSERT_EQ(mathx::gcd(9, 0), 9); // stops this test immediately on failure
}A failed EXPECT_* records the failure and continues; a failed ASSERT_* ends the test. After building, ctest --test-dir build runs all tests.
Catch2 favors descriptive test names and a small set of macros such as REQUIRE and CHECK. In Catch2 v3, linking against the Catch2::Catch2WithMain target supplies main for you.
#include <catch2/catch_test_macros.hpp>
#include "math_utils.hpp"
TEST_CASE("gcd returns the greatest common divisor", "[math]") {
REQUIRE(mathx::gcd(12, 18) == 6);
CHECK(mathx::gcd(7, 5) == 1);
}const reference, most specific type first.noexcept.std::optional (C++17) when a value may be absent, and std::expected (C++23) when the caller needs to know why.assert to catch programming errors during development, and static_assert for compile-time checks.
0 commenti
Accedi · Accedi per lasciare un commento.