tones of up

Author: behnamasadi

README.md

@@ -103,7 +103,7 @@ read more [here](https://ros-developer.com/2017/11/08/docker/)
 ## [C++ Tutorials](#)
    * [Align](docs/align.md)  
    * [Allocator](docs/allocator.md)  
-   * [Algorithms library](docs/algorithms.md)  
+   * [Algorithms Library](docs/algorithms.md)  
    * [Assert](docs/assert.md)   
    * [Atomic operations and Atomic Types](docs/atomic.md)    
    * [Asynchronous programming](docs/asynchronous_programming.md)    
@@ -113,23 +113,24 @@ read more [here](https://ros-developer.com/2017/11/08/docker/)
    * [Callbacks](docs/callbacks.md)  
    * [Callable Objects, std::function, std::bind, Lambda](docs/callable_objects_function_bind_lambda.md)  
    * [Clock, Date, Time](docs/date_time.md)   
-   * [Conditional Compilation](src/conditional_compilation.cpp)  
+   * [Conditional Compilation From CMakeLists](src/conditional_compilation.cpp)  
    * [Containers](docs/containers.md)  
       * [vector](docs/vector.md)  
       * [lists](src/lists.cpp)  
       * [C arrays, std::array, span](docs/array_span.md)  
       * [set, map, pair, tuple, tie, unordered_map, multimap, unordered_set, multiset](docs/set_map_pair_tuple.md)  
       * [stack, queue, priority_queue, deque](docs/stack_queue_priority_queue_deque.md) 
    * [Const, Constexpr and Mutable](docs/const_constexpr_mutable.md)    
+   * [Immutable Objects](docs/immutable_objects.md)  
    * [Data Types, Numerical Limits, Machine Epsilon, Precision](docs/primitive_data_types_numerical_limits_machine_epsilon_precision.md)    
    * [Data Types Conversions, Casting](docs/type_conversions_casting.md)  
-   * [Decay](docs/std_decay.md)  
+   * [Decay](docs/decay.md)  
    * [Dynamic Memory Allocation in C](docs/dynamic_memory_allocation.md)  
    * [Enum](docs/enum.md)  
    * [Error Handling](docs/error_handling.md)  
    * [Exception Handling, noexcept](docs/exception_handling.md)  
    * [Extern Variables, Extern Functions](src/extern/variable/main.cpp)  
-   * [File System ](src/filesystem.cpp)  
+   * [File System](docs/filesystem.md)  
    * [Forking](docs/fork.md)  
    * [Forwarding Reference](docs/forward.md)  
    * [Functions, Extern Function, Function Objects, Function Pointer, Inline Functions](docs/functions.md)  
@@ -140,12 +141,12 @@ read more [here](https://ros-developer.com/2017/11/08/docker/)
    * [Lambda](docs/lambda.md)     
    * [Literals](docs/literals.md)  
    * [Loading Classes Dynamically From Plugins](docs/loading_classes_dynamically_from_plugins.md)  
-   * [Macro](src/macro.cpp)  
+   * [Macros](docs/macros.md)  
    * [Memory Error Detection With Memory Address Sanitizer and Valgrind](docs/memory_leaking_valgrind.md)  
    * [Modules](docs/cpp_modules.md)     
    * [Nested Namespaces, Unnamed/Anonymous Namespaces](docs/nested_unnamed_anonymous_namespaces.md)     
    * [Numeral Systems in C++ Decimal, Binary, Octal, Hexadecimal](docs/numeral_system.md)   
-   * [Optional](src/optional.cpp)
+   * [Optional](docs/optional.md)
    * [Parameter Pack Expansion ...](docs/parameter_pack_expansion_(...).md)  
    * [Register Keyword](docs/register.md)  
    * [Regex](docs/regex.md)  
@@ -164,13 +165,13 @@ read more [here](https://ros-developer.com/2017/11/08/docker/)
    * [Structs](src/structs.cpp)  
    * [Structured binding declaration](src/structured_binding_declaration.cpp)       
    * [Switch Case](src/switch_case.cpp)  
-   * [Template, Expression templates](docs/templates.md)  
+   * [Template, Expression Templates](docs/templates.md)  
    * [Ternary (One Line If)](src/ternary.cpp) 
    * [Temporary Objects](docs/temporary_objects.md)    
    * [Track memory allocations(overriding new operator)](docs/track_memory_allocations_overriding_new_operator.md)  
    * [Trivial, standard-layout, Passive/ Plain old data structure (PDS)/ (POD), and literal types](docs/trivial_standard_pds_pod_layout.md)  
    * [Type Traits](docs/type_traits.md)
-   * [Typedef, Type alias (using keyword))](src/typedef.cpp)
+   * [Typedef, Type alias (using keyword))](docs/typedef.md)
    * [type_dispatch, integral_constant, true/false type](src/type_dispatch_integral_constant_true_false_type.cpp)    
    * [Unions](docs/union.md)  
    * [Variadic Templates Function](src/variadic_templates.cpp)     
@@ -241,7 +242,7 @@ read more [here](https://ros-developer.com/2017/11/08/docker/)
    * [Return Type Resolver](docs/return_type_resolver.md)
    * [Resource Acquisition Is Initialization (RAII)](docs/RAII.md)  
    * [Rule of 5](docs/rule_of_5.md)  
-   * [Substitution failure is not an error (SFINAE)](src/SFINAE.cpp)    
+   * [Substitution failure is not an error (SFINAE)](docs/SFINAE.md)    
    * [Stack overflow](docs/stack_overflow.md)    
    * [Stack Unwinding](src/stack_unwinding.cpp)    
    * [Type Erasure](docs/type_erasure.md)  

docs/RAII.md

@@ -74,7 +74,7 @@ In this example, `FileHandler` is a custom class that manages a file resource. T
 
 
 
-Certainly! Let's create some more practical examples of RAII in C++ to illustrate how it can be applied in real-world scenarios.
+Let's create some more practical examples of RAII in C++ to illustrate how it can be applied in real-world scenarios.
 
 ### Example 1: Database Connection Handler
 Imagine you're working on an application that requires database interactions. You can use RAII to manage database connections.

docs/RTTI.md

@@ -13,7 +13,7 @@ Run-Time Type Information (RTTI) is a feature provided by some programming langu
 
 5. **Controversy and Alternatives**: While RTTI provides dynamic type information capabilities, its use is sometimes debated among developers. Some argue that excessive use of RTTI may indicate a design problem in the application. Alternatives like visitor patterns, type tags, and dynamic interfaces are often used in place of RTTI to achieve similar functionality with potentially less overhead or more controlled type-handling mechanisms.
 
-Certainly! A common scenario where RTTI is useful involves polymorphic class hierarchies, where you need to perform specific operations based on the actual type of the object at runtime. Let's consider a classic example in C++ involving a base class and multiple derived classes.
+A common scenario where RTTI is useful involves polymorphic class hierarchies, where you need to perform specific operations based on the actual type of the object at runtime. Let's consider a classic example in C++ involving a base class and multiple derived classes.
 
 ### Scenario:
 Imagine we have a class hierarchy for different types of media content, like `Audio`, `Video`, and `Image`, all derived from a base class `Media`. We have a function that takes a pointer to `Media` and needs to perform certain actions depending on whether the actual object is `Audio`, `Video`, or `Image`.

docs/SFINAE.md

@@ -0,0 +1,47 @@
+# SFINAE
+SFINAE, which stands for "Substitution Failure Is Not An Error," is a concept in C++ template programming. It's a rule that applies during the template instantiation process. The idea is that if a substitution of template parameters into a template results in an invalid code, this is not in itself an error. Instead, the invalid template is simply discarded from the set of potential templates to use.
+
+This concept is particularly useful for creating template specializations that are only valid for certain types or conditions, enabling more flexible and powerful template designs.
+
+### Basic Example of SFINAE
+
+Here's a simple example to illustrate SFINAE:
+
+```cpp
+#include <iostream>
+#include <type_traits>
+
+// Base template
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value, bool>::type isIntegral(T) {
+    return true;
+}
+
+// Template specialization for non-integral types
+template <typename T>
+typename std::enable_if<!std::is_integral<T>::value, bool>::type isIntegral(T) {
+    return false;
+}
+
+int main() {
+    std::cout << std::boolalpha;
+    std::cout << "isIntegral(10): " << isIntegral(10) << std::endl;   // Outputs: true
+    std::cout << "isIntegral(3.14): " << isIntegral(3.14) << std::endl; // Outputs: false
+
+    return 0;
+}
+```
+
+In this example, there are two versions of the `isIntegral` function template. The first version is enabled (via `std::enable_if`) only for integral types, while the second version is enabled for non-integral types. When you call `isIntegral` with an integer, the first version is instantiated. If you call it with a non-integer, the second version is instantiated.
+
+### Explanation
+
+- `std::enable_if`: This is a standard library utility that provides a member typedef `type` if the given boolean constant is true. If the boolean is false, there's no member typedef. This utility is commonly used for controlling template instantiation.
+
+- `std::is_integral`: This is a type trait that checks if a type is an integral type (like int, char, etc.).
+
+### How SFINAE Comes Into Play
+
+In the example, if `T` is an integral type, the `std::enable_if<std::is_integral<T>::value, bool>::type` becomes `bool`, so the first `isIntegral` function template is valid. If `T` is not an integral type, this substitution fails, but due to SFINAE, this failure is not an error; instead, the first `isIntegral` template is simply discarded, and the compiler looks for other templates (in this case, the second `isIntegral`).
+
+SFINAE allows for powerful metaprogramming techniques in C++, enabling the creation of templates that can adapt to different types and conditions at compile time, leading to more efficient and tailored code.