shared_ptr的循环引用

class Controller {
 public:
  Controller() = default;

  ~Controller() {
    std::cout << "in ~Controller" << std::endl;
  }

  class SubController {
   public:
    SubController() = default;

    ~SubController() {
      std::cout << "in ~SubController" << std::endl;
    }

    std::shared_ptr<Controller> controller_;
  };

  std::shared_ptr<SubController> sub_controller_;
};

int main() {
  auto controller = std::make_shared<Controller>();
  auto sub_controller = std::make_shared<Controller::SubController>();

  controller->sub_controller_ = sub_controller;
  sub_controller->controller_ = controller;
  return 0;
}

以上代码执行后析构函数不会被调用，因为两个类的引用计数都是2，原理是，当shared_ptr超过作用域时，引用计数-1，如果引用计数等于0，就会调用指向的对象的析构函数，释放内存。

这里的步骤为：

 先调用包含sub_controller的 shared_ptr析构函数，内部引用计数-1，2-1=1，所以不会调用sub_controller析构

然后调用包含controller的 shared_ptr析构函数，内部引用计数-1，2-1=1，所以不会调用sub_controller析构

正确的做法是使用weak_ptr

class Controller {
 public:
  Controller() = default;

  ~Controller() {
    std::cout << "in ~Controller" << std::endl;
  }

  class SubController {
   public:
    SubController() = default;

    ~SubController() {
      std::cout << "in ~SubController" << std::endl;
    }

    std::weak_ptr<Controller> controller_;
  };

  std::shared_ptr<SubController> sub_controller_;
};

了解weak_ptr知道，他不会导致引用计数增加

改成weak_ptr后的变成：

输出

 具体步骤：

 先调用包含sub_controller的 shared_ptr析构函数，内部引用计数-1，2-1=1，所以不会调用sub_controller析构

然后调用包含controller的 shared_ptr析构函数，内部引用计数-1，1-1=0，调用controller析构，编译器在controller析构函数执行的时候还会调用成员类的析构，也就是std::shared_ptr<SubController> sub_controller_;

此时它的引用计数是1,1-1=0，调用SubController析构函数

1.调用controller析构

执行完controller后又调用了sub_controller shared_ptr智能指针的析构(又是一样的步骤，引用计数--，然后是否调用指向对象的析构函数...)

ps:环境vs2013，各个编译器实现细节可能都是不一致的，但是思想是差不多是这样子