Chapitre 8 : exceptions #

#include <print>
// Error handling using return codes — the traditional approach before exceptions.
// The return value of the function is used both for the result AND for error signaling,
// which makes the code harder to read and maintain.

#define ERROR_CODE -1

static int oneOverN(int n, double &result)
{
  if (n == 0)
  {
    return ERROR_CODE;
  }
  else
  {
    result = 1.0 / n;
    return 0;
  }
}

static double compute(int k)
{
  double result;
  if (oneOverN(k, result) == ERROR_CODE)
  {
    // Ambiguous error signaling: ERROR_CODE could be a valid result
    return ERROR_CODE;
  }
  else
  {
    return result * result;
  }
}

int main()
{
  // Problem: ERROR_CODE could be a valid result — ambiguous error signaling
  auto result = compute(0);
  if (result == ERROR_CODE)
  {
    std::println("ERROR");
  }
  else
  {
    std::println("{}", result);
  }

  return 0;
}

#include <print>
// Same logic as 08.01 but using exceptions instead of return codes.
// The exception propagates automatically through the call stack — no need
// for each intermediate function to check and forward error codes.

static double oneOverN(int n)
{
    if (n == 0)
    {
        throw n;
    }
    return 1.0 / n;
}

static double compute(int k)
{
    auto result = oneOverN(k);
    return result * result;
}

int main()
{
    try
    {
        auto result = compute(2);
        std::println("{}", result);
    }
    catch (...)
    {
        std::println("ERROR");
    }

    return 0;
}

#include <print>
// Catch handlers with value parameters do NOT perform implicit type conversions.
// A thrown double will NOT be caught by a catch(float) handler.

int main()
{
    int dividend = 10;
    int divisor = 0;

    try
    {
        if (divisor == 0)
        {
            throw 0.0; // throws a double
            // try also: throw "division by zero!";  // const char*
            // try also: throw 0.0f;                 // float
        }
        std::println("Quotient: {}", dividend / divisor);
    }
    catch (float f)
    {
        // Will NOT catch the double — no implicit conversion in catch handlers
        std::println("Caught float: {}", f);
    }
    catch (const char* msg)
    {
        std::println("Caught message: {}", msg);
    }
    catch (...)
    {
        // The double ends up here because no exact-type handler matched
        std::println("Caught unknown exception (catch-all)");
    }

    std::println("Done");

    return 0;
}

#include <print>
// An exception can be caught, partially handled, and re-thrown with a bare `throw`.
// This allows multiple levels of the call stack to react to the same exception.

void f()
{
    try
    {
        int n = 2;
        throw n;
    }
    catch (int x)
    {
        std::println("Exception caught in f(): {}", x);
        throw; // re-throw the same exception to the caller
    }
}

int main()
{
    try
    {
        f();
    }
    catch (int i)
    {
        std::println("Exception caught in main() (int): {}", i);
    }
    catch (double d)
    {
        std::println("Exception caught in main() (double): {}", d);
    }

    return 0;
}

#include <type_traits>
#include <print>
#include <stdexcept>
// In C++17, dynamic exception specifications (throw(int, float, ...)) were removed.
// The only remaining specification is `noexcept`, which guarantees that a function
// will not throw. If a noexcept function does throw, std::terminate is called.

// Most standard library containers rely heavily on noexcept for performance optimizations.
// If a move constructor is noexcept, std::vector will use it instead of the copy constructor during resizing

// This function promises not to throw
void safeFunction() noexcept
{
  std::println("safeFunction: I promise not to throw");
}

// This function may throw (default behavior, same as noexcept(false))
void riskyFunction()
{
  throw std::runtime_error("something went wrong");
}

// noexcept can also be conditional
template <typename T>
void process(T value) noexcept(std::is_integral_v<T>)
{
  if constexpr (std::is_integral_v<T>)
  {
    std::println("Processing integral value: {} (noexcept)", value);
  }
  else
  {
    std::println("Processing non-integral value: {} (may throw)", value);
    throw std::runtime_error("non-integral error");
  }
}

int main()
{
  // noexcept can be queried at compile time
  std::println("safeFunction is noexcept: {}", noexcept(safeFunction()));
  std::println("riskyFunction is noexcept: {}", noexcept(riskyFunction()));
  std::println("process<int> is noexcept: {}", noexcept(process(42)));
  std::println("process<double> is noexcept: {}", noexcept(process(3.14)));

  safeFunction();

  try
  {
    riskyFunction();
  }
  catch (const std::exception &e)
  {
    std::println("Caught: {}", e.what());
  }

  // Safe: int is integral → noexcept(true)
  process(42);

  // This would throw → catch it
  try
  {
    process(3.14);
  }
  catch (const std::exception &e)
  {
    std::println("Caught from process<double>: {}", e.what());
  }

  // WARNING: calling safeFunction with a throw inside would call std::terminate!
  // Uncomment to test (program will abort):
  // auto dangerous = []() noexcept { throw std::runtime_error("oops"); };
  // dangerous(); // → std::terminate()

  return 0;
}

