In modern C++ programming, one of the key challenges is to manage dynamically allocated memory safely, especially when exceptions can be thrown at any point. If you allocate memory using `new` and an exception is thrown before you manually call `delete`, your program can easily leak memory. To address this, you will create a simple smart pointer class, **`SimpleSmartPointer<T>`**, which ensures that the memory it manages is always deleted when the smart pointer goes out of scope, even if an exception occurs. This resource-guarding pattern is fundamental for writing exception-safe code and is the basis for more advanced smart pointers such as **`std::unique_ptr`**.


#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>


#include <string>

template<typename T>
class SimpleSmartPointer {
private:
    T* ptr;
public:
    explicit SimpleSmartPointer(T* p = nullptr) : ptr(p) {}
    ~SimpleSmartPointer() { delete ptr; }
    SimpleSmartPointer(const SimpleSmartPointer&) = delete;
    SimpleSmartPointer& operator=(const SimpleSmartPointer&) = delete;
    SimpleSmartPointer(SimpleSmartPointer&& other) noexcept : ptr(other.ptr) { other.ptr = nullptr; }
    SimpleSmartPointer& operator=(SimpleSmartPointer&& other) noexcept {
        if (this != &other) {
            delete ptr;
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        return *this;
    }
    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }
    T* get() const { return ptr; }
};

struct TestStruct {
    int x;
    int getX() const { return x; }
};

TEST_CASE("SimpleSmartPointer deletes managed pointer in destructor", "[SimpleSmartPointer]") {
    bool deleted = false;
    struct DeleterChecker {
        bool* flag;
        DeleterChecker(bool* f) : flag(f) {}
        ~DeleterChecker() { *flag = true; }
    };
    {
        SimpleSmartPointer<DeleterChecker> sp(new DeleterChecker(&deleted));
        REQUIRE(!deleted);
    }
    REQUIRE(deleted); // Pointer should be deleted when smart pointer goes out of scope
}

TEST_CASE("SimpleSmartPointer provides dereference and member access", "[SimpleSmartPointer]") {
    SimpleSmartPointer<int> sp(new int(123));
    REQUIRE(*sp == 123);
    *sp = 321;
    REQUIRE(*sp == 321);
    SimpleSmartPointer<TestStruct> sp2(new TestStruct{42});
    REQUIRE(sp2->x == 42);
    REQUIRE(sp2->getX() == 42);
}

TEST_CASE("SimpleSmartPointer disables copy construction and assignment", "[SimpleSmartPointer]") {
    SimpleSmartPointer<int> sp(new int(5));
    // The following lines should not compile if uncommented:
    // SimpleSmartPointer<int> sp2 = sp;
    // SimpleSmartPointer<int> sp3(sp);
    // sp2 = sp;
    SUCCEED();
}

TEST_CASE("SimpleSmartPointer supports move construction and move assignment", "[SimpleSmartPointer]") {
    SimpleSmartPointer<int> sp1(new int(10));
    SimpleSmartPointer<int> sp2(std::move(sp1));
    REQUIRE(sp2.get() != nullptr);
    REQUIRE(sp1.get() == nullptr);
    REQUIRE(*sp2 == 10);

    SimpleSmartPointer<int> sp3(new int(20));
    sp3 = std::move(sp2);
    REQUIRE(sp3.get() != nullptr);
    REQUIRE(sp2.get() == nullptr);
    REQUIRE(*sp3 == 10);
}

TEST_CASE("SimpleSmartPointer handles nullptr and self-move", "[SimpleSmartPointer]") {
    SimpleSmartPointer<int> sp1(nullptr);
    REQUIRE(sp1.get() == nullptr);
    sp1 = std::move(sp1); // Self-move should not crash
    REQUIRE(sp1.get() == nullptr);
}

test.cpp

A practical course on mastering exception handling in modern C++. Learn how to write robust code by detecting, throwing, and managing errors using exceptions. Each section introduces a new aspect of exception handling, followed by hands-on challenges inspired by real-world scenarios.

Understand the basics of exception handling in C++. Learn about try-catch blocks, throw statements, and the standard exception hierarchy.

Learn how to define and use your own exception classes for more descriptive error handling.

Discover how to write exception-safe code and manage resources properly using RAII.

Explore advanced techniques such as exception propagation, rethrowing, and exception specifications.

Challenge: Smart Pointer Resource Guard

解答