C++智能指针 - 实践

C++智能指针学习

01.理解智能指针

#include <iostream>
  #include "MyObject.h"
  using namespace std;
  //
  void memory_leak_example(bool condition) {
  std::cout <<
  "\n--- Running Memory Leak Example ---" << std::endl;
  MyObject* ptr = new MyObject(1);
  // 在堆上创建对象
  /* 此处会出现内存泄露，即为 new 的指针不会被释放
  if (condition) {
  std::cout << "Condition is true, returning early..." << std::endl;
  // 如果在这里返回，下面的 delete 将永远不会被执行
  return;
  }*/
  ptr->
  pointer_example();
  delete ptr;
  // 只有当 condition 为 false 时，这里才会被执行
  std::cout <<
  "--- Memory Leak Example Finished ---\n" << std::endl;
  }
  int main() {
  // 场景 A: 发生内存泄漏
  memory_leak_example(true);
  std::cout <<
  "After memory_leak_example(true), the object was never destroyed." << std::endl;
  // 场景 B: 没有发生内存泄漏 (只是为了对比)
  memory_leak_example(false);
  return 0;
  }

02.unique_ptr

#include "MyObject.h"
#include <memory>
  // 必须包含这个头文件
  #include <vector>
    //智能指针无论从哪个路径退出，只要栈对象被销毁，自动释放内存
    void unique_ptr_basic_example(bool condition) {
    std::cout <<
    "\n--- Running unique_ptr Basic Example ---" << std::endl;
    // 推荐用法：使用 std::make_unique 创建对象并由 unique_ptr 管理
    // 这行代码做了两件事：1. new MyObject(3) 2. 创建一个 unique_ptr 指向它
    auto ptr = std::make_unique<MyObject >
      (3);
      if (condition) {
      std::cout <<
      "Condition is true, returning early..." << std::endl;
      // 当函数在这里返回时，ptr 会离开作用域
      // 它的析构函数会被自动调用，从而 delete 其管理的对象
      return;
      }
      ptr->
      do_something();
      std::cout <<
      "No need to manually call delete!" << std::endl;
      // 函数结束，ptr 离开作用域，自动 delete 对象
      }
      int main() {
      // 无论 condition 是 true 还是 false，内存都会被正确释放！
      unique_ptr_basic_example(true);
      unique_ptr_basic_example(false);
      return 0;
      }

03.所有权转移

#include <iostream>
  #include "MyObject.h"
  #include <vector>
    using namespace std;
    // 工厂函数，创建对象并返回其所有权
    std::unique_ptr<MyObject>
      create_object(int id) {
      std::cout <<
      "Factory creating an object..." << std::endl;
      return std::make_unique<MyObject>
        (id);
        // 返回时，所有权被自动移动（转移）出去，无需手动写 std::move
        }
        void unique_ptr_ownership_example() {
        std::cout <<
        "\n--- Running unique_ptr Ownership Example ---" << std::endl;
        // 1. 从工厂函数获取所有权
        auto ptr1 = create_object(4);
        // 2. 尝试复制（这是错误的！）
        // auto ptr2 = ptr1; // 这行代码会导致编译错误！
        std::cout <<
        "Cannot copy a unique_ptr." << std::endl;
        // 3. 转移所有权
        std::cout <<
        "Moving ownership from ptr1 to ptr2..." << std::endl;
        auto ptr2 = std::move(ptr1);
        // 使用 std::move 转移所有权
        // 检查所有权状态
        if (!ptr1) {
        std::cout <<
        "ptr1 is now nullptr." << std::endl;
        }
        std::cout <<
        "ptr2 now owns the object." << std::endl;
        ptr2->
        do_something();
        // 4. 将 unique_ptr 存入容器
        std::vector<std::unique_ptr<MyObject>> object_list;
          // 必须使用 move 将所有权转移给 vector
          object_list.push_back(std::move(ptr2));
          std::cout <<
          "Object moved into the vector." << std::endl;
          if (!ptr2) {
          std::cout <<
          "ptr2 is now nullptr after moving into vector." << std::endl;
          }
          // 当 main 函数结束时，object_list 会被销毁，
          // 它内部的所有 unique_ptr 也会被销毁，从而释放所有对象
          }
          int main() {
          unique_ptr_ownership_example();
          std::cout <<
          "\nEnd of main, all objects should be destroyed now." << std::endl;
          return 0;
          }

