Deleting Raw Pointers from Unique Pointers

Deleting a raw pointer obtained from the get() method of a std::unique_ptr is a dangerous operation that leads to undefined behavior. It's important to understand why this is problematic and how to avoid such situations.

Let's break this down with an example:

1#include <iostream>
2#include <memory>
3
4class Character {
5public:
6  Character(std::string name)
7    : name(std::move(name)) {
8    std::cout << "Creating " << name << '\n';
9  }
10
11  ~Character() {
12    std::cout << "Destroying " << name << '\n';
13  }
14
15private:
16  std::string name;
17};
18
19int main() {
20  auto frodo = std::make_unique<Character>("Frodo");
21
22  Character* rawPtr = frodo.get(); 
23  delete rawPtr;                   
24
25  // frodo still thinks it owns the object!
26}

If we were to run this code, here's what would happen:

1. The Character object "Frodo" is created and owned by the std::unique_ptr.
2. We get the raw pointer using get().
3. We delete the raw pointer, which destroys the Character object.
4. At the end of main(), frodo (the std::unique_ptr) goes out of scope and tries to delete the object again.

This results in a double deletion, which is undefined behavior. It could crash your program, corrupt memory, or seemingly do nothing while causing subtle bugs elsewhere.

Here's why this is dangerous:

1. Ownership Violation: std::unique_ptr is designed to have exclusive ownership of the object it points to. By deleting the raw pointer, we're violating this contract.
2. Double Deletion: The std::unique_ptr will try to delete the object again when it goes out of scope, leading to undefined behavior.
3. Dangling Pointer: After deleting the raw pointer, the std::unique_ptr becomes a dangling pointer, pointing to memory that has been freed.

To avoid these issues:

1. Never delete raw pointers obtained from get().
2. Use get() only when you need to pass the raw pointer to functions that expect a raw pointer, and ensure those functions don't delete the pointer.
3. If you need to transfer ownership, use std::move() instead:

1#include <iostream>
2#include <memory>
3
4class Character {
5public:
6  Character(std::string name)
7    : mName(std::move(name)) {
8    std::cout << "Creating " << mName << '\n';
9  }
10
11  ~Character() {
12    std::cout << "Destroying " << mName << '\n';
13  }
14
15private:
16  std::string mName;
17};
18
19void takeOwnership(std::unique_ptr<Character> ptr) {
20  // This function now owns the Character object
21  std::cout << "Taking ownership\n";
22}
23
24int main() {
25  auto FrodoPtr = std::make_unique<Character>("Frodo");
26  takeOwnership(std::move(FrodoPtr)); 
27
28  if (!FrodoPtr) {
29    std::cout << "FrodoPtr is now null";
30  }
31}

1Creating Frodo
2Taking ownership
3Destroying Frodo
4FrodoPtr is now null

In this safe version, we transfer ownership of the Character object to the takeOwnership function using std::move(). The std::unique_ptr in main() becomes null after the move, preventing any double deletion issues.

Remember, the whole point of std::unique_ptr is to manage the lifetime of dynamically allocated objects automatically. By manually deleting the raw pointer, we're defeating this purpose and introducing potential bugs. Stick to using the std::unique_ptr interface, and let it handle the deletion for you.