Add .clang-format and format the code

Author: banach-space

.clang-format

@@ -0,0 +1,2 @@
+Language:        Cpp
+BasedOnStyle:  Google

src/auto_vs_decltype_main.cpp

@@ -29,11 +29,11 @@
 // Helper objects/functions
 //========================================================================
 template <typename T, typename S>
-auto multiply(T lhs, S rhs)->decltype(lhs * rhs) {
+auto multiply(T lhs, S rhs) -> decltype(lhs * rhs) {
   return lhs * rhs;
 }
 
-template<typename T, typename S>
+template <typename T, typename S>
 auto fpmin(T x, S y) -> decltype(x < y ? x : y) {
   return x < y ? x : y;
 }
@@ -58,10 +58,10 @@ int main() {
   }
 
   // 2. auto INSTEAD OF TYPE SPECIFIER FOR SCALAR VARS
-  int x = int();        // x is an int, initialized to 0
+  int x = int();  // x is an int, initialized to 0
   assert(x == 0);
 
-  const int &crx = x;   // crx is a const int& that refers to x
+  const int &crx = x;  // crx is a const int& that refers to x
   x = 42;
   assert(crx == 42 && x == 42);
 
@@ -84,7 +84,7 @@ int main() {
 #ifdef COMPILATION_ERROR
   const int c = 0;
   auto &rc = c;
-  rc = 44;                // error: const qualifier was not removed
+  rc = 44;  // error: const qualifier was not removed
 #endif
 
   // 3. decltype (multiply uses decltype)

src/const_vs_constexpr_main.cpp

@@ -30,7 +30,7 @@ constexpr int gcd_cpp11(int a, int b) {
 
 // C++14 implementation - many restrictions are relaxed, e.g. loops and auto
 // are now allowed
-#if __cplusplus >=  201403L
+#if __cplusplus >= 201403L
 constexpr auto gcd_cpp14(int a, int b) {
   while (b != 0) {
     auto t = b;
@@ -45,14 +45,21 @@ constexpr auto gcd_cpp14(int a, int b) {
 // The following functions implement the Fibonacci sequence calculation. The
 // 1st implementation uses templates, and the 2nd constexpr.
 //------------------------------------------------------------------------
-template <unsigned n> struct fibonacci_tmp {
+template <unsigned n>
+struct fibonacci_tmp {
   static const unsigned value =
       fibonacci_tmp<n - 1>::value + fibonacci_tmp<n - 2>::value;
 };
 
-template <> struct fibonacci_tmp<0> { static const unsigned value = 0; };
+template <>
+struct fibonacci_tmp<0> {
+  static const unsigned value = 0;
+};
 
-template <> struct fibonacci_tmp<1> { static const unsigned value = 1; };
+template <>
+struct fibonacci_tmp<1> {
+  static const unsigned value = 1;
+};
 
 constexpr unsigned fibonacci_cxp(const unsigned x) {
   return x <= 1 ? x : fibonacci_cxp(x - 1) + fibonacci_cxp(x - 2);
@@ -65,19 +72,23 @@ int main() {
   // 1. CONST VS COMPILE-TIME-CONST
   // Integers with const qualifiers are compile time constants. Doubles aren't
   // and require constexpr to become compile time consts.
-  const int var_a = 10;                   // can be evaluated at compile time (i.e. compile time constant)
+  const int var_a =
+      10;  // can be evaluated at compile time (i.e. compile time constant)
 #ifdef COMPILATION_ERROR
-  const double var_b = 3.8;               // cannot be evaluated at compile time (i.e. run-time constant)
+  const double var_b =
+      3.8;  // cannot be evaluated at compile time (i.e. run-time constant)
 #else
-  constexpr double var_b = 3.8;           // can be evaluated at compile time (i.e. compile time constant)
+  constexpr double var_b =
+      3.8;  // can be evaluated at compile time (i.e. compile time constant)
 #endif
 
-  const int var_c = var_a + 5;            // compile time constant
-  constexpr double var_d = var_b - 2.7;   // compile time constant
+  const int var_c = var_a + 5;           // compile time constant
+  constexpr double var_d = var_b - 2.7;  // compile time constant
 
   // 2. CONST vs CONSTEXPR for pointers
   const int *ptr_e;
-  constexpr int *ptr_f = nullptr;         // equivalent to int *const ptr_f (as opposed to const int *ptr_f)
+  constexpr int *ptr_f = nullptr;  // equivalent to int *const ptr_f (as opposed
+                                   // to const int *ptr_f)
 
   // 3. GCD
   // Compile time calculations

src/deep_vs_shallow.cpp

@@ -10,14 +10,12 @@
 //
 // License: MIT
 //========================================================================
-#include <iostream>
 #include <deep_vs_shallow.hpp>
+#include <iostream>
 
 Shallow::Shallow() { m_data = new int[m_capacity]; }
 
-Shallow::Shallow(const Shallow &rhs) {
-  m_data = rhs.m_data;
-}
+Shallow::Shallow(const Shallow& rhs) { m_data = rhs.m_data; }
 
 Shallow::~Shallow() {
   if (m_data != nullptr) {
@@ -26,8 +24,7 @@ Shallow::~Shallow() {
   }
 }
 
-void
-Shallow::add(int elem) {
+void Shallow::add(int elem) {
   if (m_num_elements >= m_capacity) {
     std::cout << "Full buffer, exiting." << std::endl;
     return;
@@ -37,14 +34,11 @@ Shallow::add(int elem) {
   m_num_elements++;
 }
 
-int&
-Shallow::getElemAt(unsigned idx) { return m_data[idx]; }
+int& Shallow::getElemAt(unsigned idx) { return m_data[idx]; }
 
-Deep::Deep() {
-  m_data = new int[m_capacity]();
-}
+Deep::Deep() { m_data = new int[m_capacity](); }
 
-Deep::Deep(const Deep &rhs) {
+Deep::Deep(const Deep& rhs) {
   m_data = new int[m_capacity];
   for (size_t ii = 0; ii < m_capacity; ii++) {
     m_data[ii] = rhs.m_data[ii];
@@ -53,8 +47,7 @@ Deep::Deep(const Deep &rhs) {
 
 Deep::~Deep() { delete[] m_data; }
 
-void
-Deep::add(int elem) {
+void Deep::add(int elem) {
   if (m_num_elements >= m_capacity) {
     std::cout << "Full buffer, exiting." << std::endl;
     return;
@@ -64,5 +57,4 @@ Deep::add(int elem) {
   m_num_elements++;
 }
 
-int&
-Deep::getElemAt(unsigned idx) { return m_data[idx]; }
+int& Deep::getElemAt(unsigned idx) { return m_data[idx]; }

src/deep_vs_shallow_main.cpp

@@ -17,7 +17,6 @@
 #include <deep_vs_shallow.hpp>
 #include "cpp_tutor.h"
 
-
 int main() {
   // 1. SHALLOW COPY
   Shallow obj_a;

src/memory_block.cpp

@@ -38,8 +38,7 @@ MemoryBlock::MemoryBlock(const MemoryBlock &other)
   std::copy(other.m_data, other.m_data + m_length, m_data);
 }
 
-MemoryBlock&
-MemoryBlock::operator=(const MemoryBlock &other) {
+MemoryBlock &MemoryBlock::operator=(const MemoryBlock &other) {
   std::cout << "In operator=(const MemoryBlock&). length = " << other.m_length
             << ". Copying resource." << std::endl;
 
@@ -54,10 +53,7 @@ MemoryBlock::operator=(const MemoryBlock &other) {
   return *this;
 }
 
-size_t
-MemoryBlock::length() const {
-  return m_length;
-}
+size_t MemoryBlock::length() const { return m_length; }
 
 MemoryBlock::MemoryBlock(MemoryBlock &&other) noexcept
     : m_length(0), m_data(nullptr) {
@@ -75,8 +71,7 @@ MemoryBlock::MemoryBlock(MemoryBlock &&other) noexcept
   other.m_length = 0;
 }
 
-MemoryBlock&
-MemoryBlock::operator=(MemoryBlock &&other) noexcept {
+MemoryBlock &MemoryBlock::operator=(MemoryBlock &&other) noexcept {
   std::cout << "In operator=(MemoryBlock&&). length = " << other.m_length << "."
             << std::endl;
 

src/noexcept_main.cpp

@@ -9,25 +9,22 @@
 //  Illustrates the noexcept keyword and demonstrates that std::vector has
 //  different behavior if the type's move constructor is marked noexcept. This
 //  reason behind this is very well explained here:
-//   * https://www.reddit.com/r/cpp_questions/comments/51btqw/why_does_stdvector_have_different_behavior_if_the/
+//   *
+//   https://www.reddit.com/r/cpp_questions/comments/51btqw/why_does_stdvector_have_different_behavior_if_the/
 //
 // License: MIT
 //========================================================================
-#include <vector>
 #include <iostream>
+#include <vector>
 
 //========================================================================
 // Helper functions and data structures
 //========================================================================
 // Throwing in foo triggers a call to std::terminate
-void foo() noexcept(true) {
-  throw 13;
-}
+void foo() noexcept(true) { throw 13; }
 
 // Throwing in bar is fine
-void bar() noexcept(false) {
-  throw 13;
-}
+void bar() noexcept(false) { throw 13; }
 
 // A is a trivial class with it's move constructor marked as noexcept. Note
 // that move-constructing means that the id of the object moved-from is
@@ -54,7 +51,7 @@ struct A {
   }
 
   // Move assignment operator.
-  A &operator=(A &&other)  = delete;
+  A &operator=(A &&other) = delete;
 
   // Destructor.
   ~A() { std::cout << "  A: destructing object: " << id << std::endl; }
@@ -139,7 +136,7 @@ int main() {
   // 3. THROW AN EXCEPTION INSIDE A FUNCTION DECORATED WITH noexcept(false)
   try {
     bar();
-  } catch(...) {
+  } catch (...) {
     std::cout << "Exception in bar caught" << std::endl;
   }
 
@@ -152,7 +149,7 @@ int main() {
 
   try {
     foo();
-  } catch(...) {
+  } catch (...) {
     std::cout << "Exception in foo caught" << std::endl;
   }
 }

src/null_vs_nullptr_main.cpp

@@ -15,9 +15,9 @@
 //
 // License: MIT
 //========================================================================
-#include "cpp_tutor.h"
 #include <cassert>
 #include <iostream>
+#include "cpp_tutor.h"
 
 //========================================================================
 // Helper functions

src/override_final_main.cpp

@@ -36,9 +36,9 @@ struct B final : A
 };
 
 struct C : B {
-  void foo(){}
+  void foo() {}
 #ifdef COMPILATION_ERROR
-  void fez(){}
+  void fez() {}
 #endif
 };