Add content to C++ roadmap

src/data/roadmaps/cpp/content/106-structuring-codebase/100-scope/100-namespaces.md

@@ -1 +1,103 @@
-# Namespaces
+# Namespaces in C++
+
+In C++, a namespace is a named scope or container that is used to organize and enclose a collection of code elements, such as variables, functions, classes, and other namespaces. They are mainly used to divide and manage the code base, giving developers control over name collisions and the specialization of code.
+
+### Syntax
+
+Here's the syntax for declaring a namespace:
+
+```cpp
+namespace identifier {
+    // code elements
+}
+```
+
+### Using Namespaces
+
+To access elements within a namespace, you can use the scope resolution operator `::`. Here are some examples:
+
+#### Declaring and accessing a namespace
+
+```cpp
+#include <iostream>
+
+namespace animals {
+    std::string dog = "Bobby";
+    std::string cat = "Lilly";
+}
+
+int main() {
+    std::cout << "Dog's name: " << animals::dog << std::endl;
+    std::cout << "Cat's name: " << animals::cat << std::endl;
+
+    return 0;
+}
+```
+
+#### Nesting namespaces
+
+Namespaces can be nested within other namespaces:
+
+```cpp
+#include <iostream>
+
+namespace outer {
+    int x = 10;
+
+    namespace inner {
+        int y = 20;
+    }
+}
+
+int main() {
+    std::cout << "Outer x: " << outer::x << std::endl;
+    std::cout << "Inner y: " << outer::inner::y << std::endl;
+
+    return 0;
+}
+```
+
+### `using` Keyword
+
+You can use the `using` keyword to import namespaced elements into the current scope. However, this might lead to name conflicts if multiple namespaces have elements with the same name.
+
+#### Using a single element from a namespace
+
+```cpp
+#include <iostream>
+
+namespace animals {
+    std::string dog = "Bobby";
+    std::string cat = "Lilly";
+}
+
+int main() {
+    using animals::dog;
+    
+    std::cout << "Dog's name: " << dog << std::endl;
+
+    return 0;
+}
+```
+
+#### Using the entire namespace
+
+```cpp
+#include <iostream>
+
+namespace animals {
+    std::string dog = "Bobby";
+    std::string cat = "Lilly";
+}
+
+int main() {
+    using namespace animals;
+    
+    std::cout << "Dog's name: " << dog << std::endl;
+    std::cout << "Cat's name: " << cat << std::endl;
+
+    return 0;
+}
+```
+
+In conclusion, namespaces are a useful mechanism in C++ to organize code, avoid naming conflicts, and manage the visibility of code elements.

src/data/roadmaps/cpp/content/106-structuring-codebase/101-code-splitting/index.md

@@ -1 +1,55 @@
-# Code splitting
+# Code Splitting
+
+Code splitting refers to the process of breaking down a large code base into smaller, more manageable files or modules. This helps improve the organization, maintainability, and readability of the code. In C++, code splitting is generally achieved through the use of separate compilation, header files, and source files.
+
+#### Header Files (.h or .hpp)
+
+Header files, usually with the `.h` or `.hpp` extension, are responsible for declaring classes, functions, and variables that are needed by multiple source files. They act as an interface between different parts of the code, making it easier to manage dependencies and reduce the chances of duplicated code.
+
+Example of a header file:
+
+```cpp
+// example.h
+#ifndef EXAMPLE_H
+#define EXAMPLE_H
+
+class Example {
+public:
+    void printMessage();
+};
+
+#endif
+```
+
+#### Source Files (.cpp)
+
+Source files, with the `.cpp` extension, are responsible for implementing the actual functionality defined in the corresponding header files. They include the header files as needed and provide the function and class method definitions.
+
+Example of a source file:
+
+```cpp
+// example.cpp
+#include "example.h"
+#include <iostream>
+
+void Example::printMessage() {
+    std::cout << "Hello, code splitting!" << std::endl;
+}
+```
+
+#### Separate Compilation
+
+C++ allows for separate compilation, which means that each source file can be compiled independently into an object file. These object files can then be linked together to form the final executable. This provides faster build times when making changes to a single source file since only that file needs to be recompiled, and the other object files can be reused.
+
+Example of separate compilation and linking:
+
+```sh
+# Compile each source file into an object file
+g++ -c main.cpp -o main.o
+g++ -c example.cpp -o example.o
+
+# Link object files together to create the executable
+g++ main.o example.o -o my_program
+```
+
+By following the code splitting technique, you can better organize your C++ codebase, making it more manageable and maintainable.

src/data/roadmaps/cpp/content/106-structuring-codebase/index.md

@@ -1 +1,66 @@
-# Structuring codebase
+# Structuring Codebase
+
+Structuring codebase is an essential part of software development that deals with organizing and modularizing your code to make it more maintainable, efficient, and easier to understand. A well-structured codebase enhances collaboration, simplifies adding new features, and makes debugging faster. In C++, there are various techniques to help you structure your codebase effectively.
+
+## Namespaces
+
+Namespaces are one of the tools in C++ to organize your code by providing a named scope for different identifiers you create, like functions, classes, and variables. They help avoid name clashes and make your code more modular.
+
+```cpp
+namespace MyNamespace {
+    int aFunction() {
+        // function implementation
+    }
+}
+// to use the function
+MyNamespace::aFunction();
+```
+
+## Include Guards
+
+Include guards are a tool for preventing multiple inclusions of a header file in your project. They consist of preprocessor directives that conditionally include the header file only once, even if it's included in multiple places.
+
+```cpp
+#ifndef MY_HEADER_FILE_H
+#define MY_HEADER_FILE_H
+
+// Your code here
+
+#endif // MY_HEADER_FILE_H
+```
+
+## Header and Source Files
+
+Separating your implementation and declarations into header (*.h) and source (*.cpp) files is a key aspect of structuring your codebase in C++. Header files usually contain class and function declarations, while source files contain their definitions.
+
+// MyClass.h
+```cpp
+#ifndef MY_CLASS_H
+#define MY_CLASS_H
+
+class MyClass
+{
+public:
+    MyClass();
+    int myMethod();
+};
+ 
+#endif // MY_CLASS_H
+```
+
+// MyClass.cpp
+```cpp
+#include "MyClass.h"
+
+MyClass::MyClass() {
+    // constructor implementation
+}
+
+int MyClass::myMethod() {
+    // method implementation
+}
+```
+
+## Code Formatting
+
+Consistent code formatting and indentation play a crucial role in structuring your codebase, making it easier to read and understand for both you and other developers. A style guide such as the [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html) can help you maintain consistent formatting throughout your project.