Added more concepts

Author: Lavin-tom

Argument_passing/Readme.md

@@ -22,4 +22,4 @@
 
 
 ---
-[Next](https://github.com/Lavin-tom/cpp_programming/tree/master/)
+[Next](https://github.com/Lavin-tom/cpp_programming/tree/master/Namespace)

Datatypes/Readme.md

@@ -0,0 +1,93 @@
+## Datatypes
+
+
+### Bool
+`bool` data type is used to represent Boolean values, which can be either `true` or `false`. It is typically used in conditional statements, logical operations, and boolean expressions.
+
+In memory, a bool value is usually stored as 1 byte, where a value of 1 represents true and a value of 0 represents false.
+
+example:
+```c++
+bool isTrue = true;  // declaring and initializing a bool variable
+
+if (isTrue) {
+    // code to be executed if isTrue is true
+    cout << "The value is true." << endl;
+} else {
+    // code to be executed if isTrue is false
+    cout << "The value is false." << endl;
+}
+
+```
+To print true or false we can use  `boolalpha`
+
+example:
+```c++
+#include<iostream>
+using namespace std;
+int main()
+{
+    bool a = 1;
+    cout << boolalpha << a << endl;
+}
+
+output:
+true
+```
+#### Why size of `bool` is one byte?
+The size of a bool is typically one byte, which is equivalent to 8 bits. This size is chosen to ensure that a bool variable can hold either true or false values.
+
+Although a bool logically represents a single bit of information (1 or 0), using a whole byte provides several advantages:
+
+- Memory Alignment: Memory is usually organized in byte-sized chunks, and accessing single bytes is generally more efficient than accessing individual bits.
+
+- Compatibility: Many computer architectures and programming languages are designed to work with bytes as the smallest addressable unit of memory. Using a single byte for a bool allows for easier interoperability and compatibility between different systems and programming languages.
+
+- Simplicity: Using a byte for a bool simplifies memory management and makes it consistent with other data types. It avoids complexities that could arise from manipulating individual bits directly.
+
+---
+
+### wchar_t
+- `wchar_t` is a built-in data type that represents a wide character. It is used to store Unicode characters that may require more than a single byte to represent.
+
+- The wchar_t type is typically used when working with wide strings or characters that are outside the ASCII range. It ensures that characters from various character sets, including non-Latin scripts, can be represented accurately.
+
+- The size of wchar_t is implementation-defined and can vary depending on the platform and compiler. It is guaranteed to be large enough to hold the largest supported wide character set for the target environment.CopyCopy
+
+- In most modern systems, wchar_t is 2 or 4 bytes in size, allowing it to accommodate a wide range of Unicode characters. The exact size can be determined using the `sizeof` operator.
+
+
+
+### string
+`string` data type is used to represent and manipulate text or character sequences. It is part of the C++ Standard Library and provides a more convenient and flexible way to work with strings compared to C-style character arrays.
+
+
+- Header File Inclusion:
+To use string, you need to include the `<string>` header file in your C++ program.
+
+- Dynamic Size:
+Unlike fixed-size character arrays, string can dynamically grow or shrink to accommodate the length of the string. You don't need to specify the size beforehand.
+
+- Easy Initialization:
+You can initialize an string using various methods:
+
+  - Direct initialization: string str = "Hello";
+  - Copy initialization: string str("Hello");
+  - Assignment: string str; str = "Hello";
+
+- String Operations: 
+string provides a wide range of member functions for common string operations, including:
+
+    - Accessing individual characters: str[i], str.at(i)
+    - Concatenation: str1 + str2, str1.append(str2)
+    - Length: str.length(), str.size()
+    - Substring extraction: str.substr(startIndex, length)
+    - Searching for substrings: str.find(substring), str.rfind(substring)
+    - Modifying strings: str.replace(), str.erase(), str.insert()
+    - Comparison: str1 == str2, str1 < str2, etc.
+- String Input and Output:
+string can be easily read from and written to the standard input/output streams using the familiar `>>` and `<<` operators.
+
+
+---
+[Next](https://github.com/Lavin-tom/cpp_programming/tree/master/Function_Overloading)

Datatypes/bool.cpp

@@ -0,0 +1,17 @@
+#include <iostream>
+using namespace std;
+int main()
+{
+
+    bool isTrue = true; // declaring and initializing a bool variable
+    if (isTrue)
+    {
+        // code to be executed if isTrue is true
+        cout << "The value is true." << endl;
+    }
+    else
+    {
+        // code to be executed if isTrue is false
+        cout << "The value is false." << endl;
+    }
+}

Datatypes/string.cpp

@@ -0,0 +1,58 @@
+#include<iostream>
+#include<string>
+using namespace std;
+int main()
+{
+    string str = "Hello";
+    cout<<str<<endl;
+
+    //Accessing individual character
+    //Accessing individual characters: str[i], str.at(i)
+    cout<<str[0]<<endl;     //method one
+    cout<<str.at(0)<<endl;  //methond two
+
+    //Length of string
+    //Length: str.length(), str.size()
+    cout<<"Length of string: "<<str.length()<<endl;     //method one
+    cout<<"Length of string: "<<str.size()<<endl;       //method two
+
+    //concatenation
+    //Concatenation: str1 + str2, str1.append(str2)
+    string str2 = "World";
+    cout<<str+str2<<endl;           //method one
+    cout<<str.append(str2)<<endl;   //method two
+
+    //extraction
+    //Substring extraction: str.substr(startIndex, length)
+    cout<<str.substr(0,5)<<endl;   
+
+    //substring
+    //Searching for substrings: str.find(substring), str.rfind(substring)
+    cout<<str.find("World")<<endl;  //method one
+    cout<<str.rfind("World")<<endl; //method two
+
+    //modifying string
+    str.replace(5,4,"everyone!");   //replace 4 characters and add "everyone" from 5 th index position
+    cout<<str<<endl;
+
+    str.erase(5,7);             //deleting 7 characters from index 5
+    cout<<str<<endl;
+
+    str.insert(5,"everyone!");
+    cout<<str<<endl;
+    
+    //comaparison
+    //Comparison: str1 == str2, str1 < str2, etc.
+    if(str==str2)
+        cout<<str<<" and "<<str2<<" are same"<<endl;
+    else
+        cout<<str<<" and "<<str2<<" are not same"<<endl;
+
+
+    string str3;
+    cin>>str3;
+    cout<<str3<<endl;
+    string str4;
+    getline(cin,str4);      //to print string with space
+    cout<<str4<<endl;
+}

Datatypes/wchar_t.cpp

@@ -0,0 +1,8 @@
+#include <iostream>
+using namespace std;
+int main() {
+    wchar_t myWideChar = L'€';
+    wcout << "Wide character: " << myWideChar << endl;
+    wcout << "Size of wchar_t: " << sizeof(wchar_t) << " bytes" << endl;
+    return 0;
+}

Function_overloading/README.md

@@ -0,0 +1,34 @@
+### Function Overloading
+
+Function overloading is a feature in C++ that allows `multiple functions with the same name, but different parameter lists`, to be defined. This means that you can have multiple functions in a program with the same name, as long as they have different types or number of parameters.
+
+example:
+
+```C++
+#include <iostream>
+using namespace std;
+void print(int num) {
+    cout << "Printing an integer: " << num << endl;
+}
+ 
+void print(double num) {
+    cout << "Printing a double: " << num << endl;
+}
+ 
+void print(char c) {
+    cout << "Printing a character: " << c << endl;
+}
+ 
+int main() {
+    print(5);          // Calls the function print(int)
+    print(3.14);       // Calls the function print(double)
+    print('a');        // Calls the function print(char)
+    
+    return 0;
+}
+
+
+```
+---
+
+[Next](https://github.com/Lavin-tom/cpp_programming/tree/master/Inline_functions)

Function_overloading/function_overloading.cpp

@@ -0,0 +1,44 @@
+//swapping using function over loading
+#include<iostream>
+using namespace std;
+void swap_data(int a,int b)
+{
+	int t;
+	cout<<"integer swaping"<<endl;
+	t=a;
+	a=b;
+	b=t;
+	cout<<"a: "<<a<<" b: "<<b<<endl;
+}
+void swap_data(char ch1,char ch2)
+{
+	char t;
+        cout<<"char swaping"<<endl;
+        t=ch1;
+        ch1=ch2;
+        ch2=t;
+        cout<<"ch1: "<<ch1<<" ch2: "<<ch2<<endl;
+}
+void swap_data(float f1,float f2)
+{
+ 	float t;
+        cout<<"float swaping"<<endl;
+        t=f1;
+        f1=f2;
+        f2=t;
+        cout<<"f1: "<<f1<<" f2: "<<f2<<endl;
+}
+int main()
+{
+	int a=10,b=20;
+	char ch1='A',ch2='B';
+	float f1=12.3,f2=34.5;
+	cout<<"before swpping"<<endl;
+	cout<<"a: "<<a<<" b: "<<b<<endl;
+	cout<<"ch1: "<<ch1<< "ch2: "<<ch2<<endl;
+	cout<<"f1: "<<f1<< " f2: "<<f2<<endl;
+	cout<<"after swaping"<<endl;
+	swap_data(a,b); 
+    swap_data(ch1,ch2);
+	swap_data(f1,f2);
+}

Function_overloading/function_overloading_basics.cpp

@@ -0,0 +1,27 @@
+//function overloading
+//same function name different parameter list
+#include<iostream>
+using namespace std;
+void print(int a)
+{
+    cout<<a<<endl;
+}
+void print(double a)
+{
+    cout<<a<<endl;
+}
+void print(char a)
+{
+    cout<<a<<endl;
+}
+void print(string a)
+{
+    cout<<a<<endl;
+}
+int main()
+{
+    print(10);
+    print(12.34);
+    print('?');
+    print("testing");
+}

Inline_functions/README.md

@@ -0,0 +1,21 @@
+### Inline function
+
+ An inline function is a function that is expanded by the compiler at the location where it is called, rather than being executed as a separate function call. 
+
+To define an inline function in C++, the keyword `inline` is placed before the function declaration. For example:
+
+```C++
+inline int multiply(int x, int y) {
+    return x * y;
+}
+```
+
+When an inline function is called, `the compiler replaces the function call with the actual code of the function`. This eliminates the overhead of making a function call, resulting in faster execution. 
+
+#### Notes :
+- inline keyword is just a suggestion to the compiler, and the compiler is free to decide whether or not to actually inline the function.
+ -  inline functions should be kept small, as large functions may not be suitable for inlining.
+
+---
+
+[Next](https://github.com/Lavin-tom/cpp_programming/tree/master/Dynamic_memory_allocation)

functions/inline_function/inline_function.cpp renamed to Inline_functions/inline_function.cpp

@@ -50,7 +50,7 @@
 |Not have Exception Handling|Having exception handling|
 |Template is not available|Template is available|
 
-```
+```C++
 #include<iostream>
 using namespace std;
 int main()

functions/inline_function/inline_functions.cpp renamed to Inline_functions/inline_functions.cpp

@@ -10,6 +10,19 @@ The repository is organized into multiple directories, each focusing on a specif
 
 If you are new to C++ or programming in general, we recommend starting with the [Introduction to C++](https://github.com/Lavin-tom/cpp_programming/tree/master/Introduction-to-C++) directory. Here, you will find introductory topics, basic syntax, and fundamental programming concepts that will lay the groundwork for your C++ journey.
 
+## Topic Covered
+### Flow of Concepts
+-   [Introduction to C++](https://github.com/Lavin-tom/cpp_programming/tree/master/Introduction-to-C++)
+-   [Scope Resolution Operator](https://github.com/Lavin-tom/cpp_programming/tree/master/Scope_resolution_operator)
+-   [Reference Operator](https://github.com/Lavin-tom/cpp_programming/tree/master/Reference_operator)
+-   [Argument Passing](https://github.com/Lavin-tom/cpp_programming/tree/master/Argument_passing)
+-   [Namespace](https://github.com/Lavin-tom/cpp_programming/tree/master/Namespace)
+-   [Datatypes](https://github.com/Lavin-tom/cpp_programming/tree/master/Datatypes)
+-   [Function Overloading](https://github.com/Lavin-tom/cpp_programming/tree/master/Function_Overloading)
+-   [Inline Functions](https://github.com/Lavin-tom/cpp_programming/tree/master/Inline_functions)
+-   [Dynamic Memory Allocation](https://github.com/Lavin-tom/cpp_programming/tree/master/Dynamic_memory_allocation)
+-   [Structure](https://github.com/Lavin-tom/cpp_programming/tree/master/Structure)
+
 ## Start Learning C++ Today!
 
 We believe that learning programming should be an enjoyable and enriching experience. With this C++ Beginner's Repository, we hope to provide you with the necessary resources to kickstart your journey into the world of C++ programming. Happy coding!

Introduction-to-C++/README.md

@@ -3,7 +3,7 @@
 Used to provide alias name/duplicate name for existing varibale.
 
 Syntax : `datatype &new_name = existing_name;`
-```
+```C++
 example: 
 
 #include<iostream>
@@ -24,7 +24,7 @@ x: 20
 #### Reference to Array
 Syntax : `datatype (&new_array)[size] = existing_array; `
 
-```
+```C++
 example: 
 
 #include<iostream>
@@ -45,7 +45,7 @@ output:
 #### Reference to Pointer
 Syntax : `datatype* (&new_variable) = existing_variable; `
 
-```
+```C++
 example: 
 
 #include<iostream>

README.md

@@ -2,7 +2,7 @@
 
 To access global variable when there is local varibale with same. 
 
-``` 
+```C++
 example:
 
 #include<iostream>