Using std::unique_ptr as a Class Member

Using std::unique_ptr as a member of a class is a way to ensure that the class manages the lifetime of the pointed-to resource. When the class instance is destroyed, the unique_ptr member will automatically clean up the resource it manages.

Here's an example of a class Wizard that has a unique_ptr member which manages a Wand resource:

1#include <memory>
2#include <iostream>
3
4class Wand {
5public:
6  Wand() { std::cout << "Wand created.\n"; }
7  ~Wand() { std::cout << "Wand destroyed.\n"; }
8};
9
10class Wizard {
11private:
12  std::unique_ptr<Wand> wand_;
13
14public:
15  Wizard() : wand_{std::make_unique<Wand>()} {}
16
17  void CastSpell() {
18    if (wand_) {
19      std::cout << "Casting spell!\n";
20    } else {
21      std::cout << "I have no wand!\n";
22    }
23  }
24};
25
26int main() {
27  Wizard gandalf;
28  gandalf.CastSpell();
29}

1Wand created.
2Casting spell!
3Wand destroyed.

In this example, the Wizard class has a unique_ptr<Wand> member. When a Wizard instance is created, it creates a new Wand instance and stores it in the unique_ptr member.

When the Wizard instance goes out of scope (in this case, at the end of main), the Wizard destructor is called. Although we haven't explicitly defined a destructor for Wizard, the compiler provides a default destructor that will call the destructors of all the class's members - including the destructor of wand_, which in turn will delete the Wand instance.

This pattern of using unique_ptr as a class member is useful for implementing composition relationships, where one class is responsible for the lifetime of instances of another class.

Some key points to remember when using unique_ptr as a class member:

1. If you define a custom destructor for your class, you don't need to explicitly delete the unique_ptr member - it will clean up its managed resource automatically.
2. If you define custom copy/move constructors or copy/move assignment operators for your class, you need to decide how you want to handle the unique_ptr member. Often, it makes sense to prohibit copying and only allow moving, which can be achieved by deleting the copy constructor and copy assignment operator.
3. Access the managed resource through the unique_ptr member using or >, just like you would with a normal pointer.
4. Check if the unique_ptr member is managing a resource before trying to use it, as attempting to dereference an empty unique_ptr will cause undefined behavior.

Using unique_ptr as a class member is a key part of implementing RAII (Resource Acquisition Is Initialization) in C++, which is a powerful technique for managing resources and avoiding leaks.