clang applied

Author: behnamasadi

src/CRTP.cpp

@@ -1,2 +1,2 @@
-//http://www.vishalchovatiya.com/7-advance-cpp-concepts-idiom-examples-you-should-know/
-int main(){}
+// http://www.vishalchovatiya.com/7-advance-cpp-concepts-idiom-examples-you-should-know/
+int main() {}

src/RAII.cpp

@@ -1,13 +1,11 @@
 #include <iostream>
-#include <thread>
 #include <mutex>
+#include <thread>
 
 /*
-RAII (Resource Acquisition is Initialization) tries to solve the problems like these:
-Problems:
-1)Problem #1
-    int array=new int[size];
-array goes out of scope without being deleted, memory leak
+RAII (Resource Acquisition is Initialization) tries to solve the problems like
+these: Problems: 1)Problem #1 int array=new int[size]; array goes out of scope
+without being deleted, memory leak
 
 2)Problem #2
 std::mutex global_mu;
@@ -23,24 +21,24 @@ std::thread t1(func1);
 t1 goes out of scope and it is joinable but std::terminte is called;
 
 
-RAII is when you acquire "resources" in constructor and release them in destructor;
+RAII is when you acquire "resources" in constructor and release them in
+destructor;
 
 Whats is a resource?
 1) must be acquired before use
 2) in limited supply
 example:
 heap: you should use malloc befprehand, heap is also limited
-files: you should open files before use, the number of files on your mahine is limited
-socket:
-mutex:
+files: you should open files before use, the number of files on your mahine is
+limited socket: mutex:
 
 Example of RAII from standard c++:
 std::vector, std::string, std::unique_ptr, std::lock_gaurd
 
 Refs: https://medium.com/swlh/what-is-raii-e016d00269f9
 */
 
