我对文章的格式和错别字进行了调整，并标注出了重要的部分。以下是正文。

正文

C# 和 Java 中有自动垃圾回收机制，.net 运行时和 java 虚拟机可以管理分配的堆内存，在对象失去引用时自动回收，因此在 C# 和 Java 中，内存管理不是大问题。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 如何使用吧。

初始化

// 智能指针的初始化
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

智能指针中的原始指针

通过 get 获取

char* pData = pBuf.get();

注意事项

智能指针虽然能自动管理堆内存，但是它有不少陷阱，使用时需要注意：

不要把一个原生指针给多个 shared_ptr 管理

int *ptr = new int;
shared_ptr<int> p1(ptr);
shared_ptr<int> p2(ptr); // logic error 导致 ptr 被删除两次

不要把 this 指针给 shared_ptr
不要在函数实参里创建 shared_ptr

function(shared_ptr<int>(new int), g()); //有缺陷

可能的过程是先 new int ，然后调 g()，g() 发生异常， shared_ptr 没有创建，int 内存泄露。

应该改为如下形式

shared_ptr<int> p(new int());
f(p, g());

对象内部生成 this 的 shared_ptr

从 std::enable_shared_from_this 类派生

在该类中定了成员函数 shared_from_this() ，返回 shared_ptr 。这个函数仅在 shared_ptr 的构造函数被调用之后才能使用。原因是 enable_shared_from_this::weak_ptr 并不在构造函数中设置（此处的构造函数指的是类型 T 的构造函数），而是在 shared_ptr 的构造函数中设置（此处的构造函数指的是类型 shared_ptr 的构造函数）。

若不使用 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

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

例如

struct B
{
    std::weak_ptr<A> m_a;
};

ptrB->m_a 不会增加 A 对象的引用计数，因此 A 对象离开作用域时，引用计数为 0 ，m_b 的引用计数减一，b 离开作用域后引用计数由 1 减为 0 。

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 所有, ptr 成为无效的指针.

智能指针是个好东西，使用它之后就不用担心内存释放、内存泄露的问题了，我的项目中都是用的智能指针，没有 delete 。

智能指针使我们的程序更安全，除了循环引用会导致内存泄露之外，其他都很安全，可以放心使用。

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

【转载】C++11 改进我们的程序之垃圾回收

正文

std::shared_ptr

初始化

智能指针中的原始指针

注意事项

std::unique_ptr

std::weak_ptr