04_与函数交互 (获取裸指针)

#include <iostream>
  #include "MyObject.h"
  #include <vector>
    using namespace std;
    // 假设这是一个第三方库的函数，它只接受裸指针，并且不会尝试 delete 它
    void process_raw_pointer(MyObject* raw_ptr) {
    if (raw_ptr) {
    std::cout <<
    "Processing object via raw pointer..." << std::endl;
    raw_ptr->
    do_something();
    }
    delete raw_ptr;
    }
    void unique_ptr_raw_pointer_example() {
    std::cout <<
    "\n--- Running unique_ptr Raw Pointer Example ---" << std::endl;
    auto ptr = std::make_unique<MyObject>
      (5);
      // 使用 .get() 方法获取裸指针，但不要释放它！
      // 所有权仍然在 unique_ptr 手中
      process_raw_pointer(ptr.get());
      //.get() 提供了一个“只读”的、临时的裸指针
      std::cout <<
      "After processing, unique_ptr still owns the object." << std::endl;
      } // 函数结束，ptr 离开作用域，对象被安全销毁
      int main() {
      unique_ptr_raw_pointer_example();
      return 0;
      }

05.shared_ptr 的基本用法与引用计数

// main.cpp
#include <memory>
  #include <vector>
    #include <iostream>
      #include "MyObject.h"
      //shared_ptr 通过引用计数，精确地追踪有多少个指针在共享同一个对象。
      // 只有当最后一个 shared_ptr 被销毁时，对象才会被释放
      void shared_ptr_basic_example() {
      std::cout <<
      "\n--- Running shared_ptr Basic Example ---" << std::endl;
      // 推荐用法：使用 std::make_shared 创建对象
      auto s_ptr1 = std::make_shared<MyObject>
        (10);
        std::cout <<
        "s_ptr1 created. Use count: " << s_ptr1.use_count() << std::endl;
        // 输出: 1
        {
        // 创建一个新的作用域
        std::cout <<
        "Entering new scope..." << std::endl;
        // 复制 s_ptr1。这是 shared_ptr 的核心能力。
        std::shared_ptr<MyObject> s_ptr2 = s_ptr1;
          //不是同一个指针，但它们指向同一个对象
          std::cout <<
          "s_ptr2 created by copying s_ptr1. Use count: " << s_ptr1.use_count() << std::endl;
          // 输出: 2
          std::cout <<
          "s_ptr2 use count is also: " << s_ptr2.use_count() << std::endl;
          // 输出: 2
          s_ptr2->
          do_something();
          std::cout <<
          "Leaving new scope..." << std::endl;
          } // s_ptr2 在这里离开作用域，被销毁，引用计数减 1
          std::cout <<
          "After scope, s_ptr2 is destroyed. Use count: " << s_ptr1.use_count() << std::endl;
          // 输出: 1
          std::cout <<
          "--- shared_ptr Basic Example Finished ---\n" << std::endl;
          //-----------
          std::cout <<
          "Entering new scope..." << std::endl;
          // 复制 s_ptr1。这是 shared_ptr 的核心能力。
          std::shared_ptr<MyObject> s_ptr2 = s_ptr1;
            std::cout <<
            "!!!s_ptr2 created by copying s_ptr1. Use count: " << s_ptr1.use_count() << std::endl;
            // 输出: 2
            std::cout <<
            "!!!s_ptr2 use count is also: " << s_ptr2.use_count() << std::endl;
            // 输出: 2
            s_ptr2->
            do_something();
            std::cout <<
            "Leaving new scope..." << std::endl;
            } // main 函数结束前，s_ptr1 在这里被销毁，引用计数变为 0，对象被 delete
            int main() {
            shared_ptr_basic_example();
            return 0;
            }

06_shared_ptr 与容器和函数

