chore: backup

Author: nooneknowspeter

exercises/00_intro/01_intro.cpp

@@ -1,31 +1,31 @@
+// TODO: We sometimes encourage you to keep trying things on a given exercise
+// even after you already figured it out. If you got everything working and feel
+// ready for the next exercise, enter `n` in the terminal.
+
+#include <gtest/gtest.h>
 #include <iostream>
+#include <string>
 
-void splashScreen()
+void intro01()
 {
+    // TODO: Enter the correct passphrase.
+    // NOTE: Use the testcase as reference.
+    std::cout << "Welcome to " << "cpplings" << "!" << std::endl;
+}
 
-    // // user input
-    // char userInput{};
+int main(int argc, char *argv[])
+{
+    intro01();
 
-    // splash screen
-    // std::cout << "          Welcome to cpplings!        \n";
-    std::cout << "                  _ _                 \n";
-    std::cout << "                 | (_)                \n";
-    std::cout << "  ___ _ __  _ __ | |_ _ __   __ _ ___ \n";
-    std::cout << " / __| '_ \\| '_ \\| | | '_ \\ / _` / __|\n";
-    std::cout << "| (__| |_) | |_) | | | | | | (_| \\__ \\\n";
-    std::cout << " \\___| .__/| .__/|_|_|_| |_|\\__, |___/\n";
-    std::cout << "     | |   | |               __/ |    \n";
-    std::cout << "     |_|   |_|              |___/     \n";
-    std::cout << "                                      \n";
-    // std::cout << "          Enter Y/y to continue       \n";
+    std::cout << "\n\n" << "Testing output begins here\n--------------------------" << "\n";
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
 
-    // while (true)
-    // {
-    //     std::cin >> userInput;
-    //
-    //     if (userInput == 'y' || userInput == 'Y')
-    //     {
-    //         break;
-    //     }
-    // }
+TEST(Intro, Intro01)
+{
+    testing::internal::CaptureStdout();
+    intro01();
+    std::string stdout{testing::internal::GetCapturedStdout()};
+    ASSERT_EQ(stdout, "Welcome to cpplings!\n");
 }

exercises/00_intro/02_intro.cpp

@@ -2,23 +2,30 @@
 // even after you already figured it out.
 //
 // Printing in C++ involves "cout", a function from the "std" namespace,
-// that displays an stream buffer in the console.
+// that displays a stream buffer in the console.
 //
 // Referencing a function from a namespace, or in this a case a namespace
-// from a module (imported using "#include <iostream>"),
+// from a module/header (imported using "#include <iostream>"),
 // involves using the scope resolution operator (::),
-// we will get deeper into modules later.
+// we will get deeper into modules and headers later.
 //
 // The value to be printed must "shift to the stream" using the
 // left-shift operator (<<).
 //
 // https://cppbyexample.com/what_is_iostream.html
 // http://www.en.cppreference.com/w/cpp/io/cout.html
+// https://www.learncpp.com/cpp-tutorial/statements-and-the-structure-of-a-program/
 
+#include <gtest/gtest.h>
 #include <iostream>
 
-void message()
+void intro02()
 {
-    // TODO: Fix the line of code to print "Hello World!" to the console
-    std::cout << "Hello World!";
+    // TODO: Fix the line of code to print "Hello World!" to the console.
+    std::cout << "Hello ";
+}
+
+int main()
+{
+    intro02();
 }

exercises/01_variables/01_variables.cpp

@@ -6,21 +6,36 @@
 // datatype variableName = value;
 //
 // Using the first example is called Direct List Initialization.
-// It is a modern way of intializing variables in C++
+// It is a modern way of intializing variables in C++.
 //
 // The second method is a classic way of initializing and assigning
 // values to variables.
 //
+// In C++, variables can be named whatever using different conventions unlike
+// certain languages like Rust or Python where they must be named in snake_case.
+// In C/C++, variables are often named using the camelCase or snake_case convention.
+//
 // https://www.learncpp.com/cpp-tutorial/introduction-to-objects-and-variables/
 // https://www.learncpp.com/cpp-tutorial/variable-assignment-and-initialization/
 
+#include <gtest/gtest.h>
+
 // TODO: Add the missing module for printing
 #include <iostream>
 
 void variables01()
 {
-    // TODO: Add the missing keyword
+    // TODO: Assign an integer to a variable named "x" using direct list initialization.
     int x{5};
 
-    std::cout << x;
+    // TODO: Assign an integer to a variable named "y" using the classic way.
+    int y = 10;
+
+    std::cout << "direct list initialization -> " << "x{" << x << "}" << "\n";
+    std::cout << "classic way -> " << "y" << "=" << y;
+}
+
+int main()
+{
+    variables01();
 }

exercises/01_variables/02_variables.cpp

@@ -1,9 +1,21 @@
+// A variable's type must be declared before
+// the variable's name.
+//
+// int foo{5};
+// float bar{10.5f}; / float bar{10.5};
+// double baz{20.56};
+
 #include <iostream>
 
 void variables02()
 {
-    // TODO: Add the missing keyword
+    // TODO: Add a missing type and value.
     int x{5};
 
-    std::cout << x;
+    std::cout << "x=" << x;
+}
+
+int main()
+{
+    variables02();
 }

exercises/01_variables/03_variables.cpp

@@ -0,0 +1,28 @@
+// Besides the variable data types, C++ has a few more
+// keywords for declaring the type of variable before
+// decalaring the variable's data type.
+//
+// const FOO{5};
+//
+// Constant names are normally written in UPPER_CASE or CONSTANT_CASE.
+//
+// https://www.learncpp.com/cpp-tutorial/keywords-and-naming-identifiers/
+
+#include <iostream>
+#include <type_traits>
+
+void variables03()
+{
+    // TODO: Declare a constant variable with a value and then print it out to stdout.
+    const int FOO{5};
+
+    std::cout << FOO;
+
+    static_assert(std::is_const_v<decltype(FOO)>,
+                  "The variable must be a constant."); // NOTE: Ignore this line of code.
+}
+
+int main()
+{
+    variables03();
+}

exercises/01_variables/04_variables.cpp

@@ -1,5 +1,29 @@
-int x;
+#include <gtest/gtest.h>
+#include <string>
 
 void variables04()
 {
+    // TODO: Change the line below to fix the compiler error.
+    // NOTE: Use the test case as reference.
+    int baz{5};
+
+    // TODO: Also print out the value of baz to stdout in a sentence "baz=5".
+    std::cout << "baz=" << baz;
+}
+
+int main(int argc, char **argv)
+{
+    variables04();
+
+    std::cout << "\n\n" << "Testing output begins here\n--------------------------" << "\n";
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+
+TEST(Variables, Variables04)
+{
+    testing::internal::CaptureStdout();
+    variables04();
+    std::string stdout{testing::internal::GetCapturedStdout()};
+    ASSERT_EQ(stdout, "baz=5");
 }

exercises/01_variables/05_variables.cpp

@@ -0,0 +1,21 @@
+// TODO: We sometimes encourage you to keep trying things on a given exercise
+// even after you already figured it out.
+//
+// C++ is a statically typed language.
+// Datatypes need to be explicitly decalred.
+// Datatypes can be "inferred" by using the "auto" keyword.
+
+#include <iostream>
+int main()
+{
+    // TODO: Infer the datatype using the "auto" keyword.
+    // Assign a "truthy" value to compile.
+    auto doesAutoWork{true};
+
+    std::cout << "doesAutoWork? -> " << doesAutoWork;
+
+    if (!doesAutoWork)
+    {
+        return 1;
+    }
+}

exercises/02_functions/01_functions.cpp

@@ -1,22 +1,58 @@
+// TODO: We sometimes encourage you to keep trying things on a given exercise
+// even after you already figured it out.
 //
+// Evey programmer knows that functions are resuable pieces of code.
 //
+// Each function is called and assigned/"pushed" on to the stack (fragment of memory).
+// Read more about the stack here: https://en.wikipedia.org/wiki/Stack-based_memory_allocation/
+//
+// A C++ function includes:
+//  - The function signature: int f(int x)
+//                              |  | |
+//                              |  | parameter list (parameter datatype parameter name, ...)
+//                              |  |
+//                              |  function name
+//                              |
+//                              function return type
+//
+//  - Function clause/body:
+//			{ -> function scope beginning
+//					return x; -> return (depends on function return type; will be explained in an upcoming exercise)
+//  		} -> function scope ending
+//
+// Functions are normally named using the camelCase convention.
 //
 // https://www.learncpp.com/cpp-tutorial/introduction-to-functions/
 // https://www.learncpp.com/cpp-tutorial/function-return-values-value-returning-functions/
+// https://www.learncpp.com/cpp-tutorial/why-functions-are-useful-and-how-to-use-them-effectively/
 
 #include <gtest/gtest.h>
 #include <iostream>
 
-int function01(int x)
+// TODO: Create the function signature.
+// Add the function return type, name "f" and a parameter "x" with an int datatype.
+int f(int x)
 {
     int y{x + 1};
 
+    std::cout << "x: " << x << " " << "y: " << y << std::endl;
+
     return y;
 }
 
+int main(int argc, char **argv)
+{
+    // TODO: Call the function and pass in an appropriate parameter.
+    f(10);
+
+    std::cout << "\n\n" << "Testing output begins here\n--------------------------" << "\n";
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+
 TEST(Functions, Function01)
 {
-    ASSERT_EQ(function01(0), 1);
-    ASSERT_EQ(function01(1), 2);
-    ASSERT_EQ(function01(2), 3);
+    ASSERT_EQ(f(0), 1);
+    ASSERT_EQ(f(1), 2);
+    ASSERT_EQ(f(2), 3);
 };

exercises/02_functions/02_functions.cpp

@@ -1,6 +1,41 @@
-// https://www.learncpp.com/cpp-tutorial/void-functions-non-value-returning-functions/
+// The function return a value and the value's datatype must be the same
+// as the function's return type.
 //
+// https://www.learncpp.com/cpp-tutorial/function-return-values-value-returning-functions/
+// https://www.learncpp.com/cpp-tutorial/introduction-to-function-parameters-and-arguments/
 
-void function02()
+#include <gtest/gtest.h>
+#include <string>
+
+// TODO: Add the missing keyword.
+// NOTE: Use the rest of the code as reference to determine which datatype needs to be returned.
+int bar()
+{
+    // TODO: Change the line below to fix the compiler error.
+    // NOTE: Use the test case as reference.
+    int baz{5};
+
+    // TODO: Also print out the value of baz to stdout in a sentence "baz=5".
+    std::cout << "baz=" << baz;
+
+    return baz;
+}
+
+int main(int argc, char **argv)
+{
+    // TODO: call the bar function
+    bar();
+
+    std::cout << "\n\n" << "Testing output begins here\n--------------------------" << "\n";
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+
+TEST(Variables, Variables04)
 {
+    testing::internal::CaptureStdout();
+    bar();
+    std::string stdout{testing::internal::GetCapturedStdout()};
+    ASSERT_EQ(bar(), 5);
+    ASSERT_EQ(stdout, "baz=5");
 }