#include <iostream>
#include <print>
#include <new>
// A simple Vector class that demonstrates both implicit exceptions (bad_alloc
// from new[]) and explicit exceptions (bounds checking with const char*).

class Vector
{
public:
  explicit Vector(int size) : m_size(size)
  {
    m_data = new double[m_size]; // may throw std::bad_alloc
  }

  ~Vector()
  {
    delete[] m_data;
    m_data = nullptr;
  }

  Vector(const Vector&) = delete;
  Vector& operator=(const Vector&) = delete;

  double &operator[](int i)
  {
    validateIndex(i);
    return m_data[i];
  }

private:
  void validateIndex(int i) const
  {
    if (i < 0 || i >= m_size)
    {
      // In real code, prefer throwing std::out_of_range
      throw "Index out of bounds!";
    }
  }

  double *m_data{nullptr};
  int m_size{0};
};

int main()
{
  int n = 0;
  int i = 0;
  double x = 0.0;

  std::print("Number of vector components: n = ");
  std::cin >> n;

  try
  {
    Vector v(n); // if n is too large → bad_alloc
    std::print("Index and value of a component: i, v[i] ? ");
    std::cin >> i >> x;
    v[i] = x; // if i is out of [0..n-1] → throws const char*
    std::println("v[{}] = {}", i, x);
  }
  catch (const char *message)
  {
    std::println("{}", message);
  }
  catch (const std::bad_alloc &)
  {
    std::println("Memory allocation failed");
  }
  catch (...)
  {
    std::println("Unknown error");
  }

  std::println("Done");

  return 0;
}

#include <print>
#include <exception>
// Catching exceptions by reference preserves polymorphism.
// Catching by value causes slicing — the derived part is lost.

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

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

int main()
{
    // Catch by REFERENCE: polymorphism works — calls Exception1::what()
    try
    {
        std::println("--- Catch by reference ---");
        throw Exception1();
    }
    catch (const std::exception& e)
    {
        std::println("Caught: {}", e.what()); // prints "Exception1"
    }

    // Catch by VALUE: slicing occurs — calls std::exception::what()
    try
    {
        std::println("--- Catch by value ---");
        throw Exception2();
    }
    catch (const std::exception e) // NOLINT: intentional catch by value
    {
        std::println("Caught: {}", e.what()); // prints "std::exception" (sliced!)
    }

    return 0;
}

#include <print>
#include <format>
#include <exception>
#include <string>
// A custom exception class that inherits from std::exception.
// Uses __LINE__ to include the source line number in the error message.

class MyException : public std::exception
{
public:
    MyException(const char* message, int line)
        : m_msg(std::format("Error at line {}: {}", line, message))
    {
    }

    const char* what() const noexcept override
    {
        return m_msg.c_str();
    }

private:
    std::string m_msg;
};

int main()
{
    try
    {
        throw MyException("something went wrong", __LINE__);
    }
    catch (const std::exception& e)
    {
        std::println("{}", e.what());
    }

    return 0;
}

#include <print>

// WARNING: this is for pedagogical purposes only!
//  --> Throwing integral types is a bad practice.
//  --> Throw exceptions inheriting from std::exception
int main(int argc, char *argv[])
{
  if (argc < 2)
  {
    std::println("Usage: 1242.2_08.09_IntegralExceptionsVsClassesExceptions.exe <exception_type>");
    std::println("Exception types: char, short, int, long");

    return 1;
  }

  try
  {
    auto exceptionTypeStr = std::string_view(argv[1]);
    if (exceptionTypeStr == "char")
    {
      throw '0';
    }
    else if (exceptionTypeStr == "short")
    {
      throw static_cast<short>(1);
    }
    else if (exceptionTypeStr == "int")
    {
      throw 2;
    }
    else if (exceptionTypeStr == "long")
    {
      throw 3L;
    }
  }
  catch (char c)
  {
    std::println("Caught char exception: '{}'", c);
  }
  catch (short s)
  {
    std::println("Caught short exception: {}", s);
  }
  catch (int i)
  {
    std::println("Caught int exception: {}", i);
  }
  catch (long l)
  {
    std::println("Caught long exception: {}", l);
  }

  return 0;
}