focuses on scopedptr class and its lifetimes

Object Lifetime-(stack $ scope lifetimes)/Log.cpp

@@ -0,0 +1,54 @@
+#include <iostream>
+#include <string>
+
+class Entity
+{
+    public  :
+       Entity()
+       {
+          std::cout << "Created Entity!" << std::endl;
+       } 
+
+      ~Entity()
+      {
+          std::cout << "Destroyed Entity!" << std::endl;
+      } 
+};
+
+class ScopedPtr
+{
+    private :
+     Entity* m_Ptr;
+    public :
+       ScopedPtr(Entity* Ptr)
+           : m_Ptr(Ptr)
+           {
+           }
+
+       ~ScopedPtr()
+       {
+            delete m_Ptr;
+       }    
+
+};
+
+
+
+
+int main()
+{    
+
+
+    {
+
+    ScopedPtr e = new Entity();//we can also write it in constructor way and it is implicit conversion
+      Entity* e = new Entity(); //upper code allocated on heap and get destroyed after the scope ends ,scopedptr object allocated on stack!
+    }
+
+
+    std::cin.get();
+}
+
+
+//  we can write unq ptr which is a scoped ptr but now lets write in a simple class
+//  timer class for benchmarking  and mutex locking[multiple threads cant access at sametime locks and unlocks after ] are  examples of this type of using scopedptrs'

Object Lifetime-(stack $ scope lifetimes)/main.cpp

@@ -0,0 +1,49 @@
+#include <iostream>
+#include <string>
+
+class Entity
+{
+    public  :
+       Entity()
+       {
+          std::cout << "Created Entity!" << std::endl;
+       } 
+
+      ~Entity()
+      {
+          std::cout << "Destroyed Entity!" << std::endl;
+      } 
+};
+
+int* CreateArray(int* array)
+{
+
+      int* array = new int[50];//Heap allocation 
+     //int array[50];//stack allocated
+     return array;//returning ptr in stack memory
+}
+
+int main()
+{    
+
+int array[50];//copying memory    
+int* a = CreateArray(array);
+
+    {
+        //Entity e;
+
+      Entity* e = new Entity();  
+    }
+
+
+    std::cin.get();
+}
+
+
+
+//   {} THIS IS A SCOPE!! WE HAVE SCOPES FOR CLASSES,EMPTY CLASSES AND FOR IF STATEMENTS!
+//   JUST DEBUG THE CODE AND VERIFY EACH LINE
+//   WHILE STACK OR SCOPE ALLOCATION AFTER SCOPE ENDS IT DOES DESTROYS ENTITY
+//   WHILE HEAP ALLOCATION IT DOES LIVES EVEN AFTER SCOPE ENDS
+//   BY USING "Scoped ptr" OR SCOPE CLASSES AND UNQ PTR WHICH IS A SMART POINTER WE CAN ALLOCATE ON HEAP AND AUTO DELETE THE MEMORY AFTER SCOPE ENDS
+//   A CLASS THATS A WRAPPER OVER A POINTER WHICH UPON CONSTRUCTION HEAP ALLOCATES THE POINTER AND THEN UPON DESTRUCTION DELETES THE POINTER

this--keyword/main.cpp

@@ -38,3 +38,4 @@ int main()
 }
 
 
+//IN Const methods this is a const entity constant pointer!!