C++ 智能指针

一、初识智能指针

     第一次使用智能指针是在写一个服务器程序的时候，使用boost\asio库写TCP连接线程，用到了boost::shared_ptr，只知道很好用，不用考虑tcp::socket的回收处理。

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <boost/smart_ptr.hpp>
using boost::asio::ip::udp;
using boost::asio::ip::tcp;
typedef boost::shared_ptr<tcp::socket> socket_ptr;

#include <iostream>
using namespace std;
#include "server.h"

const int max_length = 512000;

void session(socket_ptr sock,CirQueueKT206RMsg* m_SocketDataQueue)
{
	try
	{
		KT206R_F_MsgPrtcl::Msg msg;
		char data[max_length];
		for (;;)
		{			
			boost::system::error_code error;
			size_t length = sock->read_some(boost::asio::buffer(data), error);
			if (error == boost::asio::error::eof)
				break; // Connection closed cleanly by peer.
			else if (error){				
				sock->shutdown(boost::asio::ip::tcp::socket::shutdown_both);
				sock->close();
				throw boost::system::system_error(error); // Some other error.
			}
			boost::asio::write(*sock, boost::asio::buffer(data, length));
			msg.ip.clear();
			msg.type = 0;
			msg.version =0;
			msg.Vnode.clear();
			SetMsgProtocol protocle;
			if(protocle.KT206R_F_TCP_Protocol(data,length,sock->remote_endpoint().address().to_string(),msg)){
				if(msg.Vnode.size()>0){
					m_SocketDataQueue->enQueue(msg);
				}
			}
		}
		sock->close();
	}
	catch (std::exception& e)
	{
		;//std::cerr << "Exception in thread: " << e.what() << "\n";
	}
	sock.reset();
}

void server(boost::asio::io_service& io_service, short port,CirQueueKT206RMsg* m_SocketDataQueue)
{
	tcp::acceptor a(io_service, tcp::endpoint(tcp::v4(), port));
	for (;;)
	{
		socket_ptr sock(new tcp::socket(io_service));
		a.accept(*sock);
		boost::thread t(boost::bind(session, sock,m_SocketDataQueue));
	}
}

void SetAccessPacket::run()
{
	for(;;){
		if(m_protocol_version == 1)
			blocking_udp_echo_server();			//UDP 同步I/O方式		
		else if(m_protocol_version == 2){		//TCP同步I/O方式
			try
			{
				boost::asio::io_service io_service;
				server(io_service, 10608,this->m_SocketUdpQueue);
			}
			catch (std::exception& e)
			{
				logger()->error("Unable to start the blocking_TCP_echo_server service ");
				std::cerr << "Exception: " << e.what() << "\n";
			}
		}
		else if(m_protocol_version == 3)
			blocking_udp_echo_server2();			//UDP 同步I/O方式2
		else{
			logger()->error("Can not find a right protocol version to start the service ");
			break;
		}
		logger()->info("Automatically try again. Waiting....");
		boost::this_thread::sleep(boost::posix_time::milliseconds(5000));
		logger()->info("Start the service again");
	}
	logger()->error("Server failed to Startup !");
}

初见shared_ptr的威力了吧？对，对于new出来的对象，我们可以不用考虑去delete它们。怀着一股强烈的好奇心和求知欲，我又去参考阅读了C++11新标准关于智能指针的知识。

二、C++11 的智能指针

        在原C++98里面有个智能指针“auto_ptr”，auto_ptr以对象的方式管理堆分配的内存，并在析构的时候，释放所获得的堆内存。以new操作返回的指针作为auto_ptr的初始化值，如auto_ptr(new int)，同样也不用显示调用delete，但是因为auto_ptr的一些缺点（拷贝的时候返回一个左值，不能调用delete[]等）所以C++11 标准废弃了auto_ptr，进而改用了unique_ptr,shared_ptr,和weak_ptr,三个智能指针。

1、unique_ptr

        unique_ptr顾名思义，它与所指的对象的内存紧密绑定在一起，不能与其他的unique_ptr类型的指针对象共享所指对象的内存。例如 ：

      unique_ptr<int> un_p1(new int (1));   //这将是无法复制的unique_ptr

      unique_ptr<int> un_p2 = un_p1;       //编译将无法通过

但是可以通过标准库函数move函数将一个unique_ptr的“所有权”转移，一旦“所有权"转移成功了，原来的unique_ptr指针就失去了对象内存的”所有权"。例如：

      unique_ptr<int> un_p3 = move(un_p1) ; //un_p3是唯一的所有者

      cout<<*un_p1<<endl;                       //运行是出错

与这种唯一占用式的智能指针对应的当然就是shared_ptr智能指针了。

2、神器shared_ptr/weak_ptr

       shared_ptr是引用计数型智能指针，源于boost和std::tr1，现已纳入C++11 标准库shared_ptr用起来方便，类模版形式是shared_ptr<T>。引用计数是自动化资源管理的常用手段，就是当计数降为0的时候，对象即被销毁，而weak_ptr也是一个引用计数型智能指针，但是它不增加对象的引用次数，没有影响其指向对象的内存的引用计数，所以weak_ptr可以用来验证shared_ptr指针的有效性。看例子：

#include <memory>
#include <iostream>
using namespace std;

void Check(weak_ptr<int> & wp){
	shared_ptr<int> sp = wp.lock();   //转换为shared_ptr<int>
	if(sp != nullptr)
		cout<<"valid pointer "<<*sp<<endl;
	else
		cout<<"invalid pointer"<<endl;
}

int main(){
	shared_ptr<int> sp1(new int(123));
	shared_ptr<int> sp2 = sp1;
	weak_ptr<int> wp = sp1;

	cout<<*sp1<<endl; //123
	cout<<*sp2<<endl; //123
	Check(wp);	  //valid pointer 123

	sp1.reset();      //计数降1
	cout<<*sp2<<endl; //123
	Check(wp);	  //valid pointer 123

	sp2.reset();      //计数变成0，析构
	Check(wp);	  //invalid pointer
}

三、shared_ptr/weak_ptr的应用

          当析构函数遇到多线程可能是每个程序猿遇到的棘手的问题，怎么保证线程安全，怎么解决C++内存问题，加锁和智能指针是我们的神兵利器。例如，在处理空悬指针和野指针问题上，用shared_ptr/weak_ptr可以避免这种情况的出现，不匹配的new[]/delete[]，把new[]统统替换成std::vector/shared_ptr。shared_ptr控制对象的生命期，只要有一个X对象的shared_ptr存在，该对象就不会析构，当对象X的最后一个shared_ptr析构或者reset()的时候，X保证被销毁。