Normal Pointers
In C++ or similar languages, a normal pointer is a simple variable that stores the memory address of another variable.

Example:
cpp
Copy code
int* ptr = new int(10); // ptr points to a dynamically allocated integer with value 10

While this is simple, there are some issues:

Manual Memory Management: You must manually deallocate the memory.
Memory Leaks: If you forget to delete it, you’ll leak memory.
Dangling Pointers: If the memory is deleted but the pointer is not reset, you may access invalid memory, causing undefined behavior.

Example Problem (Memory Leak):
cpp
Copy code
int* ptr = new int(10);
// Forgetting to delete


Smart Pointers
Smart pointers handle memory automatically. They automatically deallocate memory when it's no longer needed, helping you avoid
common pitfalls like memory leaks and dangling pointers.

C++ provides three main smart pointers in the <memory> library:

std::unique_ptr
std::shared_ptr
std::weak_ptr

When and Why to Use Smart Pointers
std::unique_ptr: For exclusive ownership

Use when you need a pointer that owns a resource exclusively, meaning only one pointer can manage the resource.
Automatically deletes the resource when the pointer goes out of scope.
Why: Ensures no other pointer can access the memory, making ownership clear and avoiding memory leaks.

    Example:
cpp
Copy code
#include <memory>
std::unique_ptr<int> ptr = std::make_unique<int>(10);  // A unique pointer to an integer with value 10
// No need to call delete, memory will be released automatically when 'ptr' goes out of scope

If you try to copy a unique_ptr, you'll get an error since it's designed for exclusive ownership:

cpp
Copy code
std::unique_ptr<int> ptr2 = ptr;  // Error, cannot copy unique_ptr
std::shared_ptr: For shared ownership

Use when you need multiple pointers to share ownership of a resource.
It maintains a reference count that tracks how many pointers are referring to the resource.
Why: When the last shared_ptr goes out of scope, it automatically deletes the resource. This is useful for shared resources (e.g., trees, graphs).

Example:
cpp
Copy code
#include <memory>
std::shared_ptr<int> ptr1 = std::make_shared<int>(10);  // A shared pointer
std::shared_ptr<int> ptr2 = ptr1;  // Now both ptr1 and ptr2 share ownership

Both ptr1 and ptr2 point to the same memory, and it will only be freed when both go out of scope.

std::weak_ptr: For non-owning references to shared resources

Use when you need a pointer that references a shared_ptr without affecting its reference count.
Why: Prevents circular references (e.g., in data structures like doubly linked lists) where two shared_ptrs point to each other, creating a memory leak even though they should have been deleted.

    Example:
cpp
Copy code
#include <memory>
std::shared_ptr<int> shared = std::make_shared<int>(10);
std::weak_ptr<int> weak = shared;  // weak_ptr doesn't increase the reference count


When to Use Smart Pointers vs. Normal Pointers
Use normal pointers when:
You need simple, non-owning references to resources, and you handle memory management yourself.
In performance-critical parts where memory overhead from smart pointers may be too high (though this is rare).

    Use smart pointers when:
You want automatic memory management.
You need to ensure resources are freed properly, and you want to avoid manual delete operations.
You want ownership semantics (like exclusive or shared ownership) to be clear and enforced.

    Summary:
Smart pointers automate memory management and avoid common errors like memory leaks and dangling pointers.
Normal pointers give more control but require careful manual management.
Let me know if you'd like any additional examples or clarifications!