error handling

Author: asartori86

c++/06_error_handling/00_errno.cpp

@@ -0,0 +1,16 @@
+#include <cmath>
+#include <iostream>
+
+int main() {
+  double d = std::sqrt(4);
+  std::cout << d << " " << errno << std::endl;
+
+  d = std::sqrt(-4);
+  std::cout << d << " " << errno << std::endl;
+
+  d = 0;
+
+  errno = 0;
+
+  return 0;
+}

c++/06_error_handling/01_exceptions.cpp

@@ -0,0 +1,45 @@
+#include <cmath>
+#include <iostream>
+
+// implment a square root function that "deals with" negative
+// numbers. Moreover according to the logic of the program, d should
+// never be greater than 50
+double square_root(const double d);
+
+struct Negative_number {};
+
+struct Bigger_than_expected {};
+
+int main() {
+  try {
+    std::cout << "please insert a number\n";
+    double number;
+    std::cin >> number;
+    auto d = square_root(number);
+    std::cout << "square root of " << number << " is " << d << '\n';
+    return 0;
+  } catch (const Negative_number) {
+    std::cerr << "The square root of a negative number is a complex number.\n"
+                 "square_root() is "
+              << "limited to handle positive double numbers.\n";
+    return 1;
+  } catch (const Bigger_than_expected) {
+    std::cerr << "The function square_root has been called with a parameter "
+                 "greater than 50.\n"
+              << "This means there is a bug in the algorithm that generated "
+                 "this number.\n";
+    return 2;
+  } catch (...) {
+    std::cerr << "Unknown exception. Aborting.\n";
+    return 3;
+  }
+}
+
+double square_root(const double d) {
+  // test the pre-conditions
+  if (d < 0)
+    throw Negative_number{};
+  if (d > 50)
+    throw Bigger_than_expected{};
+  return std::sqrt(d);
+}

c++/06_error_handling/02_exceptions.cpp

@@ -0,0 +1,43 @@
+#include <cmath>
+#include <iostream>
+#include <string>
+#include <utility>
+
+// implment a square root function that "deals with" negative
+// numbers. Moreover according to the logic of the program, d should
+// never be greater than 50
+double square_root(const double d);
+
+struct Square_root_invalid {
+  std::string message;
+  Square_root_invalid(std::string s) : message{std::move(s)} {}
+};
+
+int main() {
+  try {
+    std::cout << "please insert a number\n";
+    double number;
+    std::cin >> number;
+    auto d = square_root(number);
+    std::cout << "square root of " << number << " is " << d << '\n';
+    return 0;
+  } catch (const Square_root_invalid& s) {
+    std::cerr << s.message << std::endl;
+    return 1;
+  } catch (...) {
+    std::cerr << "Unknown exception. Aborting.\n";
+    return 3;
+  }
+}
+
+double square_root(const double d) {
+  // test the pre-conditions
+  if (d < 0)
+    throw Square_root_invalid{"Cannot handle negative numbers. You gave me " +
+                              std::to_string(d)};
+  if (d > 50)
+    throw Square_root_invalid{
+        "The argument of square_root must be lower than 50. You gave me " +
+        std::to_string(d)};
+  return sqrt(d);
+}

c++/06_error_handling/03_error.cpp

@@ -0,0 +1,58 @@
+#include <cmath>
+#include <iostream>
+
+#include "ap_error.hpp"
+
+// implment a square root function that "deals with" negative
+// numbers. Moreover according to the logic of the program, d should
+// never be greater than 50
+double square_root(const double d);
+
+struct Square_root_invalid {
+  std::string message;
+  Square_root_invalid(std::string s) : message{std::move(s)} {}
+  const char* what() const { return message.c_str(); }
+};
+
+int main() {
+  try {
+    std::cout << "please insert a number\n";
+    double number;
+    std::cin >> number;
+    double d = square_root(number);
+    std::cout << "square root of " << number << " is " << d << '\n';
+    return 0;
+  } catch (const Square_root_invalid& e) {
+    std::cerr << e.what() << std::endl;
+    return 2;
+  } catch (const std::exception& e) {
+    std::cerr << e.what() << std::endl;
+    return 1;
+  } catch (...) {
+    std::cerr << "Unknown exception. Aborting.\n";
+    return 3;
+  }
+}
+
+double square_root(const double d) {
+  // test the pre-conditions
+
+  AP_ERROR(d >= 0 && d <= 50, Square_root_invalid)
+      << "In our library the argument must be positive and less or equal than "
+         "50.\n\nYou passed "
+      << d << ".\n";
+
+  // AP_ERROR(d >= 0 && d <= 50) << "In our library the argument must be
+  // positive "
+  //                                "and less or equal than 50.\n";
+
+  // AP_ERROR_GE(d, 0) << "Cannot handle negative numbers.\n";
+
+  // AP_ERROR_LE(d, 50) << "According to the implemented algorithm, the argument
+  // "
+  //                       "must be less than 50.\n";
+
+  // AP_ERROR_IN_RANGE(d,0,50);
+
+  return sqrt(d);
+}

c++/06_error_handling/04_assert.cpp

