Why Smart Pointers Replace Raw new delete
Understand RAII and why owning raw pointers is rarely correct in modern C++.
Why Smart Pointers Replace Raw new delete is a free C++ Academy lesson on CoddyKit. This is lesson 1 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the C++ Academy learning path, and your progress syncs across the web and the CoddyKit app. The C++ Academy course includes 4 lessons in total.
Raw new and delete
The C inheritance: new T allocates a T on the heap; delete frees it. You must match every new with exactly one delete — or leak (or crash).
Widget* w = new Widget();
// ... use w ...
delete w; // forget this and you leakWhat Goes Wrong
Common failures:
- Forgotten
delete— memory leak - Double
delete— undefined behavior - Exception thrown between
newanddelete— leak - Returning a raw pointer with unclear ownership
RAII to the Rescue
Resource Acquisition Is Initialization: tie the lifetime of a resource to the lifetime of a stack object. The destructor releases the resource — even if an exception is thrown.
The Smart Pointer Idea
A smart pointer is a small RAII wrapper around a raw pointer. Its destructor calls delete. You never forget to free.
The Three Smart Pointers
Standard library smart pointers in <memory>:
std::unique_ptr<T>— exclusive ownershipstd::shared_ptr<T>— shared ownership with ref countingstd::weak_ptr<T>— non-owning observer of a shared_ptr
Smart Pointers Are Cheap
unique_ptr is zero overhead (same size and speed as a raw pointer). shared_ptr has a small atomic ref count cost.
No More Manual Delete
With smart pointers, you almost never write delete. The destructor takes care of it.
#include <memory>
std::unique_ptr<Widget> w = std::make_unique<Widget>();
// no delete needed — when w goes out of scope, Widget is destroyedSmart Pointers and Exceptions
If an exception is thrown mid-function, locals are destroyed in reverse order. Smart pointers release their resources automatically — raw pointers leak.
Ownership in the Type
The smart pointer type now encodes ownership. Reading a function signature tells you who owns the object.
// I take ownership
void consume(std::unique_ptr<Widget> w);
// I look but do not own
void inspect(const Widget& w);Raw Pointers Still Exist
Use raw pointers (or references) for non-owning access. They communicate "I am borrowing, not owning."
Replacing new with make Functions
Prefer std::make_unique (C++14) and std::make_shared (C++11). They are exception safe and slightly more efficient than calling new directly.
auto w = std::make_unique<Widget>(42);
auto s = std::make_shared<Resource>("file.txt");Quick Check
What is the main reason to use std::unique_ptr instead of a raw new/delete pair?
Recap
Raw new/delete is error prone. Smart pointers wrap heap-allocated objects in RAII handles that release automatically. Prefer std::make_unique and std::make_shared for safety and performance.
Learn C++ with an AI tutor — free
Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.
- Courses
- 51
- Lessons
- 203
Frequently Asked Questions
Is the “Why Smart Pointers Replace Raw new delete” lesson free?
Yes — any 3 lessons of the C++ Academy learning path, including “Why Smart Pointers Replace Raw new delete”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The C++ Academy course includes 4 lessons in total.
What will I learn in “Why Smart Pointers Replace Raw new delete”?
Understand RAII and why owning raw pointers is rarely correct in modern C++. You practise C++ Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start C++ Academy?
No prior experience is required. C++ Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 1 of 4.
How long does the “Why Smart Pointers Replace Raw new delete” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this C++ Academy lesson?
Yes. Every C++ Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- Why Smart Pointers Replace Raw new delete
- unique_ptr Exclusive Ownership
- shared_ptr and weak_ptr Shared Ownership
- Custom Deleters and Make Functions