clang-fromat applid

Author: behnamasadi

src/algorithms_library.cpp

@@ -532,7 +532,7 @@ void sort() {
   std::shuffle(vec1.begin(), vec1.end(), g);
 
   ///////////////////partial_sort, finding top 3 students,
-  ///sorted///////////////////
+  /// sorted///////////////////
   std::partial_sort(number_set1.begin(), number_set1.begin() + 3,
                     number_set1.end());
 
@@ -541,7 +541,7 @@ void sort() {
   std::cout << "\n";
 
   /////////////////////nth_element, finding top 3 students, not necessarily
-  ///sorted/////////////////////
+  /// sorted/////////////////////
   std::shuffle(vec1.begin(), vec1.end(), g);
   std::nth_element(number_set1.begin(), number_set1.begin() + 3,
                    number_set1.end());
@@ -550,7 +550,7 @@ void sort() {
   std::cout << "\n";
 
   ///////////////////////partion data into two groups, neither of the groups are
-  ///sorted/////////////////////
+  /// sorted/////////////////////
   std::shuffle(number_set1.begin(), number_set1.end(), g);
   std::vector<int>::iterator iterator_to_the_first_element_of_the_second_group =
       std::partition(number_set1.begin(), number_set1.end(),
@@ -574,7 +574,7 @@ void sort() {
   std::cout << "\n";
 
   /////////////////////////stable_partition,partion data into two groups, but it
-  ///preserve the original order///////////////////////
+  /// preserve the original order///////////////////////
   std::shuffle(number_set1.begin(), number_set1.end(), g);
   std::stable_partition(number_set1.begin(), number_set1.end(),
                         [](int x) { return x < 30; });

src/cast.cpp

@@ -31,7 +31,7 @@ pointer type and data pointed by the pointer is same or not.
 */
 
 /////////////////////////////////Static
-///Cast/////////////////////////////////////
+/// Cast/////////////////////////////////////
 class Int {
   int x;
 

src/class/header_guard/add.h

@@ -6,6 +6,3 @@
 // your declarations here
 int add(int x, int y);
 #endif
-
-
-

src/class/header_guard/mymath.h

@@ -2,6 +2,6 @@
 #define MATH_H
 
 // your declarations here
-int somemathfunction(){return 0;}
+int somemathfunction() { return 0; }
 
 #endif

src/class/header_guard/subtract.h

@@ -6,4 +6,3 @@
 // your declarations here
 int subtract(int x, int y);
 #endif
-

src/class/virtual_function_abstract_class.cpp

@@ -65,7 +65,7 @@ class Derived : public Base {
 } // namespace VirtualFunction
 int main() {
   ///////////////////////////////////////Virtual
-  ///Function///////////////////////////////////
+  /// Function///////////////////////////////////
 
   {
     std::cout << "Order of function calls:" << std::endl;
@@ -78,7 +78,7 @@ int main() {
   }
 
   ///////////////////////////////////////Pure Virtual and Abstract
-  ///Classes///////////////////////////////////
+  /// Classes///////////////////////////////////
 
   {}
 

src/function_pointer.cpp

@@ -8,15 +8,15 @@ later be called through that function pointer.
 */
 
 ///////////////////////////////////Adder
-///Example////////////////////////////////////
+/// Example////////////////////////////////////
 
 int adder(int a, int b) { return a + b; }
 
 // defining
 int (*adder_fn_ptr)(int, int);
 
 /////////////////////////////////Foreach
-///Example////////////////////////////////////
+/// Example////////////////////////////////////
 
 void foreach (std::vector<int> values, void(funcPrint)(int)) {
   for (auto value : values)

src/lists.cpp

@@ -22,7 +22,7 @@ void print(std::list<int> &list) {
 int main() {
 
   ////////////////////////////////push_back,
-  ///push_front///////////////////////////////
+  /// push_front///////////////////////////////
   std::list<int> list_of_numbers;
   list_of_numbers.push_back(1);
   list_of_numbers.push_back(2);
@@ -33,7 +33,7 @@ int main() {
   print(list_of_numbers);
 
   ////////////////////////////////remove,
-  ///remove_if///////////////////////////////
+  /// remove_if///////////////////////////////
 
   std::cout << "removing second element:" << std::endl;
   std::list<int>::iterator itr = list_of_numbers.begin();
@@ -48,14 +48,14 @@ int main() {
   print(list_of_numbers);
 
   ////////////////////////////////remove,
-  ///remove_if///////////////////////////////
+  /// remove_if///////////////////////////////
   std::cout << "delete all even numbers:" << std::endl;
   auto even = [](int x) { return (x % 2 == 0); };
   list_of_numbers.remove_if(even);
   print(list_of_numbers);
 
   ////////////////////////////////front, back
-  ///element///////////////////////////////
+  /// element///////////////////////////////
 
   std::cout << "front element:" << std::endl;
   std::cout << list_of_numbers.front() << std::endl;

src/multithreading/join_detach_threads.cpp

@@ -13,7 +13,7 @@
 #include <queue>
 
 ////////////////////////////////////Join, Detach
-///Threads//////////////////////////////
+/// Threads//////////////////////////////
 
 void print(int a, int &b) { std::cout << a << " " << b << std::endl; }
 

src/printing_with_format.cpp

@@ -2,20 +2,20 @@
 #include <iostream>
 #include <string>
 #include <string_view>
- 
+
 template <typename... Args>
-std::string dyna_print(std::string_view rt_fmt_str, Args&&... args) {
-    return std::vformat(rt_fmt_str, std::make_format_args(args...));
+std::string dyna_print(std::string_view rt_fmt_str, Args &&... args) {
+  return std::vformat(rt_fmt_str, std::make_format_args(args...));
 }
- 
+
 int main() {
-    std::cout << std::format("Hello {}!\n", "world");
- 
-    std::string fmt;
-    for (int i{}; i != 3; ++i) {
-        fmt += "{} "; // constructs the formatting string
-        std::cout << fmt << " : ";
-        std::cout << dyna_print(fmt, "alpha", 'Z', 3.14, "unused");
-        std::cout << '\n';
-    }
+  std::cout << std::format("Hello {}!\n", "world");
+
+  std::string fmt;
+  for (int i{}; i != 3; ++i) {
+    fmt += "{} "; // constructs the formatting string
+    std::cout << fmt << " : ";
+    std::cout << dyna_print(fmt, "alpha", 'Z', 3.14, "unused");
+    std::cout << '\n';
+  }
 }

src/streams_IO_operation_format_output.cpp

@@ -258,7 +258,7 @@ void stringstreamExample() {
   }
 
   /////////////////////////////count words
-  ///frquency/////////////////////////////////
+  /// frquency/////////////////////////////////
   std::stringstream wordsFrquencyStream("a b bb c a dd d");
   wordsFrquencyStream.str("a b bb c a dd d");
 

src/string.cpp

@@ -118,7 +118,8 @@ void cStyleString() {
   char name0[10] = {
       'b', 'e', 'h', 'n',
       'a', 'm', '\0'}; // stack variable, compiler output: char name0[10] =
-                       // {'b', 'e', 'h', 'n', 'a', 'm', '\0', '\0', '\0', '\0'};
+                       // {'b', 'e', 'h', 'n', 'a', 'm', '\0', '\0', '\0',
+                       // '\0'};
   char name1[] = {
       'b', 'e', 'h', 'n',
       'a', 'm', '\0'}; // stack variable, compiler output: char name1[7] = {'b',

src/structs.cpp

@@ -38,7 +38,7 @@ int Structsmain()
 // int main()
 {
   //	initializer list. This allows you to initialize some or all the members
-  //of a struct at declaration time.
+  // of a struct at declaration time.
   Employee Joe = {1, 42, 60000.0f};
   Employee sJoe;
   sJoe.nID = 14;
@@ -55,7 +55,7 @@ int Structsmain()
   cout << myDataElement.hasData << endl;
 
   //	example of  "->" operator, when we have pointer to struct or class, for
-  //accessing member we have to use -> operator
+  // accessing member we have to use -> operator
   DataElement RealData;
   DataElement *PointerToRealData = &RealData;
   PointerToRealData->iVal = 1234;

src/template.cpp

@@ -159,7 +159,7 @@ template <class TYPE> void PrintTwice(TYPE data) {
 template <class T> T Add(T n1, T n2) { return n1 + n2; }
 
 ////////////////////////////////Template
-///Specialization////////////////////////////////
+/// Specialization////////////////////////////////
 
 // An Example Program for function template specialization
 
@@ -302,16 +302,16 @@ struct Vector<3> {
 
 int main() {
   //	For the first call of GetAverage, where IntArray is passed, compiler
-  //would instantiate this function as: 	double GetAverage(int tArray[], int
-  //nElements);
+  // would instantiate this function as: 	double GetAverage(int tArray[],
+  // int nElements);
 
   int IntArray[5] = {100, 200, 400, 500, 1000};
   float FloatArray[3] = {1.55f, 5.44f, 12.36f};
   cout << GetAverage(IntArray, 5);
   cout << GetAverage(FloatArray, 3);
 
   ////////////////////////////////Template
-  ///Specialization////////////////////////////////
+  /// Specialization////////////////////////////////
   // function template specialization
   add(10, 3);
   add(std::string("a"), std::string("b"));