aggregate-copy-default-direct-value-zero_initialization updated

Author: behnamasadi

README.md

@@ -179,7 +179,7 @@ read more [here](https://ros-developer.com/2017/11/08/docker/)
    * [Cast Base Class to Derived/  Derived to Base](src/class/cast_Base_to_Derived_to_Base.cpp)   
    * [Class Forward Declaration](docs/class_forward_declaration.md)  
    * [Class Constructor Initializationlist](src/class/constructor_initialization_list.cpp)  
-   * [Class Constructor Aggregate/ Copy/ Default/ Direct/ Value/ Uniform/ Zero Initialization, Initializer List](docs/aggregate-copy-default-direct-value-zero.md)  
+   * [Class Constructor Aggregate/ Copy/ Default/ Direct/ Value/ Uniform/ Zero Initialization, Initializer List](docs/aggregate-copy-default-direct-value-zero_initialization.md)  
    * [Copy/ Move Constructor, rvalue, lvalue, move semantic](docs/copy_constructor_move_constructor_rvalue_lvalue_move_semantic.md)  
    * [Cyclic (Circular) Dependency](docs/circular_dependencies.md)  
    * [Default(=default), Deleted (=delete) Constructors](docs/default_constructors_=default_0_delete.md)  

docs/aggregate-copy-default-direct-value-zero.md renamed to docs/aggregate-copy-default-direct-value-zero_initialization.md

@@ -1,3 +1,52 @@
+Certainly! Initialization in C++ is a fundamental concept, involving various methods to assign initial values to variables or objects. Each type of initialization serves different purposes and has distinct syntax and behavior. I'll explain each of the types you mentioned:
+
+1. **Initialization Lists (Constructor Initialization Lists)**: 
+   - Used in the definition of constructors.
+   - Syntax: `ClassName(Type1 arg1, Type2 arg2) : member1(arg1), member2(arg2) { /* constructor body */ }`
+   - Purpose: Directly initializes member variables of a class.
+   - Benefits: More efficient than assignment inside the constructor body, especially for initializing const and reference members.
+
+2. **Aggregate Initialization**:
+   - Applies to aggregates like arrays or classes with no user-declared constructors, private or protected non-static data members, base classes, or virtual functions.
+   - Syntax: `AggregateType var = { val1, val2, ... };`
+   - Allows initialization of each member of an aggregate in the order they are declared.
+
+3. **Copy Initialization**:
+   - Involves using the `=` symbol to initialize a variable with another value.
+   - Syntax: `Type var = otherVar;`
+   - The compiler may call a copy constructor or a conversion constructor, if applicable.
+
+4. **Default Initialization**:
+   - Occurs when a variable is declared without an initializer.
+   - For built-in types (like `int`, `char`), the value is indeterminate if not explicitly initialized.
+   - For classes, the default constructor is called.
+
+5. **Value Initialization**:
+   - Introduced in C++03.
+   - Syntax: `Type var = Type();` or `Type var{};` (since C++11).
+   - Zero-initializes the object if it has a non-trivial default constructor, otherwise calls the default constructor.
+
+6. **Uniform Initialization (List Initialization)**:
+   - Introduced in C++11.
+   - Syntax: `Type var{val1, val2, ...};` or `Type var{};` for default initialization.
+   - Offers a consistent syntax for initializing any object, including automatic type deduction with `auto`, and narrowing conversion checks.
+
+7. **Direct Initialization**:
+   - Involves directly passing the initial values to the constructor of a class.
+   - Syntax: `Type var(arg1, arg2, ...);`
+   - Useful when you need to initialize an object with specific constructor parameters.
+
+8. **Zero Initialization**:
+   - Sets the value of the object to zero or a null pointer for pointers.
+   - Occurs in certain contexts automatically, like for static and thread-local objects.
+
+9. **Brace-Or-Equal Initializers (In-Class Initialization)**:
+   - A C++11 feature allowing class members to be initialized where they are declared.
+   - Syntax: `class ClassName { Type member = initialValue; };` or `class ClassName { Type member{initialValue}; };`
+   - Helps in providing default values for class members.
+
+Each of these initialization types is useful in different scenarios. The choice depends on factors like the type of object being initialized, efficiency considerations, readability of the code, and the version of the C++ standard being used. Uniform Initialization in C++11 and later offers a more consistent and safer approach across different contexts, reducing the complexity of choosing the appropriate initialization form.
+
 # Initialization Lists
 Using Initialization lists to initialize Fields