diff --git a/Arrays/Heap.cpp b/Arrays/Heap.cpp
new file mode 100644
index 0000000..2dfc0de
--- /dev/null
+++ b/Arrays/Heap.cpp
@@ -0,0 +1,56 @@
+//there is no way of knowing the size of array in c++;but there is a way cause when you delete this heap memory compiler needs to know the size of array but its comprimising
+
+#include <iostream>
+#include <array>
+
+class Entity
+{
+    public :
+
+      static const int exampleSize = 5;//constexpr will explained later which is constant expression
+      int* example[exampleSize];//suppose we changed it to a heap we first get the Entity memory adress which leads to the array  its a jumping across the memory so [better to switch it to stack]
+
+    std::array<int, 5> another;//type and size
+
+      Entity()
+      {
+         
+
+         int a[5];
+
+        int count =  sizeof(a) / sizeof(int);//size means bytes ,count means no of elements 
+
+        //example->size();//we cant do like this like some other languages for heap in Entity class
+           for(int i = 0; i < another.size(); i++)
+             example[i] = 2;//constructor which initializes
+
+      }
+};
+
+int main()
+{
+
+    Entity e;
+
+    /*int example[5];
+    for(int i = 0; i < 5; i++)
+    example[i] = 2;*///we moved into the Entity class
+
+
+    //int* another = new int[5];
+    //for(int i = 0; i < 5; i++)
+    //another[i] = 2;
+
+
+    //delete[] another;
+
+
+    std::cin.get();
+}
+//this is based on heap allocated memory with new keyword
+//we  need to manually delete this
+//stack created it will ends when we get out of curly bracket int example[5]
+//heap created more over the stack cause of the life times most probably suppose if we need to return the array inside of our funtion
+
+//in c++ 11 there is called standard array which has inbuilt datastructures  used rather than the normal raw array
+//it includes bounds checking and it keeps tracking size of arrray
\ No newline at end of file
diff --git a/Arrays/Heap.exe b/Arrays/Heap.exe
new file mode 100644
index 0000000..af48917
Binary files /dev/null and b/Arrays/Heap.exe differ
diff --git a/Arrays/Log.cpp b/Arrays/Log.cpp
new file mode 100644
index 0000000..416b6d9
--- /dev/null
+++ b/Arrays/Log.cpp
@@ -0,0 +1,23 @@
+#include <iostream>
+
+int main()
+{ 
+    int example[5];
+    int* ptr = example;
+
+    
+    for (int i = 0; i < 5; i++)
+            //example[i] = 2;//this is a text an offset to this memory of array
+        
+
+
+     example[2] = 5;//for index 2 its start at 9th byte we are writting an offset of 8 bytes from a pointer
+    *(ptr + 2) = 6;//we are dereferencing this pointer way of writting and changing value from 5 to 6
+    *(int*)((char*)ptr + 8) = 6;//this is the way of writting in single bit[char] and even in int data type of 4 bytes
+
+
+    std::cin.get();
+}
+
+//arrays are always stored in rows ; each integer of 4 bytes total 20 bytes;
+//array is just a pointer here it is a int pointer
\ No newline at end of file
diff --git a/Arrays/Log.exe b/Arrays/Log.exe
new file mode 100644
index 0000000..4ca6081
Binary files /dev/null and b/Arrays/Log.exe differ
diff --git a/Arrays/main.cpp b/Arrays/main.cpp
new file mode 100644
index 0000000..3e80083
--- /dev/null
+++ b/Arrays/main.cpp
@@ -0,0 +1,27 @@
+//in java we have no modifier = default modifier
+//in c# we have such as internal[these are topics in visibility]
+/*Arrays in C++ are a collection of multiple elements of the same type stored in contiguous memory locations (one after another).[in rows]
+They are one of the most basic and important data structures in C++.*/
+//lua language starts from index 1;c++ is 0 
+//its like having multiple variables in a single variable
+//arrays mostly work with for loops[indexable loops];without it we need to set manually the example array
+
+#include <iostream>
+
+int main()
+{
+    int example[5]; //array type and name mentioned its contain 5 integers
+    example[0] = 2;
+    example[4] = 4;//last index
+
+    example[-1] = 5;
+    example[17] = 21;//we get memory access violation [in debug mode we get errors not in release mode]
+    
+
+    std::cout << example[0] << std::endl;//with mentioning index, we get underlying data type
+    std::cout << example << std::endl;//actual array print memory adress cause its a pointer type
+
+
+
+    std::cin.get();
+}
diff --git a/Implicit conversion and Explicit keyword/main.cpp b/Implicit conversion and Explicit keyword/main.cpp
new file mode 100644
index 0000000..cc39ca9
--- /dev/null
+++ b/Implicit conversion and Explicit keyword/main.cpp	
@@ -0,0 +1,43 @@
+//Implicit means without explicitly telling what to do [automatically]
+//To explicit a constructor we keep explicit keyword before the constructor
+//compiler can perform one implicit conversion in our code[without casting]
+
+#include <iostream>
+#include <string>
+
+class Entity
+{
+  private :
+    std::string m_Name;
+    int m_Age;
+  public :
+    explicit Entity(const std::string& name)
+           : m_Name(name), m_Age(-1) {}
+    explicit Entity(int age)
+           : m_Name("Unknown"), m_Age(age) {}
+
+
+};
+
+void PrintEntity(const Entity& entity)
+{
+    //Printing
+}
+
+int main()
+{
+
+    PrintEntity(22);
+    //PrintEntity("Cherno"); //Cherno string is not a std string its a  const char array of 7 characaters and c++ have to convert 2 [char array to string and string to Entity]
+    PrintEntity(std::string("Cherno"));
+    PrintEntity(Entity("Cherno"));//both are the same
+
+    //Entity a ("Cherno"); //or Entity a = Entity("Cherno");
+    Entity a = Entity("Cherno");//cant cause iam equating string literal to a Entity object!!
+    Entity b = 22;//we cannot do when it is explicit we have to do Entity b(22); or Entity b = (Entity)22;[explicitly casting to a Entity] or Entity b = Entity(22);
+
+    std::cin.get();
+}
+
+
+//c++ cannot perform 2 implicit conversions at a time!!
\ No newline at end of file
diff --git a/Implicit conversion and Explicit keyword/main.exe b/Implicit conversion and Explicit keyword/main.exe
new file mode 100644
index 0000000..1838779
Binary files /dev/null and b/Implicit conversion and Explicit keyword/main.exe differ
diff --git a/Instantiating--objects/heap.cpp b/Instantiating--objects/heap.cpp
new file mode 100644
index 0000000..e7ee710
--- /dev/null
+++ b/Instantiating--objects/heap.cpp
@@ -0,0 +1,49 @@
+#include <iostream>
+#include <string>
+
+using string = std::string;
+
+
+class Entity
+{
+    private :
+
+      string m_Name;
+    public :
+    
+    Entity() : m_Name("Unknown")
+    {
+    }
+
+    Entity(const string& name) : m_Name(name)
+    {
+    }
+
+    const string& GetName() const
+    {
+      return m_Name;
+    }
+    
+};
+
+int main()
+{
+
+    Entity* e;
+
+    {
+
+        Entity* entity = new Entity("Cherno");//we should make an Entity pointer called entity nand this new Entity returns a Entity pointer! and this is common code in c# or java by removing pointer
+        e = entity;//not copying just assigning[storing memory adress]
+        std::cout << entity->GetName() << std::endl;//also can be (*entity) dereferncing or with arrow operator
+
+    }
+
+    std::cin.get();
+    delete e;//variable name,until this Cherno exits through objects
+}
+
+//in c# there is struct which is value based type kind of allocated on stack eventhough you used new keyword
+//in java everything is in heap
+//in c# all classes on heap
+//with smart pointers we can allocate on heap also get objects get autodeleted after scope like shed pointers 
\ No newline at end of file
diff --git a/Instantiating--objects/main.cpp b/Instantiating--objects/main.cpp
new file mode 100644
index 0000000..eb8fd2f
--- /dev/null
+++ b/Instantiating--objects/main.cpp
@@ -0,0 +1,61 @@
+#include <iostream>
+#include <string>
+
+using string = std::string;
+
+
+class Entity
+{
+    private :
+
+      string m_Name;
+    public :
+    
+    Entity() : m_Name("Unknown")
+    {
+    }
+
+    Entity(const string& name) : m_Name(name)
+    {
+    }
+
+    const string& GetName() const
+    {
+      return m_Name;
+    }
+    
+};
+
+/*void Function()
+{
+    int a = 2;
+    Entity entity  = Entity("Cherno");//after this loop this Entity gets destroyed!
+}*/
+
+int main()
+{
+
+    Entity* e;
+    {
+
+   // Function();// Stack frame gets created includes all classes and also primitive types and after that loop its all get destroyed!
+
+     Entity entity("Cherno");    //calls default constructor if there are no parameters[null referncce exception in c# or java ]
+     
+     //Entity entity  = Entity("Cherno");//same as the previous line
+     
+     e = &entity;
+     std::cout << entity.GetName() << std::endl;
+    }
+
+    std::cin.get();
+}
+
+
+/*we need to instantiate a class [not static]
+  2 ways of creating by the type of memory used heap and stack
+  its all based on lifetime and speedness 
+  1.stack is autodeleted after the end of loop and its fast
+  2.heap have to deleted manually and its slow
+  also we have an area where our source code lives*/
+  
\ No newline at end of file
diff --git a/Instantiating--objects/main.exe b/Instantiating--objects/main.exe
new file mode 100644
index 0000000..04258c9
Binary files /dev/null and b/Instantiating--objects/main.exe differ
diff --git a/Interfaces/main.cpp b/Interfaces/main.cpp
new file mode 100644
index 0000000..b0b1fbd
--- /dev/null
+++ b/Interfaces/main.cpp
@@ -0,0 +1,78 @@
+/*Pure virtual function in C++ is the key feature that lets you create interfaces (or abstract classes that behave like interfaces).
+What is a Pure Virtual Function?
+A pure virtual function is a virtual function that:
+
+Has = 0 at the end
+Has no implementation in the base class (or sometimes just a dummy one)
+Forces every derived (child) class to provide its own implementation
+we cant instantiate the interface class [only sub classes we can and have to]
+Interfaces are just classes in c++ with unimplemented methods acting as template of source unlike other languages as java or c#*/
+
+
+#include <iostream>
+#include <string>
+
+  class Printable
+
+    {
+  public :
+     virtual std::string GetClassName() = 0;//now every class have to contain GetClassName function to implement
+        
+    };
+
+      class Entity : public Printable//made a sub class
+    {
+        public :
+          virtual std::string GetName() { return "Entity"; }//by removing body and equating to 0 makes a pure virtal funtion
+          std::string GetClassName() override { return "Entity"; } 
+  
+        };
+    
+    class Player : public Entity //no need of printable 
+    {
+        private :
+          std::string m_Name;
+      public :
+          Player(const std::string& name)
+               : m_Name(name) {}
+
+               std::string GetName() override { return m_Name; }
+               std::string GetClassName() override { return "Player"; } 
+    };
+
+    void PrintName(Entity* entity)
+    {
+          std::cout << entity->GetName() << std::endl;
+    }
+
+    class A : public Printable 
+    {
+       public :
+           std::string GetClassName() override {return "A"; }
+
+    };
+
+
+    void Print(Printable* obj)//this is for printing names of class and type which has GetClassName funtion and make Printable a pointer 
+{
+    std::cout << obj->GetClassName() << std::endl;
+}
+int main()
+{
+
+    Entity* e = new Entity();//cant instantiate the Entity class if it is pure virtual funtion and we need to give a sub class where the funtion is implemented eg Player("")
+   // PrintName(e);
+    
+    
+    Player* p = new Player("Suhas");
+    //PrintName(p);
+
+    Print(e);
+    Print(p);
+    Print(new A());//it is a memory leak
+
+
+   
+    std::cin.get();
+}
+    //we can only instantiate the class if it actually has all those pure virtual functions implemented[all funtions implemented]
\ No newline at end of file
diff --git a/Interfaces/main.exe b/Interfaces/main.exe
new file mode 100644
index 0000000..cd09c06
Binary files /dev/null and b/Interfaces/main.exe differ
diff --git a/Member initialiser lists/Log.cpp b/Member initialiser lists/Log.cpp
new file mode 100644
index 0000000..28c758f
--- /dev/null
+++ b/Member initialiser lists/Log.cpp	
@@ -0,0 +1,69 @@
+#include <iostream>
+#include <string>
+
+class Example
+{
+    public :
+      Example()
+      {
+        std::cout << "Created Entity!" << std::endl;
+
+      }
+
+      Example(int x)
+      {
+
+        std::cout << "Created Entity with " << x << "!" << std::endl;
+
+      }
+
+};
+
+class Entity
+{
+           //This is through member initializer list!!
+    private :
+       std::string m_Name;
+       Example m_Example;//created an Entity! like it  is in Entity class
+
+
+       //int m_Score;
+       //int x, y, z;
+
+     public :
+
+     Entity() 
+               : m_Example(Example(8)) //we can also use only 8 inside
+                //:  x(0), y(0), z(0)//,m_Score(0) //Initialiser list need to list in order of class members declared!!
+     {
+        //m_Name = "Unknown";//ThiS m_Name object constructed twice [default constrfuctor and with unknown parameter]
+
+            m_Name = std::string("Unknown");
+            //m_Example = Example(8);
+
+     }
+
+     Entity(const std::string& name)  //constructor
+                : m_Name(name)
+     {
+     }
+         const std::string& GetName() const {
+            return m_Name;
+         }
+
+};
+
+int main()
+{
+
+    Entity e0;
+     //std::cout << e0.GetName() << std::endl;
+
+    /*Entity e1("Cherno");
+     std::cout << e1.GetName() << std::endl;*/
+
+    std::cin.get();
+}
+
+     //this keeps code in the constructor a lot cleaner !!
+     //but there is funtional differnce specifically applied to classes
\ No newline at end of file
diff --git a/Member initialiser lists/Log.exe b/Member initialiser lists/Log.exe
new file mode 100644
index 0000000..cd8e18d
Binary files /dev/null and b/Member initialiser lists/Log.exe differ
diff --git a/Member initialiser lists/main.cpp b/Member initialiser lists/main.cpp
new file mode 100644
index 0000000..6519971
--- /dev/null
+++ b/Member initialiser lists/main.cpp	
@@ -0,0 +1,39 @@
+//Its a way for us to initialiaze our class member funtions in the constructor
+
+#include <iostream>
+#include <string>
+
+class Entity
+{
+
+    private :
+       std::string m_Name;
+     public :
+
+     Entity() //Default constructor 
+     {
+            m_Name = "Unknown";
+     }
+
+     Entity(const std::string& name)  //constructor
+     {
+           m_Name = name;
+
+     }
+         const std::string& GetName() const {
+            return m_Name;
+         }
+
+};
+
+int main()
+{
+
+    Entity e0;
+     std::cout << e0.GetName() << std::endl;
+
+    Entity e1("Cherno");
+     std::cout << e1.GetName() << std::endl;
+
+    std::cin.get();
+}
\ No newline at end of file
diff --git a/Member initialiser lists/main.exe b/Member initialiser lists/main.exe
new file mode 100644
index 0000000..a31d155
Binary files /dev/null and b/Member initialiser lists/main.exe differ
diff --git a/Mutable--keyword/Lambda.cpp b/Mutable--keyword/Lambda.cpp
new file mode 100644
index 0000000..0994b4b
--- /dev/null
+++ b/Mutable--keyword/Lambda.cpp
@@ -0,0 +1,47 @@
+#include <iostream>
+#include <string>
+
+class Entity
+{
+  private :
+          std::string m_Name;
+          mutable int m_DebugCount = 0;
+
+   public :
+       const std::string& GetName() const
+       {
+        m_DebugCount++;
+        return m_Name;
+       }
+
+};
+
+int main()
+{
+
+    class Entity e ;
+    e.GetName();
+
+    int x = 8;
+    auto f = [=]() mutable
+                        //we can write &x or x or = or &
+    {
+        //std::cout << "Hello" << std::endl;
+        //x++;//by value = we get error we need to get it through local variable so better to use mutable keyword
+
+        /*  int y = x;
+          y++;
+        std::cout << y << std::endl;*/
+
+        x++;//we passed it through value through mutable keyword
+        std::cout << x << std::endl;
+
+    };
+
+    f();
+             //x = 8 cause we pased through value than reference
+    std::cin.get();
+}
+        /*lambda is a little through away funtion 
+               you can write and
+        assign it to the variable quickly */
diff --git a/Mutable--keyword/main.cpp b/Mutable--keyword/main.cpp
new file mode 100644
index 0000000..646d9ac
--- /dev/null
+++ b/Mutable--keyword/main.cpp
@@ -0,0 +1,31 @@
+/*the application of mutable mostly with lambdas and const
+   its like mutable reversing the meaning of const*/
+
+#include <iostream>
+#include <string>
+
+class Entity
+{
+  private :
+          std::string m_Name;
+          mutable int m_DebugCount = 0;
+
+   public :
+       const std::string& GetName() const//const and ref
+           //making methods const so not to modify the class
+
+       {
+        m_DebugCount++;//its for supppose how many times we debugging
+        return m_Name;
+       }
+
+};
+
+int main()
+{
+
+    class Entity e ;
+    e.GetName();//we will do if the method is const
+
+    std::cin.get();
+}
diff --git a/Operators -- its overloading/Log.cpp b/Operators -- its overloading/Log.cpp
new file mode 100644
index 0000000..f829f51
--- /dev/null
+++ b/Operators -- its overloading/Log.cpp	
@@ -0,0 +1,64 @@
+#include <iostream>
+#include <string>
+
+
+struct Vector2
+{
+     float x, y;
+
+     Vector2(float x,float y)
+            : x(x), y(y) {}
+
+     /*Vector2 Add(const Vector2& other) const  
+      {
+            return *this + other; const ptr in this case so we need to dereference this this keyword!!
+            return operator+(other);
+      
+            } */   
+
+
+
+      Vector2 Add(const Vector2& other) const  
+      {
+            return Vector2(x + other.x, y + other.y);
+      }    
+
+
+      Vector2 operator+(const Vector2& other) const
+       {
+          return Add(other);
+       }
+
+      /*
+      
+             Vector2 operator+(const Vector2& other) const
+           {
+               return Vector2(x + other.x, y + other.y); we have done reverse of the overloading like creating Add from +
+           }
+               */
+       
+
+
+      Vector2 Multiply(const Vector2& other) const
+      {
+            return Vector2(x * other.x, y * other.y );
+      }
+
+      Vector2 operator*(const Vector2& other) const
+      {
+            return Multiply(other);
+      }
+
+};
+
+int main()
+{
+     Vector2 position(4.0f, 4.0f);
+     Vector2 speed(0.5f, 1.5f);
+     Vector2 powerup(1.1f, 1.1f);
+
+
+     Vector2 result1 = position.Add(speed.Multiply(powerup));
+     Vector2 result2 = position + (speed * powerup);//BODMAS
+}
+
diff --git a/Operators -- its overloading/dumb.cpp b/Operators -- its overloading/dumb.cpp
new file mode 100644
index 0000000..da63c1e
--- /dev/null
+++ b/Operators -- its overloading/dumb.cpp	
@@ -0,0 +1,84 @@
+#include <iostream>
+#include <string>
+
+
+struct Vector2
+{
+     float x, y;
+
+     Vector2(float x,float y)
+            : x(x), y(y) {}
+
+
+      Vector2 Add(const Vector2& other) const  
+      {
+            return Vector2(x + other.x, y + other.y);
+      }    
+
+
+      Vector2 operator+(const Vector2& other) const
+       {
+          return Add(other);
+       }
+
+    
+
+
+      Vector2 Multiply(const Vector2& other) const
+      {
+            return Vector2(x * other.x, y * other.y );
+      }
+
+      Vector2 operator*(const Vector2& other) const
+      {
+            return Multiply(other);
+      }
+
+
+    //equals(),Tostring in case of java 
+
+    bool operator==(const Vector2& other) const//EQUATING
+    {
+            return x == other.x && y == other.y;
+    }
+
+     bool operator!=(const Vector2& other) const
+    {
+
+           // return !operator==(other); not preferrable!!!!
+            return !(*this == other);//to reverse how it works!!
+    }
+
+
+};
+
+  std::ostream& operator<<(std::ostream& stream, const Vector2& other)
+  {
+    stream << other.x << ", " << other.y;
+      return stream;
+  }
+
+int main()
+{
+     Vector2 position(4.0f, 4.0f);
+     Vector2 speed(0.5f, 1.5f);
+     Vector2 powerup(1.1f, 1.1f);
+
+
+     Vector2 result1 = position.Add(speed.Multiply(powerup));
+     Vector2 result2 = position + (speed * powerup);//BODMAS
+
+     //if (!result1.equals(result2))//this is how you equate in a java 
+      if(result1 == result2)
+      {
+
+      }
+
+
+     std::cout << result2 << std::endl;//no overload for << operator to take in an output string and also Vector2
+
+}
+
+
+//This is about the leftshift operator!!!
+
diff --git a/Operators -- its overloading/main.cpp b/Operators -- its overloading/main.cpp
new file mode 100644
index 0000000..862cd4a
--- /dev/null
+++ b/Operators -- its overloading/main.cpp	
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <string>
+
+
+struct Vector2
+{
+     float x, y;
+
+     Vector2(float x,float y)
+            : x(x), y(y) {}
+
+      Vector2 Add(const Vector2& other) const  
+      {
+            return Vector2(x + other.x, y + other.y);
+      }    
+
+      Vector2 Multiply(const Vector2& other) const
+      {
+            return Vector2(x * other.x, y * other.y );
+      }
+      
+
+};
+
+int main()
+{
+     Vector2 position(4.0f, 4.0f);
+     Vector2 speed(0.5f, 1.5f);
+     Vector2 powerup(1.1f, 1.1f);//Multiplies the result!!
+
+
+    Vector2 result = position.Add(speed.Multiply(powerup));//without operator overloading
+
+    std::cin.get();
+}
+
+
+//Operators are just funtions!!
+//Operator overloading is just giving new funtionality to the operator
+//This is not supported on java and partially on c# and use when only its needed!
\ No newline at end of file
diff --git a/String - Literals/Log.cpp b/String - Literals/Log.cpp
new file mode 100644
index 0000000..601ab17
--- /dev/null
+++ b/String - Literals/Log.cpp	
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <string>
+
+#include <stdlib.h>
+
+int main()
+{
+
+    using namespace std::string_literals;//gives no of funtions for convenience
+    
+    std::string name0 = std::string("Cherno") + "hello!";//cant do cause you cant add 2 raw literals directly 
+    std::string name0 = "Cherno"s + "hello!";//this s returns a standard string and u8 for normal string and L infront of the string literals for wide string
+
+
+    std::u32string name0 = U"Cherno"s + U" hello";//for wide string it is wstring and R for row
+
+    const char* example = R"(Line1
+    Line2
+    Line3
+    Line4)";
+
+      const char* ex = "Line1\n"
+           "Line2\n"
+            "Line3\n";           
+    
+
+
+    const char* name = u8"Cherno";//made with utf 8 similar to remaining ones [ unicode transformation format ]
+    const wchar_t* name2 = L"Cherno";//wide and this is 2 bytes per character[but variable for such as linux and windows]
+
+    const char16_t* name3 = u"Cherno";//2 bytes per character or 16 bits a character using string
+    const char32_t* name4 = U"Cherno";//32 bits character or 4 bytes per character
+
+
+
+    std::cin.get();
+}
+
+/*string literals are always stored in read only memory
+       so i cant equate a char pointer to a string litreral 
+         which is a READ ONLY MEMORY
+         we can use a const char array */ 
\ No newline at end of file
diff --git a/String - Literals/main.cpp b/String - Literals/main.cpp
new file mode 100644
index 0000000..9ebf11f
--- /dev/null
+++ b/String - Literals/main.cpp	
@@ -0,0 +1,20 @@
+#include <iostream>
+#include <string>
+
+#include <stdlib.h>
+#include <cstring>
+
+        /*just a standard c library include 3 funtions and 
+               its a string literal also written as
+                    "Suhas"; 0[this is numeric zero]*/
+
+int main()
+{
+    const char name[8] = "Che\0rno";
+
+              /*8 cause it even ends with \0*/
+                                                        
+    std::cout << strlen(name) << std::endl;
+                                                      
+    std::cin.get();
+}
\ No newline at end of file
diff --git a/String - Literals/main.exe b/String - Literals/main.exe
new file mode 100644
index 0000000..c01c629
Binary files /dev/null and b/String - Literals/main.exe differ
diff --git a/Strings - working/Log.cpp b/Strings - working/Log.cpp
new file mode 100644
index 0000000..8756b60
--- /dev/null
+++ b/Strings - working/Log.cpp	
@@ -0,0 +1,37 @@
+#include <iostream>
+#include <string>
+
+void PrintString(const std::string& string)//creating copy of that std::string class
+
+{
+   // string += "h"; by removing the const and the refernce keywords and its just a read only function
+    std::cout << string << std::endl;
+
+}
+
+int main()
+{
+     std::string name = "Suhas";// + "hello!";process of appending strings
+     name += "hello!";
+
+     std::string name = std::string("Suhas") + "hello";
+     PrintString(name);
+     bool contains = name.find("no") != std::string::npos;//to find text in our string
+         
+       /*npos is the illegal position for that find
+       and name.find returns position of that no thing*/
+
+
+     name.size();
+               
+            /*strlen(s) for the length of the string char* s
+                and strcpy for copying of the strings*/
+
+
+
+     std::cout << name << std::endl;
+
+     std::cin.get();
+
+}          /* string copying in funtions are quite slow
+        strings can be addable than char ptrs  */
\ No newline at end of file
diff --git a/Strings - working/main.cpp b/Strings - working/main.cpp
new file mode 100644
index 0000000..4679cfd
--- /dev/null
+++ b/Strings - working/main.cpp	
@@ -0,0 +1,36 @@
+#include <iostream>
+#include <string>
+
+int main()
+{
+     std::string name = "Suhas";
+                  
+        /*char pointer[c style of defining]  and we keep it const
+         cause to make string immutable;
+           will changes to std::string by
+                 using header file of string*/
+         
+     char name2[6] = { 'S', 'u', 'h', 'a', 's', 0 };
+
+         /*0 or '\0' is the null termination character 
+         string terminates after hitting 0; without it
+         the string goes outside of allocated memory*/
+
+
+     std::cout << name2 << std::endl;
+
+
+     name[2] = 'a';
+
+     std::cin.get();
+
+}          
+           /*Its just the array of chars
+              char is of 1 byte of memory and 
+              string generally uses char ;
+                wide strings are 2 bytes per character
+                std::string is templated version of basic 
+                string class which is templated with char */
+                
+//char is underlying datatype for each chartacter in std::string             
+//string has a constructor takes char or const char ptr
\ No newline at end of file
diff --git a/Strings - working/main.exe b/Strings - working/main.exe
new file mode 100644
index 0000000..b79fd31
Binary files /dev/null and b/Strings - working/main.exe differ
diff --git a/Terenary--operators/Log.cpp b/Terenary--operators/Log.cpp
new file mode 100644
index 0000000..7abfc30
--- /dev/null
+++ b/Terenary--operators/Log.cpp
@@ -0,0 +1,22 @@
+#include <iostream>
+#include <string>
+
+static int s_Level = 102;
+static int s_Speed = 2;
+
+int main()
+{
+       /* if (s_Level > 5)
+          s_Speed = 10;
+        else
+           s_Speed = 5;*/
+
+        //s_Speed = s_Level > 5 ? 10 : 2;   //we need to write the condition first and then ?:
+         s_Speed = (s_Level > 5  && s_Level < 100) ?  s_Level > 10 ? 15 : 10 : 5;//this brackets are initially absent
+
+
+       std::cout << s_Speed <<std::endl;
+
+
+    std::cin.get();
+}     
\ No newline at end of file
diff --git a/Terenary--operators/Log.exe b/Terenary--operators/Log.exe
new file mode 100644
index 0000000..fae0180
Binary files /dev/null and b/Terenary--operators/Log.exe differ
diff --git a/Terenary--operators/main.cpp b/Terenary--operators/main.cpp
new file mode 100644
index 0000000..d66a5b9
--- /dev/null
+++ b/Terenary--operators/main.cpp
@@ -0,0 +1,37 @@
+//Just an alternative way of writting if and else statements!!
+      //  ? = if    : = else
+
+#include <iostream>
+#include <string>
+
+static int s_Level = 1;
+static int s_Speed = 2;
+
+int main()
+{
+       /* if (s_Level > 5)
+          s_Speed = 10;
+        else
+           s_Speed = 5;*/
+
+        //s_Speed = s_Level > 5 ? 10 : 2;   //we need to write the condition first and then ?:
+         s_Speed = s_Level > 5 ?  s_Level > 10 ? 15 : 10 : 5;
+
+
+       std::string rank = s_Level > 10 ? "Master" : "Beginner";//not construct an intermediate string due to return value optimisation and its faster
+
+       std::string otherRank;//without terenary operator and constructing a temporary string and destroying it!
+           if(s_Level > 10)
+           otherRank = "Master";
+
+           else
+             otherRank = "Beginner";
+
+
+    std::cin.get();
+}     
+
+
+
+    
+
diff --git a/Virtual functions/Log.cpp b/Virtual functions/Log.cpp
new file mode 100644
index 0000000..4bdae24
--- /dev/null
+++ b/Virtual functions/Log.cpp	
@@ -0,0 +1,50 @@
+#include <iostream>
+#include <string>
+
+    class  Entity
+    {
+        public :
+          virtual std::string GetName() { return "Entity"; }//getName is going to return string
+
+    };
+    
+    class Player : public Entity
+    {
+        private :
+          std::string m_Name;//stores a name
+      public :
+          Player(const std::string& name)//constructor allows to specify a name
+               : m_Name(name) {}
+
+               std::string GetName() override { return m_Name; }//Mark the overriden function with keyword override and this helps the funtion came from the base class
+    };
+
+    void PrintName(Entity* entity)
+    {
+          std::cout << entity->GetName() << std::endl;
+    }
+
+
+int main()
+{
+
+    Entity* e = new Entity();
+    PrintName(e);
+    //std::cout << e->GetName() <<std::endl;
+    
+    Player* p = new Player("Suhas");
+    PrintName(p);
+
+    //std::cout << p->GetName() << std::endl;
+
+
+    //Entity* entity = p;//p is pointer to a player type but this is a instance in the player class
+    //std::cout << entity->GetName();//we expect player to be printed
+
+    std::cin.get();
+}
+
+//v table contain a mapping for all the virtual functions in our base class so we can map it to correct overwritten function at runtime 
+//if i want to override a funtion you need to mark the base funtion in the base class as virtual
+//virtual funtions need extra memory to store v table to dispatch to the right funtion includes member pointer in the base class
+//and if we call virtual funtion we have to go through table to see which matches [additional performace penalty] ]
\ No newline at end of file
diff --git a/Virtual functions/main.cpp b/Virtual functions/main.cpp
new file mode 100644
index 0000000..b33a416
--- /dev/null
+++ b/Virtual functions/main.cpp	
@@ -0,0 +1,45 @@
+//binding means which functions to call
+//if not virtual it is static binding : The compiler decides at compile time which function to call, based only on the type of the pointer/reference, not the actual object it points to.
+//if it is virtual it is dynamic or runtime binding means the decision of which function to call happens at runtime, based on the actual type of the object.
+//Made possible by virtual functions and the hidden vtable mechanism
+
+//virtual functions allows up to ovverride the methods in the sub classes
+//if parent class has some virtual function then sub class can ovverride it to change the method
+
+#include <iostream>
+#include <string>
+
+    class  Entity
+    {
+        public :
+           std::string GetName() { return "Entity"; }//getName is going to return string
+
+    };
+    
+    class Player : public Entity
+    {
+        private :
+          std::string m_Name;//stores a name
+      public :
+          Player(const std::string& name)//constructor allows to specify a name
+               : m_Name(name) {}
+
+               std::string GetName() { return m_Name; }//return the name member
+    };
+
+
+int main()
+{
+
+    Entity* e = new Entity();
+    std::cout << e->GetName() <<std::endl;//created a entity and try to print the getname
+    
+    Player* p = new Player("Suhas");
+    std::cout << p->GetName() << std::endl;
+//no need to bothering of objects as program terminates it anyway
+
+    std::cin.get();
+}
+
+//everything goes bad whenever i start introduce polymorphism
+//referring player like its not entity
\ No newline at end of file
diff --git a/Visibility/.gitignore b/Visibility/.gitignore
new file mode 100644
index 0000000..14419a1
Binary files /dev/null and b/Visibility/.gitignore differ
diff --git a/Visibility/Log.cpp b/Visibility/Log.cpp
new file mode 100644
index 0000000..2638ba5
--- /dev/null
+++ b/Visibility/Log.cpp
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <string>
+
+class Entity
+{
+        protected :
+             int X, Y;
+
+
+         void Print(){}    
+
+
+public :
+     Entity()
+     {
+        X = 0;
+        Print();
+     }
+
+};
+
+class Player : public Entity//Player is a subclass of Entity
+{
+   public :
+       Player()
+       {
+        X = 2; 
+        Print();
+       }
+};
+
+int main()
+{
+     Entity e;
+     e.X = 2;
+    e.Print();//its completly different funtion and is outside of class and not even part of sub class
+    
+    std::cin.get();
+}
+
+//protected means parent and sub classes along can acccess the symbols
+//public means we know everything can access the subjects ina class
diff --git a/Visibility/main.cpp b/Visibility/main.cpp
new file mode 100644
index 0000000..3c00ef7
--- /dev/null
+++ b/Visibility/main.cpp
@@ -0,0 +1,49 @@
+/*Visibility in C++ refers to access specifiers — they control who can see and use (access) the members (variables, functions, etc.) of a class.
+In simple words:
+Visibility decides which parts of your class are public, private, or protected — i.e., who is allowed to touch them.*/
+//classes are generally private and structs are generally public
+//this visibility has no affect on performance or running or the program and generation of code [not related with CPU]
+//there are even called friends which can access the private
+
+#include <iostream>
+#include <string>
+
+class Entity
+{
+        private :
+             int X, Y;
+
+
+         void Print(){}    
+
+
+public :
+     Entity()
+     {
+        X = 0;//constructor
+        Print();
+     }
+
+};
+
+class Player : public Entity//sub class of Entity
+{
+   public :
+       Player()
+       {
+        X = 2;// Even this constructor cant access the data cause it is private
+        Print();
+       }
+};
+
+int main()
+{
+     Entity e;
+     e.X = 2;// we cant access the subjects from a priavte class
+    e.Print();
+    
+    std::cin.get();
+}
+
+//protected is more visible than Private and less visible than public
+//we keep classes public and private according to goal of not breaking the code [such as UIs]USER INTERFACE
\ No newline at end of file
diff --git a/const -- types/Log.cpp b/const -- types/Log.cpp
new file mode 100644
index 0000000..06ac31f
--- /dev/null
+++ b/const -- types/Log.cpp	
@@ -0,0 +1,74 @@
+#include <iostream>
+#include <string>
+
+class Entity
+{
+    private :
+           int m_X, m_Y;
+           mutable int var;
+    public :
+          //const int* const GetX() const //[means cant change the content and cant reassign pointer also cant change member variables of the class through methods] 
+          int GetX() const
+          {
+
+            var = 2;//suppose it needa to modify keep mutable in front of the variable
+            return m_X;     
+          }      
+
+          int GetX()
+          {
+            return m_X;
+          }
+
+          /*keeping const after method in class means 
+              this method cannot modify actual class and its 
+                 belonged variables makes just a
+                  read only method*/
+
+       void SetX(int x)// const makes no sense its setting
+       {
+            m_X = x;  
+       }         
+
+};
+
+   void PrintEntity(const Entity& e)//pass it by conast refernece to avoid copying [just a read only memory]
+   {
+       /*  e = nullptr; 
+         e = Entity(); 
+         
+               its not like pointers
+               reassigning this object means changing its own
+               no separation between pointer and contents of the pointer 
+               cause  you are the contents in ref
+               you are the entity though you are a ref
+               and GetX funtion need to be const otherwise it violates const Entity */
+
+        std::cout << e.GetX() << std::endl;
+
+   }
+
+
+   int main()
+   {
+
+    Entity e;
+     const int MAX_AGE = 90;
+
+     const int* const a = new int;
+
+     *a = 2;
+     a = (int*)&MAX_AGE;
+     a = nullptr;
+
+
+     std::cout << *a << std::endl;
+
+     std::cin.get();
+
+
+
+   }
+
+
+//int* m_X, *m_Y //its like both considering pointers
\ No newline at end of file
diff --git a/const -- types/main.cpp b/const -- types/main.cpp
new file mode 100644
index 0000000..ed5e4c7
--- /dev/null
+++ b/const -- types/main.cpp	
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <string>
+
+int main()
+{
+      const int MAX_AGE = 5;//this integer is a constant you cannot change it!
+      
+      int* a = new int; //created on heap tO acquire a pointer
+
+      *a = 2;
+      a = (int*)&MAX_AGE;
+
+      int const* a = new int;//contents cant be changed '*a'
+      const int* a = new int;//same as the above
+
+      int*const a = new int;//cant reassign the pointer 'a'
+      const int*const a = new int;//contents and assigning of pointer cant be changed
+
+
+      
+            /*dereferencing and equating to 2 [contents]
+            reassigning pointer to some other memory adress*/
+
+      std::cout << *a << std::endl;//reading 'a' is fine
+
+
+
+    std::cin.get();
+}
\ No newline at end of file
diff --git a/const -- types/main.exe b/const -- types/main.exe
new file mode 100644
index 0000000..6918168
Binary files /dev/null and b/const -- types/main.exe differ
diff --git a/new--keyword/main.cpp b/new--keyword/main.cpp
new file mode 100644
index 0000000..8c1f3c3
--- /dev/null
+++ b/new--keyword/main.cpp
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <string>
+
+using string = std::string;
+
+
+class Entity
+{
+  private :
+     string m_Name;
+  public :
+    Entity() : m_Name("Unknown"){}
+    Entity(const string& name) : m_Name(name) {}
+    
+    const string& GetName() const { return m_Name; }
+};
+
+
+int main()
+{
+
+    int a = 2;
+    int* b = new int [50]; // 200 bytes and returns a pointer 
+
+    Entity* e = new(b) Entity();//returns a void pointer and the aloocated to b memory adress
+    //Entity* e = (Entity*)malloc(sizeof(Entity));//malloc(50); and this returns a Entity pointer
+
+    //free (e);
+   
+   
+    delete e;//calls destructor and free funtion that "malloc"ed
+    delete[] b;
+
+//scope based pointing and ref counting for using it in advanced way!!
+
+    std::cin.get();
+}
+
+//This new is a heap allocated keyword which returns a pointer 
+//This can be applied to  classes, primitive types and also arrays
+//This memory allocated in heap contigously from the freeelist which have the memory adresses
+//we cannot take the malloc rather than new Entity(); cause this calls conatructor 
diff --git a/this--keyword/Log.cpp b/this--keyword/Log.cpp
new file mode 100644
index 0000000..7526c34
--- /dev/null
+++ b/this--keyword/Log.cpp
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <string>
+
+void PrintEntity(const Entity& e);//DECLARED
+
+class Entity
+{
+    public : 
+       int x, y;
+
+       Entity(int x, int y)
+       {
+           Entity* e = this;
+           
+          this->x = x;
+          this->y = y;
+
+          Entity& e = *this;
+
+          PrintEntity(*this);//pass the current instance of Entity class with  x, y!
+
+          //delete this; avoid this cause you are freeing memory from memeber funtion 
+       }
+
+       int GetX() const
+       {
+           const Entity& e = *this;
+       }
+};
+
+void PrintEntity(Entity* e)//DEFINED
+{
+    //PRINTING
+}
+
+int main()
+{
+    std::cin.get();
+}
+
+
+//supppose we want to call a method which is outside class from within entity class
\ No newline at end of file
diff --git a/this--keyword/main.cpp b/this--keyword/main.cpp
new file mode 100644
index 0000000..fb91c9f
--- /dev/null
+++ b/this--keyword/main.cpp
@@ -0,0 +1,40 @@
+//this keyword only applicable to member funtion[funtion in the class i.e, method!!]
+//this is a pointer to the current object instance!!
+//in order to call a method we need to instantiate the object!
+
+#include <iostream>
+#include <string>
+
+class Entity
+{
+    public : 
+       int x, y;
+
+       Entity(int x, int y)
+               //: x(x), y(y) we can use member initisaliser list! without it it cannot be differentiated;so we need to give reference to the class member varaible!!
+       {
+           Entity* e = this;//Entity pointer const and we cannot reassign the adrress
+           //Entity* const&  e = this; to assign it to a ref this is the way
+          // e->x = x; or
+          this->x = x;//or (* this).x = x;
+          this->y = y;
+       }
+
+       int GetX() const
+       {
+
+            //Entity* e =  this; not valid
+            const Entity* e = this; //in const funtion e->x = 5; cant be done :  this is const Entity * const 
+
+            return x;
+       }
+
+
+};
+
+int main()
+{
+    std::cin.get();
+}
+
+