-std::mutex  globalMutex;
+std::mutex globalMutex;
 void lockMutexBad(bool shouldThrow) {
   std::cout << "Locking mutex manually..." << std::endl;
   globalMutex.lock();
@@ -59,16 +57,14 @@ void lockMutexBad(bool shouldThrow) {
 }
 
 void lockMutexBadExample() {
-    try
-    {
-        //tis call will llock the mutex without unlocking that
-        lockMutexBad(true);
-    } catch (...)
-    {
-        std::cout << "Caught exception" << std::endl;
-    }
-    //this call will stuck in the deadlcok
-    lockMutexBad(false);
+  try {
+    // tis call will llock the mutex without unlocking that
+    lockMutexBad(true);
+  } catch (...) {
+    std::cout << "Caught exception" << std::endl;
+  }
+  // this call will stuck in the deadlcok
+  lockMutexBad(false);
 }
 
 void lockMutexGood(bool shouldThrow) {
@@ -83,21 +79,17 @@ void lockMutexGood(bool shouldThrow) {
 }
 
 void lockMutexGoodExample() {
-    try
-    {
-        lockMutexGood(true);
-    } catch (...)
-    {
-        std::cout << "Caught exception" << std::endl;
-    }
-    lockMutexGood(false);
+  try {
+    lockMutexGood(true);
+  } catch (...) {
+    std::cout << "Caught exception" << std::endl;
+  }
+  lockMutexGood(false);
 }
 
+int main() {
+  std::thread t1(lockMutexBadExample);
 
-int main()
-{
-    std::thread t1(lockMutexBadExample);
-
-    t1.join();
-    return 0;
+  t1.join();
+  return 0;
 }

src/RTTI.cpp

@@ -1 +1 @@
-int main(){}
+int main() {}

src/RVO_NRVO_copy_elision.cpp

@@ -16,7 +16,8 @@ Then you will get
 "copy constructor"
 
 =================Copy elision (Copy omission) ====================
-it is a compiler optimization technique that avoids unnecessary copying of objects.
+it is a compiler optimization technique that avoids unnecessary copying of
+objects.
 
 This line:
     string s="hello";
@@ -28,35 +29,29 @@ should be broken down by the compiler as
 However, most of the C++ compilers avoid such overheads of creating a temporary
 object and then copying it.
 */
-struct S
-{
-    S() {std::cout<<"constructor" <<std::endl;}
+struct S {
+  S() { std::cout << "constructor" << std::endl; }
 
-    S(S const &rhs) {std::cout<<"copy constructor" <<std::endl;}
+  S(S const &rhs) { std::cout << "copy constructor" << std::endl; }
 };
 
-//Return Value Optimization
-S RVO()
-{
-    return S();
-}
+// Return Value Optimization
+S RVO() { return S(); }
 
-//Named Return Value Optimization
-S NRVO()
-{   S s;
-    return s;
+// Named Return Value Optimization
+S NRVO() {
+  S s;
+  return s;
 }
 
-struct string
-{
-    string(const char* str="\0") {std::cout<<"constructor" <<std::endl;}
-    string (const string &rhs ){std::cout<<"copy constructor" <<std::endl;}
+struct string {
+  string(const char *str = "\0") { std::cout << "constructor" << std::endl; }
+  string(const string &rhs) { std::cout << "copy constructor" << std::endl; }
 };
 
-int main()
-{
-    S s1=RVO();
-    S s2=NRVO();
+int main() {
+  S s1 = RVO();
+  S s2 = NRVO();
 
-    string s="hello";
+  string s = "hello";
 }

src/SFINAE.cpp

@@ -1 +1 @@
-int main(){}
+int main() {}

src/VTABLE_and_VPTR.cpp

@@ -1,56 +1,31 @@
 #include <iostream>
 
-
-class base
-{
+class base {
 public:
+  void virtual foo() { std::cout << "foo from base" << std::endl; }
 
-    void virtual foo()
-    {
-        std::cout<<"foo from base" <<std::endl;
-    }
-
-    void virtual bar()
-    {
-        std::cout<<"bar from base" <<std::endl;
-    }
-
-    void print()
-    {
-        std::cout<<"print from base" <<std::endl;
-    }
+  void virtual bar() { std::cout << "bar from base" << std::endl; }
 
+  void print() { std::cout << "print from base" << std::endl; }
 };
 
-
-class derived : public base
-{
+class derived : public base {
 public:
-
-    void foo() override
-    {
-        std::cout<<"foo from derived" <<std::endl;
-    }
-    void print()
-    {
-        std::cout<<"print from derived" <<std::endl;
-    }
+  void foo() override { std::cout << "foo from derived" << std::endl; }
+  void print() { std::cout << "print from derived" << std::endl; }
 };
 
+int main() {
+  base *bptr;
+  derived derived_object;
+  bptr = &derived_object;
 
-int main()
-{
-    base *bptr;
-    derived derived_object;
-    bptr = &derived_object;
-
-    //virtual function, binded at runtime, we got the foo() from derived
-    bptr->foo();
-
-    // Non-virtual function, binded at compile time, we get print() from base
-    bptr->print();
+  // virtual function, binded at runtime, we got the foo() from derived
+  bptr->foo();
 
-    // shadow method, 
-    derived_object.print();
+  // Non-virtual function, binded at compile time, we get print() from base
+  bptr->print();
 
+  // shadow method,
+  derived_object.print();
 }

src/add.cpp

@@ -1,8 +1,4 @@
-extern "C" 
-{
+extern "C" {
 
-  int add(int a,int b)
-  {
-	return a+b;
-  }
+int add(int a, int b) { return a + b; }
 }

src/aggregate_initialization.cpp

@@ -2,69 +2,58 @@
 
 class entity {
 public:
-    int x;
-    std::string y;
+  int x;
+  std::string y;
 };
 
-class intArray
-{
+class intArray {
 public:
-    int size;
-    int * data;
+  int size;
+  int *data;
 
-    intArray(int size)
-    {
-        size = size;
-        data = new int[size];
-    }
-
-    ~intArray()
-    {
-        delete[] data;
-    }
+  intArray(int size) {
+    size = size;
+    data = new int[size];
+  }
 
-    intArray(std::initializer_list<int> list)
-    {
-        size = list.size();
-        data = new int[list.size()];
+  ~intArray() { delete[] data; }
 
-        //std::initializer_list doesn't provide a subscript operator
+  intArray(std::initializer_list<int> list) {
+    size = list.size();
+    data = new int[list.size()];
 
-        int count{ 0 };
-        for (auto element : list)
-        {
-            data[count] = element;
-            ++count;
-        }
+    // std::initializer_list doesn't provide a subscript operator
 
+    int count{0};
+    for (auto element : list) {
+      data[count] = element;
+      ++count;
     }
+  }
 };
 
-int main()
-{
-    // Aggregate initialization (Initializations using public attributes)
-    entity entity1{ 2011,"name" };
-    entity entity2 = { 2011,"name"};
-
-
-    /*
-    initializer_list
-    so far the only way to use our array is like this:
-    */
-
-    intArray array1(4);
-    array1.data[0] =7 ;
-    array1.data[1] = 3;
-    array1.data[2] = 5;
-    array1.data[3] = 6;
-
-    /*
-    with initializer_list, we can send an array directly:
-    */
-
-
-    intArray array2({ 1,2,3,4,5,6,7,8 });
-    std::cout << array2.data[0] << std::endl;
-    std::cout << array2.data[1] << std::endl;
-    std::cout << array2.data[2] << std::endl;
+int main() {
+  // Aggregate initialization (Initializations using public attributes)
+  entity entity1{2011, "name"};
+  entity entity2 = {2011, "name"};
+
+  /*
+  initializer_list
+  so far the only way to use our array is like this:
+  */
+
+  intArray array1(4);
+  array1.data[0] = 7;
+  array1.data[1] = 3;
+  array1.data[2] = 5;
+  array1.data[3] = 6;
+
+  /*
+  with initializer_list, we can send an array directly:
+  */
+
+  intArray array2({1, 2, 3, 4, 5, 6, 7, 8});
+  std::cout << array2.data[0] << std::endl;
+  std::cout << array2.data[1] << std::endl;
+  std::cout << array2.data[2] << std::endl;
 }