彻底理解智能指针:shared_ptr

class Transport {
public:
    void sendAsync() {
        ioWorker_.asyncWrite([this]() {
            this->handleWriteComplete();
        });
    }
};

auto t = std::make_shared<Transport>();
t->sendAsync();      // 发起异步操作
t.reset();           // 调用者提前释放（连接关闭、对象析构）

class Transport : public std::enable_shared_from_this<Transport> {
public:
    void sendAsync() {
        auto self = shared_from_this(); // 拿到自己的一份共享所有权

        ioWorker_.asyncWrite([self]() {
            self->handleWriteComplete(); // self 保证对象不被提前销毁
        });
    }
};

auto t = std::make_shared<Transport>();
t->sendAsync();  // 发起异步操作
t.reset();       // 调用者释放自己的那份

class Transport : public std::enable_shared_from_this<Transport> {
public:
    void sendAsync(std::vector<char> data) {
        auto self = shared_from_this();
        ioWorker_.asyncWrite([self, data = std::move(data)]() mutable {
            // 这里 data 和 self 一起活到写完
            self->handleWriteComplete(data);
        });
    }

    void handleWriteComplete(const std::vector<char>& data) {
        std::cout << "Write complete: " << data.size() << " bytes\n";
    }
};

class Foo {
public:
    void bar() {
        auto p = shared_from_this(); // ❌ 编译错误
    }
};

class Foo : public std::enable_shared_from_this<Foo> {
public:
    void bar() {
        auto p = shared_from_this(); // ✅ 可以用了
    }
};

template<class T>
class enable_shared_from_this {
protected:
    mutable std::weak_ptr<T> weak_this_; // 💡 弱引用指针，不影响计数
public:
    shared_ptr<T> shared_from_this() {
        return weak_this_.lock(); // 从弱引用锁出一个强引用
    }
    weak_ptr<T> weak_from_this() noexcept {
        return weak_this_;
    }
};

auto p = std::make_shared<Foo>();

p->weak_this_ = p; // 内部逻辑：让 enable_shared_from_this 知道自己的 shared_ptr

auto p2 = this->shared_from_this();

return weak_this_.lock();

// 当 make_shared 创建对象/控制块时（非常简化的伪流程）：
template<class T, class... Args>
std::shared_ptr<T> make_shared(Args&&... args) {
    // 1) 分配控制块（control block）并在其上构造 T（可能在同一块内存）
    control_block* cb = new control_block(...);
    T* obj = new(cb->storage) T(std::forward<Args>(args)...);

    // 2) 创建 shared_ptr 指向 control block（管理引用计数）
    std::shared_ptr<T> sp(cb, obj); // 实际实现更复杂

    // 3) 关键：如果 T 继承 enable_shared_from_this<T>
    //    把当前的 shared_ptr 写回对象的 weak_this_
    //    （这样对象内部就能通过 weak_from_this()/shared_from_this() 得到同一控制块）
    if constexpr (std::is_base_of_v<enable_shared_from_this<T>, T>) {
        obj->weak_this_ = sp; // 这里就是把 shared_ptr 的控制块“挂”到对象上
    }

    // 4) 返回 shared_ptr 给用户
    return sp;
}

https://en.cppreference.com/w/cpp/types/is_base_of.html

#include <memory>
#include <iostream>

struct Foo : public std::enable_shared_from_this<Foo> {
    void show() {
        auto self = shared_from_this();
        std::cout << "shared_from_this(): use_count=" << self.use_count() << "\n";
    }
    ~Foo() { std::cout << "Foo destroyed\n"; }
};

int main() {
    auto p1 = std::make_shared<Foo>();
    std::cout << "p1.use_count=" << p1.use_count() << "\n";
    p1->show(); // 内部再拿一份 shared_ptr
    std::cout << "p1.use_count(after)=" << p1.use_count() << "\n";
}

p1.use_count=1shared_from_this(): use_count=2p1.use_count(after)=1Foo destroyed

#include <boost/asio.hpp>
#include <iostream>
#include <memory>
#include <thread>

using boost::asio::ip::tcp;

class Session : public std::enable_shared_from_this<Session> {
public:
    Session(boost::asio::io_context& io) : socket_(io) {}

    tcp::socket& socket() { return socket_; }

    void start() {
        message_ = "Hello, async world!\n";

        std::cout << "[start] begin async_write\n";

        // 捕获 shared_from_this，保证 Session 在回调完成前不被销毁
        boost::asio::async_write(socket_,
            boost::asio::buffer(message_),
            [self = shared_from_this()](boost::system::error_code ec, std::size_t bytes) {
                if (!ec) {
                    std::cout << "[callback] write complete, bytes=" << bytes << "\n";
                }
                else {
                    std::cout << "[callback] error: " << ec.message() << "\n";
                }
            });
    }

private:
    tcp::socket socket_;
    std::string message_;
};

int main() {
    boost::asio::io_context io;

    tcp::acceptor acceptor(io, tcp::endpoint(tcp::v4(), 12345));

    auto session = std::make_shared<Session>(io);
    acceptor.async_accept(session->socket(),
        [session](boost::system::error_code ec) {
            if (!ec) session->start();
        });

    io.run();
}

// EventLoop provides a main loop that notifies EventHandler 
// callback objects when I/O is ready on a file descriptor.
class EventLoop : public hf3fs::enable_shared_from_this<EventLoop> 
{

	// start and stop.

	Result<Void> start(const std::string &threadName = "EventLoop");

	class EventHandler
	{

		public:

		virtual void handleEvents(uint32_t epollEvents) = 0;


		protected:

		friend class EventLoop;

		std::weak_ptr<EventLoop> eventLoop_;
	};

class EventLoop;  // 事件循环

class EventHandler {
protected:
    std::weak_ptr<EventLoop> eventLoop_;  // ⭐ 弱引用
};

class EventLoop : public std::enable_shared_from_this<EventLoop> {
    std::vector<std::shared_ptr<EventHandler>> handlers_;
};

std::shared_ptr<EventLoop> eventLoop_;

EventLoop.shared_ptr -> EventHandler.shared_ptr -> EventLoop.shared_ptr

class EventHandler {
protected:
    std::weak_ptr<EventLoop> eventLoop_; // 弱引用，不增加 shared_count
};

void EventHandler::handleEvent() {
    if (auto loop = eventLoop_.lock()) {   // 尝试生成 shared_ptr
        loop->doSomething();
    } else {
        // EventLoop 已经被销毁，安全退出
    }
}