类中使用shared_ptr()的问题

当我们先定义一个指针，然后再用这个指针构造两个智能指针

<code>int main()

{

int* pt = new int();

std::shared_ptr<int> p1(pt);

std::shared_ptr<int> p2(pt);

std::cout << "p1.use_count() = " << p1.use_count() << std::endl;

std::cout << "p2.use_count() = " << p2.use_count() << std::endl;

return 0;

}

运行后就会报错，显示的是pt指针被重复释放了

原因是p1和p2都以为自己是唯一独占pt的智能指针，不知道还有智能指针指向pt

所以输出后发现两个引用计数都是1

如果需要不报错，就得这样写

<code>shared_ptr<int> p2 = p1

通过p1来定义p2，它们就知道pt有两个智能指针了，就不会报错。

再来看一个代码

class client

{

public:

~client()

{

std::cout << "~client()\n";

}

};

int main()

{

client* cp = new client();

std::shared_ptr<client> csp1(cp);

std::shared_ptr<client> csp2(cp);

std::cout << "csp1.use_count: " << csp1.use_count() << std::endl;

std::cout << "csp2.use_count: " << csp2.use_count() << std::endl;

return 0;

}

这个报的一样的错，原理相同，问题是我们实际开发中，很多时候需要通过this指针来获取对象的内容

这个时候需要通过enable_shared_from_this来解决问题

enable_shared_from_this的使用

class client : public std::enable_shared_from_this<client>

{

public:

~client()

{

std::cout << "~client()\n";

}

std::shared_ptr<client> get_ptr()

{

return shared_from_this();

}

};

int main()

{

client* cp = new client();

std::shared_ptr<client> csp1(cp);

std::shared_ptr<client> csp2 = cp->get_ptr();

std::cout << "csp1.use_count: " << csp1.use_count() << std::endl;

std::cout << "csp2.use_count: " << csp2.use_count() << std::endl;

return 0;

}

将代码改写成这样，先公有继承这个模板类。

这里需要注意，在你通过shared_from_this()返回一个类的shared_ptr时，该对象必须已经被一个shared_ptr所管理，所以你不能直接csp2 = cp->get_ptr()，要在此之前先有csp1(cp)。

这样的话，借助shared_from_this()，可以使得该对象只要引用计数不为零，就任意获取它的一个shared_ptr。只要还有shared_ptr持有它，它就不会消亡。

实际开发中应用，以一个服务器demo举例

首先看下面一段代码

struct client : std::enable_shared_from_this<client>

{

public:

void start()

{

}

//...其他函数

}

void start()

{

std::shared_ptr<client> s = std::make_shared<client>();

s->start();

}

int main()

{

start();

return 0;

}

这里用make_shared初始化了一个client的shared_ptr，make_shared会让对象和控制块可以安全地存储在连续的内存块中。它简化了内存管理，并提高了性能。但是不支持自己写删除器。

start是一个初始的函数，里面会稍后添加业务，下面我们写一个定时器。

public:

void start()

{

start_up();

}

private:

void start_up()

{

_timer.expires_from_now(std::chrono::seconds(10));

_timer.async_wait(std::bind(&client::time_out, shared_from_this()));

}

void time_out()

{

start_up();

}

private:

boost::asio::steady_timer _timer;

在类里面这样设计定时器，当start()调用的时候，会调用start_up()函数设置一个定时器，并且注册time_out()这个回调函数。

此时start()函数调用结束了，临时变量s的智能指针也已经释放，但是，定时器内通过调用shared_from_this()，返回了一个s管理的对象的shared_ptr给async_wait里的回调time_out()中，s管理的对象并未消亡，直到运行完回调time_out()，它才会消亡，但是回调里面如果继续调用start_up()重新设定计时器，便又会返回一个该对象的shared_ptr()传入新注册的回调time_out()内，以此类推，只要计时器不关闭，永远不会消亡。

基于这一点，可以和读写搭配起来，灵活控制当前类在什么条件下保活，什么条件下析构。