// main.cpp
#include <memory>
  #include <vector>
    #include <iostream>
      #include "MyObject.h"
      // 一个函数，接收一个 shared_ptr，表示它将临时共享该对象的所有权
      void process_shared_object(std::shared_ptr<MyObject> ptr) {
        std::cout <<
        " [Inside function] Received object. Use count: " << ptr.use_count() << std::endl;
        //3
        ptr->
        do_something();
        std::cout <<
        " [Inside function] Function finished." << std::endl;
        } // 函数结束，参数 ptr 被销毁，引用计数减 1
        void shared_ptr_advanced_example() {
        std::cout <<
        "\n--- Running shared_ptr Advanced Example ---" << std::endl;
        std::vector<std::shared_ptr<MyObject>> object_list;
          // 1. 创建对象并存入 vector
          auto s_ptr = std::make_shared<MyObject>
            (11);
            std::cout <<
            "Object created. Use count: " << s_ptr.use_count() << std::endl;
            // 1
            object_list.push_back(s_ptr);
            //复制操作，但是指向同一个shared_ptr
            std::cout <<
            "Object pushed into vector. Use count: " << s_ptr.use_count() << std::endl;
            // 2 (s_ptr 和 vector中的元素)
            // 2. 将 s_ptr 传递给函数
            std::cout <<
            "Calling function..." << std::endl;
            process_shared_object(s_ptr);
            std::cout <<
            "Function returned. Use count: " << s_ptr.use_count() << std::endl;
            // 2 (s_ptr 和 vector中的元素)
            // 3. 释放我们本地的 s_ptr
            s_ptr.reset();
            // 主动放弃所有权，只有s_ptr这一个指针放弃，其实就是s_ptr=nullptr
            std::cout <<
            "s_ptr reset. Use count: " << object_list[0].use_count() << std::endl;
            // 1 (只剩下 vector 中的元素)
            std::cout <<
            "--- shared_ptr Advanced Example Finished ---\n" << std::endl;
            } // main 函数结束前，vector 被销毁，它内部的 shared_ptr 也被销毁，引用计数变为 0，对象被 delete
            int main() {
            shared_ptr_advanced_example();
            return 0;
            }

07_weak_ptr循环引用导致的内存泄漏

// main.cpp
#include <memory>
  #include <vector>
    #include <iostream>
      #include "MyObject.h"
      // 定义两个相互引用的类
      class Son;
      // 前向声明
      class Father {
      public:
      Father() { std::cout <<
      "Father created." << std::endl;
      }
      ~Father() { std::cout <<
      "Father destroyed." << std::endl;
      }
      std::shared_ptr<Son> son_;
        };
        class Son {
        public:
        Son() { std::cout <<
        "Son created." << std::endl;
        }
        ~Son() { std::cout <<
        "Son destroyed." << std::endl;
        }
        std::shared_ptr<Father> father_;
          };
          void circular_reference_problem() {
          std::cout <<
          "\n--- Running Circular Reference Problem ---" << std::endl;
          auto father = std::make_shared<Father>
            ();
            // Father use_count = 1
            auto son = std::make_shared<Son>
              ();
              // Son use_count = 1
              // 建立相互引用，两者只是来回引用，并没有无限套娃
              father->son_ = son;
              // Son use_count = 2
              son->father_ = father;
              // Father use_count = 2
              std::cout <<
              "Father use count: " << father.use_count() << std::endl;
              std::cout <<
              "Son use count: " << son.use_count() << std::endl;
              std::cout <<
              "Leaving function scope..." << std::endl;
              } // 函数结束，father 和 son 两个局部智能指针被销毁
              // Father use_count 减为 1 (因为 Son 还指着它)
              // Son use_count 减为 1 (因为 Father 还指着它)
              // 引用计数都无法归零，析构函数永远不会被调用！
              int main() {
              circular_reference_problem();
              std::cout <<
              "After function, objects were NOT destroyed. Memory leak!" << std::endl;
              return 0;
              }

08_weak_ptr 打破循环引用

