c#和java中有自己主动垃圾回收机制，.net执行时和java虚拟机能够管理分配的堆内存，在对象失去引用时自己主动回收，因此在c#和jva中，
内存管理不是大问题。c++语言没有垃圾回收机制，必须自己去释放分配的堆内存，否则就会内存泄露。
我相信大部分c++开发者都遇到过内存泄露的问题，而查找内存泄露的问题往往要花大量的精力。要解决这个让人头疼的问题可
以採取一些办法，最有效的办法是使用智能指针！使用智能指针就不会操心内存泄露的问题了，由于智能指针能够自己主动删除删除分
配的内存。
智能指针是指向动态分配（堆）对象指针，用于生存期控制，可以确保自己主动正确的销毁动态分配的对象，防止内存
泄露。它的一种通用实现技术是使用引用计数。每次使用它，内部的引用计数加1，每次析构一次，内部引用计数减1，减为0时，删
除所指向的堆内存。
c++11之前，c++没有内置智能指针，之前仅仅能借助于boost的智能指针或者自己发明*。c++11如今内置的智能指针，使我们能够
非常方便的使用智能指针了。c++11中的智能指针包含：
- std::shared_ptr
- std::unique_ptr
- std::weak_ptr
std::shared_ptr
std::shared_ptr使用引用计数. 每个shared_ptr的拷贝都指向同样的内存。 在最后一个shared_ptr析构的时候,
内存才会被释
放。
我们看看shared_ptr怎样使用吧。
1.初始化
//智能指针的初始化 std::shared_ptr<int> p(new int(2)); std::shared_ptr<int> p2 = p; std::shared_ptr<BaseConnector> m_connt = make_shared<Connector>(m_ios, m_strIP, m_port);
通过构造函数、赋值函数或者make_shared函数初始化智能指针。
智能指针初始化能够指定删除器
void DeleteIntPtr(int* p) { delete p; } std::shared_ptr<int> p(new int, DeleteIntPtr); p的引用计数为0时会自己主动调用删除器DeleteIntPtr
2.智能指针中的原始指针，通过get获取
char* pData = pBuf.get();
3.注意事项。智能指针尽管能自己主动管理堆内存，可是它有不少陷阱，使用时须要注意：
1.不要把一个原生指针给多个shared_ptr管理
int* ptr = new int; shared_ptr<int> p1(ptr); shared_ptr<int> p2(ptr); //logic error 导致ptr被删除两次
2.不要把this指针给shared_ptr
3.不要在函数实參里创建shared_ptr
function ( shared_ptr<int>(new int), g( ) ); //有缺陷
可能的过程是先new int，然后调g( )，g( )发生异常，shared_ptr<int>没有创建，int内存泄露
shared_ptr<int> p(new int());
f(p, g());
4.对象内部生成this的shared_ptr
enable_shared_from_this 类，在该类中定了成员函数 shared_from_this() ，返回shared_ptr<T> 。这个函数仅在 shared_ptr<T> 的构造函数被调用之后才干使用。原因是 enable_shared_from_this::weak_ptr 并不在构造函数中设置（此处的构造函数指的是类型 T 的构造函数），而是在 shared_ptr<T> 的构造函数中设置（此处的构造函数指的是类型 shared_ptr<T> 的构造函数）。
若不使用 shared_from_this() 成员函数，将this指针构造了一个shared_ptr，外面创建的对象本身的shared_ptr也管理了this资源，在析构时则会发生两次析构；
class Y: public std::enable_shared_from_this<Y> { boost::shared_ptr<Y> GetSelf() { return shared_from_this(); } }; boost::shared_ptr<Y> spy(new Y) boost::shared_ptr<Y> p = spy->GetSelf(); //OK
5.shared_ptr作为对象的成员时，小心因循环引用造成无法释放资源。
struct A; struct B; struct A { std::shared_ptr<B> m_b; }; struct B { std::shared_ptr<A> m_a; }; std::shared_ptr<A> ptrA(new A); std::shared_ptr<B> ptrB(new B); ptrA->m_b = ptrB; ptrB->m_a = ptrA;
ptrA和ptrB相互引用，离开作用域时引用计数都为1，导致内存没有被释放，解决的方法是把A和B不论什么一个的成员变量改为weak_ptr
解决的方法是把A和B不论什么一个的成员变量改为weak_ptr
struct B
{
std::weak_ptr<A> m_a;
};
ptrB->m_a不会添加?A对象的引用计数，因此A对象离开作用域时，引用计数为0，m_b的引用计数减一，b离开作用域后引用计数由1减为0.
std::weak_ptr
弱引用指针，用来监视智能指针，不会使引用计数加1。在訪问所引用的对象前必须先转换为 std::shared_ptr。
用来表达暂时全部权的概念：当某个对象仅仅有存在时才须要被訪问，并且随时可能被他人删除时，能够使用
来跟踪该对象。须要获得暂时全部权时，则将其转换为 std::shared_ptr，此时假设原来的std::shared_ptr 被销毁，则该对象的生命期将被延长至这个暂时的 std::shared_ptr 相同被销毁为止。
还能够用来避免 std::shared_ptr 的循环引用。
std::weak_ptr<int> gw; void f() { if (auto spt = gw.lock()) { // Has to be copied into a shared_ptr before usage std::cout << *spt << "\n"; } else { std::cout << "gw is expired\n"; } } int main() { { auto sp = std::make_shared<int>(42); gw = sp; f(); } f(); } 输出 42 gw is expired
std::unique_ptr
unique_ptr不会共享它的指针。 无法将它拷贝到还有一个unique_ptr， unique_ptr仅仅能移动。 这意味着内存资源的全部权将转移到新的unique_ptr和原始unique_ptr不再拥有它。
int* p = new int; std::unique_ptr<int> ptr(p); std::unique_ptr<int> ptr1 = ptr; //不能复制，编译报错 auto ptr2 = std::move(ptr); //转移全部权, 如今ptr那块内存归ptr2全部, ptr2成为无效的指针.
智能指针是个好东西，使用它之后就不用操心内存释放、内存泄露的问题了，我的项目中都是用的智能指针，没有delete。
智能指针使我们的程序更安全，除了循环引用会导致内存泄露之外，其它都非常安全，能够放心使用。