Refactor operator overload examples

Author: XuhuaHuang

OperatorOverload/assignment.cpp

@@ -8,8 +8,6 @@
  *********************************************************************/
 // clang-format on
 
-#include <iostream>
-
 /**
  * @class point
  * @brief A class representing a point in 2D space.
@@ -21,26 +19,26 @@
  */
 class point {
 public:
-    constexpr point()                 = default;
-    constexpr point(const point& rhs) = default;
-    virtual ~point()                  = default;
+  point()                           = default;
+  constexpr point(const point& rhs) = default;
+  virtual ~point()                  = default;
 
-    int _x;
-    int _y;
+  int _x;
+  int _y;
 
-    point& operator=(const point&);
+  point& operator=(const point&);
 };
 
 point& point::operator=(const point& otherPoint) {
-    _x = otherPoint._x;
-    _y = otherPoint._y;
+  _x = otherPoint._x;
+  _y = otherPoint._y;
 
-    return *this;
+  return *this;
 }
 
 int main(void) {
-    point ptr1, ptr2;
-    ptr1 = ptr2;
+  point p1, p2;
+  p1 = p2;
 
-    return 0;
+  return 0;
 }

OperatorOverload/complex.cpp

@@ -0,0 +1,39 @@
+#include <iostream>
+
+class complex_t {
+private:
+  double real{0.0};
+  double imag{0.0};
+
+public:
+  complex_t() = default;
+
+  complex_t(double re, double im) noexcept
+    : real(re)
+    , imag(im) {}
+
+  [[nodiscard]]
+  inline double get_real() const noexcept {
+    return real;
+  }
+  [[nodiscard]]
+  inline double get_imag() const noexcept {
+    return imag;
+  }
+
+  [[nodiscard]]
+  inline complex_t operator+(const complex_t& other) const noexcept {
+    return complex_t(real + other.real, imag + other.imag);
+  }
+};
+
+int main() {
+  complex_t c1(1.0, 1.0);
+  complex_t c2(2.0, 2.0);
+
+  complex_t c3 = c1 + c2;
+
+  std::cout << "Result: (" << c3.get_real() << ", " << c3.get_imag() << ")\n";
+
+  return 0;
+}

OperatorOverload/conversion.cpp

@@ -1,3 +1,4 @@
+// clang-format off
 /*****************************************************************//**
  * \file   conversion.cpp
  * \brief  Overloaded conversion operator float()
@@ -7,36 +8,37 @@
  * \author Xuhua Huang
  * \date   November 2020
  *********************************************************************/
+// clang-format on
 
 #include <iostream>
 
 class Fraction {
 private:
-    int num;
-    int den;
+  int num;
+  int den;
 
 public:
-    constexpr Fraction() = default;
+  inline Fraction() = default;
 
-    constexpr Fraction(int n, int d)
-        : num(n)
-        , den(d) {}
+  constexpr Fraction(int n, int d)
+    : num(n)
+    , den(d) {}
 
-    constexpr Fraction(const Fraction& rhs) = default;
-    virtual ~Fraction()                     = default;
+  constexpr Fraction(const Fraction& rhs) = default;
+  virtual ~Fraction()                     = default;
 
-    constexpr const int getnum() const { return this->num; }
-    constexpr const int getden() const { return this->den; }
+  constexpr int getnum() const { return this->num; }
+  constexpr int getden() const { return this->den; }
 
-    // conversion operator: return float value of fraction
-    constexpr operator float() const { return float(getnum()) / float(getden()); }
+  // conversion operator: return float value of fraction
+  constexpr operator float() const { return float(getnum()) / float(getden()); }
 };
 
 int main(void) {
-    Fraction f(2, 5); // numerator = 2, denominator = 5
+  Fraction f(2, 5); // numerator = 2, denominator = 5
 
-    float val = f; // float(val) is overloaded
-    std::cout << val;
+  float val = f; // float(val) is overloaded
+  std::cout << val;
 
-    return EXIT_SUCCESS;
+  return 0;
 }

OperatorOverload/parenthesis_fn_obj.cpp

@@ -13,38 +13,38 @@
 
 class Compare {
 public:
-    constexpr inline Compare() noexcept                   = default;
-    constexpr inline Compare(const Compare& rhs) noexcept = default;
-    inline virtual constexpr ~Compare() noexcept          = default;
+  constexpr inline Compare() noexcept                   = default;
+  constexpr inline Compare(const Compare& rhs) noexcept = default;
+  inline virtual ~Compare() noexcept                    = default;
 
-    // overloading the "()" operator to compare two int
-    // return either 'true/1' or 'false/0'
-    inline const std::string operator()(int a, int b) const {
-        std::string result = "false";
-        if (a < b) {
-            result = "true";
-        }
-        return result;
+  // overloading the "()" operator to compare two int
+  // return either 'true/1' or 'false/0'
+  inline const std::string operator()(int a, int b) const {
+    std::string result = "false";
+    if (a < b) {
+      result = "true";
     }
+    return result;
+  }
 };
 
 int main(void) {
-    Compare     compare; // create a function object
-    int         a   = 5;
-    int         b   = 7;
-    std::string ans = compare(a, b);
-    // using the overloaded () operator
-    // of the "Compare" class
+  Compare     compare; // create a function object
+  int         a   = 5;
+  int         b   = 7;
+  std::string ans = compare(a, b);
+  // using the overloaded () operator
+  // of the "Compare" class
 
-    std::cout << ans << "\n";
+  std::cout << ans << "\n";
 
-    // fun with nested for loops
-    for (int i = 0; i < 100; i++) {
-        for (int j = 0; j < 100; j++) {
-            std::string ans = compare(i, j);
-            std::cout << "\nFor " << i << " < " << j << " is " << ans << "\n";
-        }
+  // fun with nested for loops
+  for (int i = 0; i < 100; i++) {
+    for (int j = 0; j < 100; j++) {
+      std::string ans = compare(i, j);
+      std::cout << "\nFor " << i << " < " << j << " is " << ans << "\n";
     }
+  }
 
-    return 0;
+  return 0;
 }