cpp
smart pointers
01_smart_pointers.cpp⚙️cpp
/**
* ============================================================
* C++ SMART POINTERS
* ============================================================
*
* This file covers:
* - unique_ptr
* - shared_ptr
* - weak_ptr
* - make_unique and make_shared
* - Custom deleters
*
* Compile: g++ -std=c++17 -Wall 01_smart_pointers.cpp -o smart_pointers
* Run: ./smart_pointers
*
* ============================================================
*/
#include <iostream>
#include <memory>
#include <vector>
#include <string>
using namespace std;
// Demo class for demonstrations
class Resource {
private:
string name;
int id;
static int nextId;
public:
Resource(const string& n = "Unnamed") : name(n), id(nextId++) {
cout << " [+] Resource " << id << " (" << name << ") created" << endl;
}
~Resource() {
cout << " [-] Resource " << id << " (" << name << ") destroyed" << endl;
}
void use() const {
cout << " [*] Using Resource " << id << " (" << name << ")" << endl;
}
string getName() const { return name; }
int getId() const { return id; }
};
int Resource::nextId = 1;
// Forward declaration for circular reference demo
class Node;
int main() {
cout << "============================================" << endl;
cout << " C++ SMART POINTERS" << endl;
cout << "============================================" << endl << endl;
// ========================================================
// PART 1: WHY SMART POINTERS?
// ========================================================
cout << "--- PART 1: WHY SMART POINTERS? ---" << endl << endl;
/*
* Smart pointers automatically manage memory:
* - No manual delete needed
* - Exception safe
* - Clear ownership semantics
* - Prevent memory leaks and dangling pointers
*
* Three types in C++11:
* 1. unique_ptr - Exclusive ownership
* 2. shared_ptr - Shared ownership
* 3. weak_ptr - Non-owning observer
*/
cout << "Problems with raw pointers:" << endl;
cout << "• Forget to delete → memory leak" << endl;
cout << "• Delete twice → undefined behavior" << endl;
cout << "• Exception before delete → leak" << endl;
cout << "• Unclear ownership → confusion" << endl;
cout << endl;
cout << "Smart pointers solve these problems!" << endl;
cout << endl;
// ========================================================
// PART 2: unique_ptr
// ========================================================
cout << "--- PART 2: unique_ptr (Exclusive Ownership) ---" << endl << endl;
/*
* unique_ptr:
* - Only ONE pointer can own the resource
* - Cannot be copied (only moved)
* - Automatically deletes when it goes out of scope
* - Zero overhead compared to raw pointer
*/
cout << "Creating unique_ptr:" << endl;
{
// Method 1: Direct construction (older style)
unique_ptr<Resource> ptr1(new Resource("First"));
// Method 2: make_unique (preferred, C++14)
auto ptr2 = make_unique<Resource>("Second");
ptr1->use();
ptr2->use();
cout << "\nptr1 owns: " << (ptr1 ? ptr1->getName() : "nothing") << endl;
cout << "ptr2 owns: " << (ptr2 ? ptr2->getName() : "nothing") << endl;
// Cannot copy unique_ptr
// unique_ptr<Resource> ptr3 = ptr1; // ERROR!
// Can move unique_ptr
cout << "\nMoving ptr1 to ptr3:" << endl;
unique_ptr<Resource> ptr3 = move(ptr1); // Transfer ownership
cout << "ptr1 owns: " << (ptr1 ? ptr1->getName() : "nothing") << endl;
cout << "ptr3 owns: " << (ptr3 ? ptr3->getName() : "nothing") << endl;
// Release ownership (returns raw pointer, you're responsible)
cout << "\nReleasing ptr3:" << endl;
Resource* raw = ptr3.release();
cout << "ptr3 owns: " << (ptr3 ? ptr3->getName() : "nothing") << endl;
delete raw; // Manual delete needed after release!
// Reset (delete current and optionally take new)
cout << "\nResetting ptr2:" << endl;
ptr2.reset(); // Deletes "Second"
ptr2.reset(new Resource("New Second"));
cout << "\nScope ending, automatic cleanup:" << endl;
} // ptr2 automatically deleted here
cout << endl;
// ========================================================
// PART 3: unique_ptr WITH ARRAYS
// ========================================================
cout << "--- PART 3: unique_ptr WITH ARRAYS ---" << endl << endl;
{
// unique_ptr for arrays
auto arr = make_unique<int[]>(5);
for (int i = 0; i < 5; i++) {
arr[i] = (i + 1) * 10;
}
cout << "Array via unique_ptr: ";
for (int i = 0; i < 5; i++) {
cout << arr[i] << " ";
}
cout << endl;
// Automatically calls delete[] when scope ends
}
cout << "\n💡 For dynamic arrays, prefer std::vector!" << endl;
cout << endl;
// ========================================================
// PART 4: shared_ptr
// ========================================================
cout << "--- PART 4: shared_ptr (Shared Ownership) ---" << endl << endl;
/*
* shared_ptr:
* - Multiple pointers can share ownership
* - Uses reference counting
* - Deleted when last shared_ptr is destroyed
* - Slight overhead (reference count)
*/
cout << "Creating shared_ptr:" << endl;
{
// Method 1: Direct (not recommended)
shared_ptr<Resource> sp1(new Resource("Shared1"));
// Method 2: make_shared (preferred)
auto sp2 = make_shared<Resource>("Shared2");
cout << "sp1 use_count: " << sp1.use_count() << endl;
cout << "sp2 use_count: " << sp2.use_count() << endl;
// Copy shared_ptr (increases reference count)
cout << "\nCopying sp2 to sp3:" << endl;
shared_ptr<Resource> sp3 = sp2;
cout << "sp2 use_count: " << sp2.use_count() << endl;
cout << "sp3 use_count: " << sp3.use_count() << endl;
{
cout << "\nCreating sp4 (copy of sp2) in inner scope:" << endl;
shared_ptr<Resource> sp4 = sp2;
cout << "sp2 use_count: " << sp2.use_count() << endl;
}
cout << "After inner scope, sp2 use_count: " << sp2.use_count() << endl;
// Reset one pointer
cout << "\nResetting sp3:" << endl;
sp3.reset();
cout << "sp2 use_count: " << sp2.use_count() << endl;
cout << "\nScope ending:" << endl;
}
cout << endl;
// ========================================================
// PART 5: weak_ptr
// ========================================================
cout << "--- PART 5: weak_ptr (Non-owning Observer) ---" << endl << endl;
/*
* weak_ptr:
* - Does NOT own the resource
* - Does NOT affect reference count
* - Used to break circular references
* - Must lock() to access (returns shared_ptr)
*/
weak_ptr<Resource> weakPtr;
{
cout << "Creating shared_ptr:" << endl;
auto sharedPtr = make_shared<Resource>("Observable");
weakPtr = sharedPtr; // weak_ptr observes
cout << "shared_ptr use_count: " << sharedPtr.use_count() << endl;
cout << "weak_ptr expired: " << boolalpha << weakPtr.expired() << endl;
// Access through weak_ptr
if (auto locked = weakPtr.lock()) {
cout << "Locked weak_ptr, using: ";
locked->use();
cout << "use_count during lock: " << sharedPtr.use_count() << endl;
}
cout << "\nShared_ptr going out of scope:" << endl;
}
cout << "After shared_ptr destroyed:" << endl;
cout << "weak_ptr expired: " << weakPtr.expired() << endl;
if (auto locked = weakPtr.lock()) {
locked->use(); // Won't execute
} else {
cout << "Cannot lock - resource is gone" << endl;
}
cout << noboolalpha << endl;
// ========================================================
// PART 6: CIRCULAR REFERENCE PROBLEM
// ========================================================
cout << "--- PART 6: CIRCULAR REFERENCES ---" << endl << endl;
/*
* Problem: Two shared_ptrs pointing to each other
* Result: Memory leak (neither ever deleted)
* Solution: Use weak_ptr for back-references
*/
cout << "Circular reference causes memory leak:" << endl;
cout << " struct Node {" << endl;
cout << " shared_ptr<Node> next;" << endl;
cout << " shared_ptr<Node> prev; // ← Problem!" << endl;
cout << " };" << endl;
cout << endl;
cout << "Solution - use weak_ptr:" << endl;
cout << " struct Node {" << endl;
cout << " shared_ptr<Node> next;" << endl;
cout << " weak_ptr<Node> prev; // ← Fixed!" << endl;
cout << " };" << endl;
cout << endl;
// ========================================================
// PART 7: make_unique AND make_shared
// ========================================================
cout << "--- PART 7: make_unique & make_shared ---" << endl << endl;
cout << "Why use make_unique/make_shared?" << endl;
cout << "─────────────────────────────────────────" << endl;
cout << "1. Exception safety" << endl;
cout << " // Problem:" << endl;
cout << " func(shared_ptr<T>(new T), mayThrow());" << endl;
cout << " // If mayThrow() throws, new T might leak!" << endl;
cout << endl;
cout << " // Solution:" << endl;
cout << " func(make_shared<T>(), mayThrow());" << endl;
cout << " // Safe: make_shared is one operation" << endl;
cout << endl;
cout << "2. Efficiency (make_shared)" << endl;
cout << " // One allocation for object + control block" << endl;
cout << endl;
cout << "3. Cleaner syntax" << endl;
cout << " auto p = make_unique<MyClass>(args...);" << endl;
cout << endl;
// ========================================================
// PART 8: CUSTOM DELETERS
// ========================================================
cout << "--- PART 8: CUSTOM DELETERS ---" << endl << endl;
cout << "Custom deleter for unique_ptr:" << endl;
{
auto deleter = [](Resource* ptr) {
cout << " Custom deleter called!" << endl;
delete ptr;
};
unique_ptr<Resource, decltype(deleter)> ptr(new Resource("Custom"), deleter);
ptr->use();
cout << "Scope ending..." << endl;
}
cout << "\nCustom deleter for shared_ptr:" << endl;
{
auto ptr = shared_ptr<Resource>(
new Resource("SharedCustom"),
[](Resource* p) {
cout << " Custom shared_ptr deleter!" << endl;
delete p;
}
);
ptr->use();
cout << "Scope ending..." << endl;
}
cout << "\n💡 Useful for: file handles, C APIs, etc." << endl;
cout << endl;
// ========================================================
// PART 9: SMART POINTERS IN CONTAINERS
// ========================================================
cout << "--- PART 9: SMART POINTERS IN CONTAINERS ---" << endl << endl;
cout << "Creating vector of shared_ptr:" << endl;
{
vector<shared_ptr<Resource>> resources;
resources.push_back(make_shared<Resource>("Vec1"));
resources.push_back(make_shared<Resource>("Vec2"));
resources.push_back(make_shared<Resource>("Vec3"));
cout << "\nUsing all resources:" << endl;
for (const auto& r : resources) {
r->use();
}
cout << "\nRemoving first element:" << endl;
resources.erase(resources.begin());
cout << "\nRemaining count: " << resources.size() << endl;
cout << "\nClearing vector:" << endl;
resources.clear();
}
cout << endl;
// ========================================================
// PART 10: SUMMARY AND GUIDELINES
// ========================================================
cout << "--- PART 10: SUMMARY ---" << endl << endl;
cout << "When to use each smart pointer:" << endl;
cout << "─────────────────────────────────────────" << endl;
cout << "unique_ptr:" << endl;
cout << " • Exclusive ownership" << endl;
cout << " • Factory functions returning new objects" << endl;
cout << " • Members of classes (PIMPL idiom)" << endl;
cout << endl;
cout << "shared_ptr:" << endl;
cout << " • Shared ownership needed" << endl;
cout << " • Objects in multiple data structures" << endl;
cout << " • When ownership is truly shared" << endl;
cout << endl;
cout << "weak_ptr:" << endl;
cout << " • Breaking circular references" << endl;
cout << " • Caching (check if object still exists)" << endl;
cout << " • Observer pattern" << endl;
cout << "\nGuidelines:" << endl;
cout << "─────────────────────────────────────────" << endl;
cout << "• Use unique_ptr by default" << endl;
cout << "• Use make_unique/make_shared" << endl;
cout << "• Pass by reference, not by smart pointer" << endl;
cout << "• Pass unique_ptr to transfer ownership" << endl;
cout << "• Return smart pointers from factories" << endl;
cout << endl;
cout << "============================================" << endl;
cout << "SMART POINTERS SUMMARY:" << endl;
cout << "============================================" << endl;
cout << "• unique_ptr: single owner, zero overhead" << endl;
cout << "• shared_ptr: multiple owners, ref counted" << endl;
cout << "• weak_ptr: observer, breaks cycles" << endl;
cout << "• Use make_unique/make_shared" << endl;
cout << "• Prefer unique_ptr by default" << endl;
cout << "============================================" << endl;
return 0;
}
// ============================================================
// EXERCISES:
// ============================================================
/*
* 1. Create a simple linked list using shared_ptr for next
* and weak_ptr for prev (doubly linked, no circular leak)
*
* 2. Implement a simple cache class using weak_ptr:
* - Store weak_ptrs to objects
* - Return shared_ptr if object exists, null otherwise
*
* 3. Create a factory function that returns unique_ptr to
* derived classes based on a parameter
*
* 4. Implement the PIMPL idiom using unique_ptr
*
* 5. Create a custom deleter for a file handle (FILE*)
* that calls fclose()
*/