详解C++中shared_ptr的使⽤教程
shared_ptr是⼀种智能指针（smart pointer）。shared_ptr的作⽤有如同指针，但会记录有多少个shared_ptrs共同指向⼀个对象。
这便是所谓的引⽤计数（reference counting）。⼀旦最后⼀个这样的指针被销毁，也就是⼀旦某个对象的引⽤计数变为0，这个对象会被⾃动删除。这在⾮环形数据结构中防⽌资源泄露很有帮助。
auto_ptr由于它的破坏性复制语义，⽆法满⾜标准容器对元素的要求，因⽽不能放在标准容器中；如果我们希望当容器析构时能⾃动把它容纳的指针元素所指的对象删除时，通常采⽤⼀些间接的⽅式来实现，显得⽐较繁琐。boost库中提供了⼀种新型的智能指针shared_ptr，它解决了在多个指针间共享对象所有权的问题，同时也满⾜容器对元素的要求，因⽽可以安全地放⼊容器中。
总结下⼏个使⽤shared_ptr需要注意的问题:
⼀. 相互引⽤链
class C;
class B : public std::enable_shared_from_this<B>
{
public:
~B(){ cout << "~B" << endl; }
void SetPC(std::shared_ptr<C>& pc){ _pc = pc; }
private:
std::shared_ptr<C> _pc;
};
class C : public std::enable_shared_from_this<C>
{
public:
~C(){ cout << "~C" << endl; }
void SetPB(std::shared_ptr<B>& pb){ _pb = pb; }
private:
std::shared_ptr<B> _pb;
};
int main()
{
std::shared_ptr<C> pc = std::make_shared<C>();
std::shared_ptr<B> pb = std::make_shared<B>();
pc->SetPB(pb);
pb->SetPC(pc);
return 0;
}
上⾯的代码中，B和C均不能正确析构，正确的做法是，在B和C的释放函数，如Close中，将其包含的shared_ptr置空。这样才能解开引⽤链。
⼆. ⾃引⽤
还有个⽐较有意思的例⼦：
析构方法class C : public std::enable_shared_from_this < C >
{
public:
~C()
{
std::cout << "~C" << std::endl;
}
int32_t Decode(const char* data, size_t)
{
return 0;
}
void SetDecoder(std::function<int32_t(const char*, size_t)> decoder)
{
_decoder = decoder;
}
private:
std::function<int32_t(const char*, size_t)> _decoder;
};
int main()
{
{
std::shared_ptr<C> pc = std::make_shared<C>();
auto decoder = std::bind(&C::Decode, pc, std::placeholders::_1, std::placeholders::_2);
pc->SetDecoder(decoder);
}
// C不能正确析构因为存在⾃引⽤
return 0;
}
上⾯的C类包含了⼀个function，该function通过std::bind引⽤了⼀个std::shared_ptr，所以_decoder其实
包含了⼀个对shared_ptr的引⽤。导致C⾃引⽤了⾃⾝，不能正确析构。需要在C的Close之类的执⾏关闭函数中，将_decoder=nullptr，以解开这种⾃引⽤。
三. 类中传递
下⾯的例⼦中有个更为隐蔽的问题：
class Session : public std::enable_shared_from_this < Session >
{
public:
~Session()
{
std::cout << "~C" << std::endl;
}
void Start()
{
// 进⾏⼀些异步调⽤
// 如 _socket.async_connect(..., boost::bind(&Session::ConnectCompleted, this), boost::asio::placeholders::error, ...)
}
void ConnectCompleted(const boost::system::err_code& err)
{
if(err)
return;
// ... 进⾏处理
// 如 _socket.async_read(..., boost::bind(&Session::ReadCompleted, this), boost::asio::placeholders::error, ...)
}
void Session::ReadComplete(const boost::system::error_code& err, size_t bytes_transferred)
{
if (err || bytes_transferred == 0)
{
DisConnect();
return;
}
// 处理数据继续读
// ProcessData();
// _socket.async_read(...)
}
private:
std::function<int32_t(const char*, size_t)> _decoder;
};
int main()
{
{
std::shared_ptr<Session> pc = std::make_shared<Session>();
pc->Start();
}
return 0;
}
上⾯Session，在调⽤Start时，调⽤了异步函数，并回调⾃⾝，如果在回调函数的 boost::bind 中传⼊的是
shared_from_this()，那么并⽆问题，shared_ptr将被⼀直传递下去，在⽹络处理正常时，Session将正常运⾏，即使main函数中已经没有它的引⽤，但是它靠boost::bind”活了下来”，boost::bind会保存传给它的shared_ptr，在调⽤函数时传⼊。当⽹络
遇到错误时，函数直接返回。此时不再有新的bind为其”续命”。Session将被析构。
⽽真正的问题在于，如果在整个bind链中，直接传递了this指针⽽不是shared_from_this()，那么实际上当函数执⾏完成
后，Session即会析构，包括其内部的资源(如 _socket)也会被释放。那么当boost底层去执⾏⽹络IO时，⾃然会遇到错误，并且仍然会”正常”回调到对应函数，如ReadCompleted，然后在err中告诉你：”由本地系统终⽌⽹络连接”(或:”An attempt to abort the evaluation failed. The process is now in an indeterminate state.” )。让⼈误以为是⽹络问题，很难调试。⽽事实上此时整个对象都已经被释放掉了。
注：由于C++对象模型实现所致，成员函数和普通函数的主要区别如下：
成员函数带隐式this参数
成员函数具有访问作⽤域，并且函数内会对⾮静态成员变量访问做⼀些转换，如 _member_data 转换成 this-
>_member_data;
也就是说，成员函数并不属于对象，⾮静态数据成员才属于对象。
因此如下调⽤在编译期是合法的：
((A*)nullptr)->Func();
⽽如果成员函数A::Func()没有访问A的⾮静态成员变量，这段代码甚⾄能正确运⾏，如:
class Test
{
public:
void Say()
{
std::cout << "Say Test" << std::endl;
}
void Set(int data)
{
_data = data;
}
private:
int _data;
};
int main()
{
// 运⾏成功
((Test*)nullptr)->Say();
// 运⾏会崩掉，尝试访问空指针所指内存(_data)
((Test*)nullptr)->Set(1);
return 0;
}
正因为这种特性，有时候在成员函数中纠结半天，也不会注意到这个对象已经”不正常了”，被释放掉了。
四. shared_ptr 使⽤总结
尽量不要环引⽤或⾃引⽤，可通过weak_ptr来避免环引⽤：owner持有child的shared_ptr child持有owner的weak_ptr
如果存在环引⽤或⾃引⽤，记得在释放时解开这个引⽤链
对于通过智能指针管理的类，在类中通过shared_from_this()⽽不是this来传递本⾝
在类释放时，尽量⼿动置空其所有的shared_ptr成员，包括function
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论