## Challenge Overview: 

You will build a simple `BankAccount` class in C++ that supports withdrawing funds. If a withdrawal request exceeds the available balance, your code must throw a custom exception named `InsufficientFundsException`. This exercise helps you practice creating and using your own exception types to handle error conditions in a realistic scenario.

**Key Requirements:**

- Define a custom exception type, `InsufficientFundsException`, that inherits from `std::exception` and overrides the `what()` method to return the message `"Insufficient funds"`.
- Implement a `BankAccount` class with:
    - A constructor to set the initial balance;
    - A `withdraw(double amount)` method that throws an `InsufficientFundsException` if `amount` is greater than the current balance; otherwise, it subtracts `amount` from the balance.

**Example usage:**

```cpp
BankAccount account(100.0);
account.withdraw(50.0); // OK
account.withdraw(60.0); // Throws InsufficientFundsException
```

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

#include <exception>
#include <string>

class InsufficientFundsException : public std::exception {
public:
    const char* what() const noexcept override {
        return "Insufficient funds";
    }
};

class BankAccount {
private:
    double balance;
public:
    BankAccount(double initialBalance) : balance(initialBalance) {}
    void withdraw(double amount) {
        if (amount > balance) {
            throw InsufficientFundsException();
        }
        balance -= amount;
    }
    double getBalance() const {
        return balance;
    }
};

TEST_CASE("Withdraw within balance succeeds", "[BankAccount][withdraw]") {
    BankAccount account(100.0);
    REQUIRE(account.getBalance() == Approx(100.0));
    account.withdraw(40.0);
    REQUIRE(account.getBalance() == Approx(60.0));
}

TEST_CASE("Withdraw exact balance succeeds and leaves zero", "[BankAccount][withdraw]") {
    BankAccount account(50.0);
    account.withdraw(50.0);
    REQUIRE(account.getBalance() == Approx(0.0));
}

TEST_CASE("Withdraw over balance throws InsufficientFundsException", "[BankAccount][withdraw]") {
    BankAccount account(30.0);
    try {
        account.withdraw(40.0);
        REQUIRE(false); // Should not reach here
    } catch (const InsufficientFundsException& e) {
        REQUIRE(std::string(e.what()) == "Insufficient funds");
    } catch (...) {
        REQUIRE(false); // Wrong exception type
    }
}

TEST_CASE("Multiple withdrawals, exception only when exceeding", "[BankAccount][withdraw]") {
    BankAccount account(100.0);
    account.withdraw(30.0);
    REQUIRE(account.getBalance() == Approx(70.0));
    account.withdraw(70.0);
    REQUIRE(account.getBalance() == Approx(0.0));
    try {
        account.withdraw(1.0);
        REQUIRE(false); // Should throw
    } catch (const InsufficientFundsException& e) {
        REQUIRE(std::string(e.what()) == "Insufficient funds");
    }
}

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: Bank Account Withdrawal

Challenge Overview:

解答