// main.cpp
#include <memory>
  #include <vector>
    #include <iostream>
      #include "MyObject.h"
      // 只需要修改 Son 的定义
      class SonFixed;
      class FatherFixed {
      public:
      FatherFixed() { std::cout <<
      "FatherFixed created." << std::endl;
      }
      ~FatherFixed() { std::cout <<
      "FatherFixed destroyed." << std::endl;
      }
      std::shared_ptr<SonFixed> son_;
        };
        class SonFixed {
        public:
        SonFixed() { std::cout <<
        "SonFixed created." << std::endl;
        }
        ~SonFixed() { std::cout <<
        "SonFixed destroyed." << std::endl;
        }
        // 关键改动：使用 weak_ptr
        // Son 只是“观察” Father，不拥有他
        std::weak_ptr<FatherFixed> father_;
          };
          void circular_reference_solution() {
          std::cout <<
          "\n--- Running Circular Reference Solution ---" << std::endl;
          auto father = std::make_shared<FatherFixed>
            ();
            // Father use_count = 1
            auto son = std::make_shared<SonFixed>
              ();
              // Son use_count = 1
              father->son_ = son;
              // Son use_count = 2
              son->father_ = father;
              // Father use_count 仍然是 1，因为 weak_ptr 不增加计数！
              std::cout <<
              "Father use count: " << father.use_count() << std::endl;
              std::cout <<
              "Son use count: " << son.use_count() << std::endl;
              // 如何通过 weak_ptr 访问对象？
              if (!son->father_.expired()) {
              // 1. 检查对象是否还存在
              // 2. 使用 lock() 获取一个临时的 shared_ptr
              std::shared_ptr<FatherFixed> father_sptr = son->father_.lock();
                if (father_sptr) {
                std::cout <<
                "Son can access Father. Father use count temporarily becomes: " << father_sptr.use_count() << std::endl;
                }
                } // father_sptr 在此被销毁，引用计数恢复
                std::cout <<
                "Leaving function scope..." << std::endl;
                } // 函数结束，father 和 son 局部指针被销毁
                // father 的 use_count 减为 0 -> FatherFixed 被销毁
                // FatherFixed 的析构函数被调用，其成员 son_ (一个shared_ptr)被销毁
                // son 的 use_count 减为 0 -> SonFixed 被销毁
                int main() {
                circular_reference_solution();
                std::cout <<
                "After function, objects were correctly destroyed." << std::endl;
                return 0;
                }

09_使用 unique_ptr 管理 FILE

#include <cstdio>
  #include <memory>
    #include <iostream>
      // 自定义删除器，一个简单的函数
      void file_closer(FILE* file) {
      if (file) {
      std::cout <<
      "Custom deleter: Closing file." << std::endl;
      fclose(file);
      }
      }
      // 使用函数指针作为删除器类型
      using FileUniquePtr = std::unique_ptr<FILE, decltype(&file_closer)>
      ;
      void unique_ptr_deleter_example() {
      std::cout <<
      "\n--- unique_ptr Custom Deleter Example ---" << std::endl;
      // 打开文件，获取 C 风格的句柄
      FILE* raw_file_ptr = fopen("test.txt", "w");
      if (!raw_file_ptr) return;
      // 创建 unique_ptr，并提供删除器
      // 注意构造函数需要传入原始指针和删除器函数指针
      FileUniquePtr file_ptr(raw_file_ptr, &file_closer);
      fprintf(file_ptr.get(), "Hello from unique_ptr with a custom deleter!\n");
      std::cout <<
      "Function scope is ending, file will be closed automatically." << std::endl;
      } // file_ptr 在此被销毁，它会自动调用 file_closer(raw_file_ptr)
      int main() {
      unique_ptr_deleter_example();
      return 0;
      }

10shared_ptr 和 Lambda 实现自定义删除器

#include <memory>
  #include <iostream>
    struct ThirdPartyResource {
    ThirdPartyResource(int id) : id_(id) { std::cout <<
    "Resource " << id_ <<
    " acquired." << std::endl;
    }
    int id_;
    };
    // 假设这是一个第三方C库的释放函数
    void release_third_party_resource(ThirdPartyResource* res) {
    std::cout <<
    "Custom C-style release function called for resource " << res->id_ <<
      "." << std::endl;
      delete res;
      // 假设它内部也是用 delete
      }
      void shared_ptr_deleter_example() {
      std::cout <<
      "\n--- shared_ptr Custom Deleter Example ---" << std::endl;
      // 创建 shared_ptr，并将自定义删除器作为第二个参数传入
      // 使用 lambda 表达式非常方便
      std::shared_ptr<ThirdPartyResource>
        res_ptr(
        new ThirdPartyResource(101),
        [](ThirdPartyResource* r) {
        std::cout <<
        "Custom lambda deleter called for resource " << r->id_ <<
          "." << std::endl;
          delete r;
          }
          );
          // 也可以传递一个函数指针
          std::shared_ptr<ThirdPartyResource>
            res_ptr2(new ThirdPartyResource(102), &release_third_party_resource);
            std::cout <<
            "Function scope is ending, resources will be released." << std::endl;
            }
            int main() {
            shared_ptr_deleter_example();
            return 0;
            }

