Smart Pointers and Modern C++

# CHAPTER 25

Smart Pointers and Modern C++ #

1. Introduction #

2. Learning Objectives #

• Explain why raw pointers (*) are dangerous.

• Use std::uniqueptr for exclusive ownership.

• Use std::sharedptr for shared ownership.

• Understand std::weakptr and cyclic references.

• Safely allocate memory using std::makeunique.

3. The Problem with Raw Pointers #

void doWork() {
    int* ptr = new int(10);
    
    if (someConditionFails()) {
        throw runtime_error("Error!"); // We jump out here...
    }
    
    delete ptr; // ...this is NEVER reached. Memory Leak!
}

4. std::uniqueptr (Exclusive Ownership) #

*(Requires #include <memory>)*

#include <iostream>
#include <memory>
using namespace std;

class Player {
  public:
    Player() { cout << "Player created\n"; }
    ~Player() { cout << "Player destroyed\n"; } // Proof it deletes!
    void play() { cout << "Playing game...\n"; }
};

int main() {
    { // Create a scope
        // Create a unique_ptr using make_unique (Best Practice!)
        unique_ptr<Player> p1 = make_unique<Player>();
        
        p1->play(); // Use it exactly like a normal pointer
        
        // unique_ptr<Player> p2 = p1; // ERROR! Cannot copy a unique_ptr!
        
    } // SCOPE ENDS: p1 is destroyed, and it AUTOMATICALLY deletes the Player!
    
    cout << "Program ends\n";
    return 0;
}

5. std::sharedptr (Shared Ownership) #

int main() {
    shared_ptr<int> s1 = make_shared<int>(100);
    cout << "Count: " << s1.use_count() << endl; // Prints 1
    
    {
        shared_ptr<int> s2 = s1; // Allowed! Both point to 100.
        cout << "Count: " << s1.use_count() << endl; // Prints 2
    } // s2 goes out of scope. Count drops to 1.
    
    cout << "Count: " << s1.use_count() << endl; // Prints 1
    
    return 0;
} // s1 goes out of scope. Count drops to 0. Memory is DELETED!

6. std::weakptr (Breaking Cycles) #

• Why use it? To prevent Cyclic References. If Object A has a sharedptr to Object B, and Object B has a sharedptr to Object A, their reference counts will never reach 0. They will keep each other alive forever (Memory Leak!). Using a weakptr for one of those links solves this.

7. Modern C++ Best Practices #

• Rule #1: Never use new or delete in modern C++ applications.

• Rule #2: Default to std::uniqueptr for everything.

• Rule #3: Only upgrade to std::sharedptr if you explicitly need shared ownership.

8. Memory-Level Explanation #

9. Common Mistakes #

• Mixing raw pointers with smart pointers: int* raw = new int(5); uniqueptr<int> p(raw); This is dangerous if someone else deletes raw manually. Always use makeunique or makeshared.

• Copying a uniqueptr: The compiler will prevent this. If you must transfer ownership, you must use std::move(ptr).

10. Exercises #

1. 1. Write a program using a std::uniqueptr to an array of 5 integers.

1. 2. Demonstrate how a std::sharedptr tracks its reference count by printing .usecount() before and after a new scope block { }.

Q10. Is C++ natively garbage-collected like Java or C#? a) Yes b) No, it uses determinism (RAII) and smart pointers instead Answer: b) No, it uses determinism (RAII) and smart pointers instead

12. Interview Questions #

• Q: Explain RAII (Resource Acquisition Is Initialization) in C++ and how smart pointers utilize it.

• Q: Describe a scenario where a cyclic reference causes a memory leak with sharedptr, and how to fix it.

• Q: Why is std::makeshared preferred over std::sharedptr<T>(new T())? (Hint: Performance and single memory allocation).

14. Next Chapter Recommendation #