@@ -0,0 +1,37 @@
+#include <cassert>
+#include <cmath>
+#include <iostream>
+
+#include "ap_error.hpp"
+
+// implment a square root function that "deals with" negative
+// numbers. Moreover according to the logic of the program, d should
+// never be greater than 50
+double square_root(const double d);
+
+int main() {
+  try {
+    std::cout << "please insert a number\n";
+    double number;
+    std::cin >> number;
+    double d = square_root(number);
+    std::cout << "square root of " << number << " is " << d << '\n';
+    return 0;
+  } catch (const std::exception& e) {
+    std::cerr << e.what() << '\n';
+    return 1;
+  } catch (...) {
+    std::cerr << "Unknown exception. Aborting.\n";
+    return 3;
+  }
+}
+
+double square_root(const double d) {
+  // test the pre-conditions
+  // assert(d >= 0 && d <= 50);  // provided by C, no execeptions
+
+  AP_ASSERT(d >= 0 && d <= 50) << "d should be in the range [0,50]";
+
+  // AP_ASSERT_IN_RANGE(d,0,50);
+  return sqrt(d);
+}

c++/06_error_handling/05_stack_unwinding.cpp

@@ -0,0 +1,78 @@
+#include <iostream>
+#include <vector>
+
+#include "ap_error.hpp"
+
+class Foo {
+ public:
+  Foo() { std::cout << "Foo" << std::endl; }
+  ~Foo() { std::cout << "~Foo" << std::endl; }
+};
+
+class Bar {
+ public:
+  Bar() { std::cout << "Bar" << std::endl; }
+  ~Bar() { std::cout << "~Bar" << std::endl; }
+};
+
+class Vector {
+  double* elem;
+
+ public:
+  Vector(const unsigned int l) : elem{new double[l]} {
+    std::cout << "Vector" << std::endl;
+  }
+  ~Vector() {
+    delete[] elem;
+    std::cout << "~Vector" << std::endl;
+  }
+};
+
+class ManyResources {
+  double* ptr;
+  Vector v;
+
+ public:
+  ManyResources() : ptr{nullptr}, v{3} {
+    std::cout << "Manyresources" << std::endl;
+    try {
+      ptr = new double[5];  // new(std::nothrow) double[5] could be better
+      AP_ERROR(false) << "Error in ManyResources ctor." << std::endl;
+    } catch (...) {
+      delete[] ptr;  // <----
+      throw;         // re-throw
+    }
+  }
+
+  ~ManyResources() {
+    std::cout << "~Manyresources" << std::endl;
+    delete[] ptr;  // <----
+  }
+};
+
+int main() {
+  Foo f;
+  int* raw_ptr = new int[7];  // do not use raw ptr
+  try {
+    // int * raw_ptr=new int[7]; // wrong because raw_ptr would not be visible
+    // inside the catch-clause
+    ManyResources mr;
+    Bar b;
+
+  } catch (const std::exception& e) {
+    std::cerr << e.what() << std::endl;
+
+    delete[] raw_ptr;  // <--- try to comment this and run valgrind or use the
+                       // sanitize library
+    return 1;
+
+  } catch (...) {
+    std::cerr << "Unknown exception. Aborting.\n" << std::endl;
+
+    delete[] raw_ptr;  // <---
+    return 2;
+  }
+
+  delete[] raw_ptr;  // <---
+  return 0;
+}

c++/06_error_handling/06_smart_pointers.cpp

@@ -0,0 +1,51 @@
+#include <iostream>
+#include <memory>
+
+#include "ap_error.hpp"
+
+class Vector {
+  std::unique_ptr<double[]> elem;
+
+ public:
+  Vector(const unsigned int l) : elem{new double[l]} {}
+
+  Vector(Vector&&) noexcept = default;
+  Vector& operator=(Vector&&) noexcept = default;
+
+  double& operator[](const unsigned int i) noexcept { return elem[i]; }
+
+  const double& operator[](const unsigned int i) const noexcept {
+    return elem[i];
+  }
+
+  ~Vector() noexcept { std::cout << "~Vector\n"; }
+};
+
+class ManyResources {
+  std::unique_ptr<double[]> ptr;
+  Vector v;
+
+ public:
+  ManyResources() : ptr{new double[5]}, v{3} {
+    std::cout << "ManyResources ctor\n";
+    AP_ERROR(false) << "I am simulating something wrong.\n";
+  }
+  ~ManyResources() noexcept { std::cout << "~ManyResources\n"; }
+};
+
+int main() {
+  try {
+    std::unique_ptr<int[]> up{new int[7]};  // RAII
+    ManyResources mr;
+
+  } catch (const std::exception& e) {
+    std::cerr << e.what() << std::endl;
+    return 1;
+
+  } catch (...) {
+    std::cerr << "Unknown exception. Aborting.\n" << std::endl;
+    return 2;
+  }
+
+  return 0;
+}

c++/06_error_handling/Makefile

@@ -0,0 +1,43 @@
+SRC = 00_errno.cpp            \
+      01_exceptions.cpp       \
+      02_exceptions.cpp       \
+      03_error.cpp            \
+      04_assert.cpp           \
+      05_stack_unwinding.cpp  \
+      06_smart_pointers.cpp   
+
+CXX = c++
+CXXFLAGS = -Wall -Wextra -g -std=c++11
+
+EXE = $(SRC:.cpp=.x)
+
+# eliminate default suffixes
+.SUFFIXES:
+SUFFIXES =
+
+# just consider our own suffixes
+.SUFFIXES: .cpp .x
+
+all: $(EXE)
+
+.PHONY: all
+
+%.x: %.cpp 
+	$(CXX) $< -o $@ $(CXXFLAGS)
+
+format: $(SRC)
+	@clang-format -i $^ -verbose || echo "Please install clang-format to run this command"
+
+.PHONY: format
+
+clean:
+	rm -f $(EXE) *~
+
+.PHONY: clean
+
+03_error.x: ap_error.hpp
+04_assert.x: ap_error.hpp
+05_stack_unwinding.x: ap_error.hpp
+06_smart_pointers.x: ap_error.hpp
+
+format: ap_error.hpp