11_this 指针共享

#include <memory>
  #include <iostream>
    #include <vector>
      // 必须公开继承自 std::enable_shared_from_this
      class GameObject : public std::enable_shared_from_this<GameObject>
        {
        public:
        GameObject() { std::cout <<
        "GameObject created." << std::endl;
        }
        ~GameObject() { std::cout <<
        "GameObject destroyed." << std::endl;
        }
        // 这个方法需要返回一个指向自身的 shared_ptr
        std::shared_ptr<GameObject>
          get_shared_ptr() {
          // 错误的做法： return std::shared_ptr<GameObject>(this);
            // 正确的做法：
            return shared_from_this();
            }
            void add_to_manager() {
            // 假设一个游戏管理器需要存储对这个对象的共享引用
            get_game_manager().push_back(get_shared_ptr());
            }
            private:
            // 模拟一个全局的游戏管理器
            static std::vector<std::shared_ptr<GameObject>>
              &
              get_game_manager() {
              static std::vector<std::shared_ptr<GameObject>> manager;
                return manager;
                }
                };
                void enable_shared_from_this_example() {
                std::cout <<
                "\n--- enable_shared_from_this Example ---" << std::endl;
                // 重要：要使用 shared_from_this，对象必须首先被一个 shared_ptr 管理
                auto obj1 = std::make_shared<GameObject>
                  ();
                  // 让对象自己把自己注册到管理器中
                  obj1->
                  add_to_manager();
                  std::cout <<
                  "After registration, obj1 use count: " << obj1.use_count() << std::endl;
                  // 尝试在没有被 shared_ptr 管理的情况下调用
                  GameObject raw_obj;
                  try {
                  // 这会抛出一个 std::bad_weak_ptr 异常
                  // raw_obj.get_shared_ptr();
                  }
                  catch (const std::bad_weak_ptr& e) {
                  std::cout <<
                  "Caught expected exception: " << e.what() << std::endl;
                  }
                  std::cout <<
                  "Function scope is ending..." << std::endl;
                  }
                  int main() {
                  enable_shared_from_this_example();
                  // main 结束后，全局的 manager 才被销毁，最终 GameObject 被释放
                  return 0;
                  }

12shared_ptr 和 Lambda 实现自定义删除器

#include <memory>
  #include <iostream>
    struct ThirdPartyResource {
    ThirdPartyResource(int id) : id_(id) { std::cout <<
    "Resource " << id_ <<
    " acquired." << std::endl;
    }
    int id_;
    };
    // 假设这是一个第三方C库的释放函数
    void release_third_party_resource(ThirdPartyResource* res) {
    std::cout <<
    "Custom C-style release function called for resource " << res->id_ <<
      "." << std::endl;
      delete res;
      // 假设它内部也是用 delete
      }
      void shared_ptr_deleter_example() {
      std::cout <<
      "\n--- shared_ptr Custom Deleter Example ---" << std::endl;
      // 创建 shared_ptr，并将自定义删除器作为第二个参数传入
      // 使用 lambda 表达式非常方便
      std::shared_ptr<ThirdPartyResource>
        res_ptr(
        new ThirdPartyResource(101),
        [](ThirdPartyResource* r) {
        std::cout <<
        "Custom lambda deleter called for resource " << r->id_ <<
          "." << std::endl;
          delete r;
          }
          );
          // 也可以传递一个函数指针
          std::shared_ptr<ThirdPartyResource>
            res_ptr2(new ThirdPartyResource(102), &release_third_party_resource);
            std::cout <<
            "Function scope is ending, resources will be released." << std::endl;
            }
            int main() {
            shared_ptr_deleter_example();
            return 0;
            }