Best Practices for Managing Object Lifetimes

1#include <memory>
2#include <fstream>
3
4class FileHandler {
5  std::unique_ptr<std::fstream> file;
6
7public:
8  FileHandler(const std::string& filename)
9    : file{std::make_unique<std::fstream>(
10      filename
11    )} {}
12
13  // File is automatically closed when FileHandler
14  // is destroyed
15};
16
17void processFile(const std::string& filename) {
18  FileHandler handler{filename};
19  // Use handler...
20} // File is closed when handler goes out of scope

1void processLargeObject() {
2  BigObject obj;  // Stack-allocated
3  // Use obj...
4}  // obj is automatically destroyed here

1#include <memory>
2
3void processData() {
4  auto data = std::make_unique<LargeData>();
5  // Use data...
6}  // data is automatically deleted

1#include <memory>
2
3class Node {
4  std::shared_ptr<Node> next;
5
6  // Prevents circular reference
7  std::weak_ptr<Node> prev;
8
9public:
10  void setNext(std::shared_ptr<Node> n){
11    next = std::move(n);
12  }
13
14  void setPrev(std::shared_ptr<Node> p){
15    prev = p;
16  }
17};

1std::unique_ptr<BigObject> createObject() {
2  return std::make_unique<BigObject>();
3}
4
5void useObject() {
6  // Ownership is moved, not copied
7  auto obj = createObject();
8  // Use obj...
9}

1class Engine; // Forward declaration
2
3class Car {
4  // Car owns Engine
5  std::unique_ptr<Engine> engine;
6
7public:
8  Car() : engine{std::make_unique<Engine>()}{}
9};

1#include <memory>
2
3class ComplexObject {
4  // Private constructor
5  ComplexObject() = default;
6
7public:
8  static std::unique_ptr<ComplexObject>
9  create(){
10    auto obj =
11      std::unique_ptr<ComplexObject>(
12        new ComplexObject());
13
14    // Complex initialization...
15    return obj;
16  }
17};