C++Guns – RoboBlog

This example throw and catch all standard exceptions just for fun
exception list from https://en.cppreference.com/w/cpp/error/exception
sorted after C++ Standard

searching a stack trace? look at https://en.cppreference.com/w/cpp/utility/basic_stacktrace

/* This example throw and catch all standard exceptions just for fun
 * exception list from https://en.cppreference.com/w/cpp/error/exception
 * sorted after C++ Standard
 *
 * searching a stack trace? look at https://en.cppreference.com/w/cpp/utility/basic_stacktrace
 */

#include <iostream>
#include <exception>
#include <future>
#include <regex>
#include <filesystem>
#include <chrono>
#include <any>
#include <optional>
#include <variant>
//#include <format> // C++20. Not implemented in GCC 12
// #include <expected> // C++23


int nCatched = 0;

template<typename T>
void check(const T& ex, std::string_view exceptionType) {
  nCatched++;
  std::string_view what(ex.what());
  // only compare the first chars from what() message, we are not intereseting in stuff after the exception type
  if(what.substr(0,exceptionType.size()) != exceptionType) {
      std::cerr << exceptionType << " what(): " << ex.what() << "\n";
      std::cerr << "\nERROR: Not all exception derived from " << exceptionType << " catched...\n";
      ::exit(EXIT_FAILURE);
    }
}

int main() {

  bool finish = false;
  int nThrow = 0;
  while(not finish){
    try {
      switch(nThrow) {
        case  1: ++nThrow; throw std::exception();
        case  2: ++nThrow; throw std::logic_error("std::logic_error");
        case  3: ++nThrow; throw std::invalid_argument("std::invalid_argument");
        case  4: ++nThrow; throw std::domain_error("std::domain_error");
        case  5: ++nThrow; throw std::length_error("std::length_error");
        case  6: ++nThrow; throw std::out_of_range("std::out_of_range");
        case  7: ++nThrow; throw std::runtime_error("std::runtime_error");
        case  8: ++nThrow; throw std::range_error("std::range_error");
        case  9: ++nThrow; throw std::overflow_error("std::overflow_error");
        case 10: ++nThrow; throw std::underflow_error("std::underflow_error");
        case 11: ++nThrow; throw std::bad_typeid();
        case 12: ++nThrow; throw std::bad_alloc();
        case 13: ++nThrow; throw std::bad_exception();
        case 14: ++nThrow; throw std::regex_error(std::regex_constants::error_collate); // C++11
        case 15: ++nThrow; throw std::system_error(ENOENT, std::system_category(), "std::system_error"); // C++11
        case 16: ++nThrow; throw std::ios_base::failure("std::ios_base::failure"); // C++11
        case 17: ++nThrow; throw std::future_error(std::future_errc::broken_promise); // C++11
        case 18: ++nThrow; throw std::bad_weak_ptr(); // C++11
        case 19: ++nThrow; throw std::bad_function_call(); // C++11
        case 20: ++nThrow; throw std::bad_array_new_length(); // C++11
        case 21: ++nThrow; throw std::filesystem::filesystem_error("std::filesystem::filesystem_error", std::error_code(ENOENT, std::system_category())); // C++17
        case 22: ++nThrow; throw std::bad_any_cast(); // C++17
        case 23: ++nThrow; throw std::bad_optional_access(); // C++17
        case 24: ++nThrow; throw std::bad_variant_access(); // C++17
        // case 25: throw std::chrono::nonexistent_local_time(); // C++ 20. Not implemented in GCC 12
        // case 26: throw std::chrono::ambiguous_local_time(); // C++20. Not implemented in GCC 12
        // case 27: throw std::format_error(); // C++20. Not implemented in GCC 12
        // case 28: throw std::bad_expected_access(); // C++23
        // case 29: throw std::tx_exception(); TODO
        default: {
          finish = true;
        }
      }
    }
    catch(std::bad_variant_access& ex) {
      check(ex, "bad variant access");
    }
    catch(std::bad_exception& ex) {
      check(ex, "std::bad_exception");
    }
    catch(std::bad_array_new_length& ex) {
      check(ex, "std::bad_array_new_length");
    }
    catch(std::bad_alloc& ex) {
      check(ex, "std::bad_alloc");
    }
    catch(std::bad_function_call& ex) {
      check(ex, "bad_function_call");
    }
    catch(std::bad_weak_ptr& ex) {
      check(ex, "bad_weak_ptr");
    }
    catch(std::bad_optional_access& ex) {
      check(ex, "bad optional access");
    }
    catch(std::bad_any_cast& ex) {
      check(ex, "bad any_cast");
    }
    catch(std::bad_typeid& ex) {
      check(ex, "std::bad_typeid");
    }
    catch(std::filesystem::filesystem_error& ex) {
      check(ex, "filesystem error");
    }
    catch(std::ios_base::failure& ex) {
      check(ex, "std::ios_base::failure");
    }
    catch(std::system_error& ex) {
      check(ex, "std::system_error");
    }
    catch(std::regex_error& ex) {
      check(ex, "Invalid collating element in regular expression"); // regex_error.what does not print the exception type first...
    }
    catch(std::underflow_error& ex) {
      check(ex, "std::underflow_error");
    }
    catch(std::overflow_error& ex) {
      check(ex, "std::overflow_error");
    }
    catch(std::range_error& ex) {
      check(ex, "std::range_error");
    }
    catch(std::runtime_error& ex) {
      check(ex, "std::runtime_error");
    }
    catch(std::future_error& ex) {
      check(ex, "std::future_error");
    }
    catch(std::out_of_range& ex) {
      check(ex, "std::out_of_range");
    }
    catch(std::length_error& ex) {
      check(ex, "std::length_error");
    }
    catch(std::domain_error& ex) {
      check(ex, "std::domain_error");
    }
    catch(std::invalid_argument& ex) {
      check(ex, "std::invalid_argument");
    }
    catch(std::logic_error& ex) {
      check(ex, "std::logic_error");
    }
    catch(std::exception& ex) {
      check(ex, "std::exception");
    }
  } // while


  if(nThrow != nCatched) {
    std::cerr << nThrow << " exception thrown but " << nCatched << " catched\n";
  } else {
    std::cout << "All exceptions which was thrown was catched\n";
  }

  return EXIT_SUCCESS;
}

$ ./a.out
All exceptions which was thrown was catched