make_unique and make_shared

Learn safe creation with make_unique and make_shared.

make_unique and make_shared

std::make_unique and std::make_shared are the safe way to create smart pointers. Instead of using new you use these: auto p = std::make_unique<int>(42); or auto p = std::make_shared<int>(42);.

These functions provide exception safety. Using make_unique instead of writing std::unique_ptr<int> p(new int(42)) prevents a memory leak if an exception occurs. Also make_shared allocates the object and the reference count in a single block; this is more efficient. Modern C++ avoids using new directly; the make_* functions are preferred.

Efficiency and safety

make_shared allocates the object and the control block (reference count) in a single memory block. This is more efficient than two separate new calls; it saves both memory and speed.

make_unique has the same cost as new but provides exception safety. Example: in a call f(std::unique_ptr<int>(new int(42)), g()) if g() throws, new int(42) leaks. Using f(std::make_unique<int>(42), g()) removes this risk. That is why make_* is always preferred.

Exercise Use make_unique and make_shared

Create a unique_ptr with auto p1 = std::make_unique<int>(7); and a shared_ptr with auto p2 = std::make_shared<int>(14);. Print both values with std::cout separated by a space: *p1 and *p2.

Show example solution

#include <iostream>
#include <memory>

int main() {
    auto p1 = std::make_unique<int>(7);
    auto p2 = std::make_shared<int>(14);
    std::cout << *p1 << " " << *p2;
    return 0;
}

Test yourself

Complete the make_unique call

auto p = std::____<int>(42);

Show answer

auto p = std::make_unique<int>(42);

What advantage does make_unique have over new?
```
// these two usages give the same result but
// make_unique is safer
```
- Less memory usage
- Faster execution
- Exception safety
- Creates larger objects
Show answer

Exception safety — make_unique prevents memory leaks on exception.
Match each function to its purpose

std::make_unique

Exclusive safe
std::make_shared

Shared safe
new int(42)

Direct allocation
Single memory block

make_shared benefit

Next lesson: RAII

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies