Smart Pointers vs Raw Pointers

Smart pointers and raw pointers are both tools for managing memory in C++, but they have some key differences in terms of functionality and usage. Let's break down each type and discuss when to use them.

Raw Pointers

Raw pointers are the traditional C-style pointers. They're simple and lightweight, but they require manual memory management.

1#include <iostream>
2
3class Weapon {
4 public:
5  Weapon(std::string name)
6  : mName{std::move(name)} {}
7  ~Weapon() {
8    std::cout << mName << " destroyed\n";
9  }
10  std::string mName;
11};
12
13int main() {
14  Weapon* sword = new Weapon("Excalibur");
15  // Use sword...
16  delete sword;  // Remember to delete!
17}

Raw pointers don't automatically free memory when they go out of scope, which can lead to memory leaks if not managed carefully.

Smart Pointers

Smart pointers, introduced in C++11, are objects that act like pointers but provide additional features, most notably automatic memory management. The two main types are std::unique_ptr and std::shared_ptr.

std::unique_ptr

std::unique_ptr is for exclusive ownership. Only one unique_ptr can own an object at a time.

1#include <iostream>
2#include <memory>
3
4class Weapon {
5 public:
6  Weapon(std::string name)
7  : mName{std::move(name)} {}
8  ~Weapon() {
9    std::cout << mName << " destroyed\n";
10  }
11  std::string mName;
12};
13
14int main() {
15  std::unique_ptr<Weapon> sword{
16    std::make_unique<Weapon>("Excalibur")};
17  // Use sword...
18}  // sword is automatically deleted here

1Excalibur destroyed

std::shared_ptr

std::shared_ptr allows multiple pointers to share ownership of an object. The object is deleted when the last shared_ptr is destroyed.

1#include <iostream>
2#include <memory>
3
4class Character {
5 public:
6  Character(std::string name)
7  : mName{std::move(name)} {}
8  ~Character() {
9    std::cout << mName << " destroyed\n";
10  }
11  std::string mName;
12};
13
14int main() {
15  std::shared_ptr<Character> hero1{
16    std::make_shared<Character>("Anna")};
17  {
18    // Shared ownership
19    std::shared_ptr<Character> hero2 = hero1;
20    std::cout << "Heroes: " << hero1->mName
21      << " and " << hero2->mName << "\n";
22
23    // hero2 goes out of scope, but object
24    // isn't deleted yet
25  }
26
27  std::cout << "Hero 1 still alive\n";
28}
29// hero1 goes out of scope, Character
30// object is deleted

1Heroes: Anna and Anna
2Hero 1 still alive
3Anna destroyed

When to Use Each

Use raw pointers when:

• You're working with legacy code or APIs that require raw pointers
• You need to pass a non-owning pointer (consider std::weak_ptr for shared_ptr objects)
• You're implementing low-level data structures or when performance is absolutely critical

Use smart pointers when:

• You want automatic memory management to prevent leaks
• You're designing new code and have control over the ownership model
• You need shared ownership (std::shared_ptr) or exclusive ownership (std::unique_ptr)

In modern C++, it's generally recommended to prefer smart pointers over raw pointers for most scenarios. They provide safety and convenience without significant performance overhead. However, understanding raw pointers is still crucial for working with existing codebases and certain low-level operations.