|
C++ 程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。但使用普通指针，容易造成内存泄露（忘记释放）、二次释放、程序发生异常时内存泄露等问题等。所有 C++11 就引入了智能指针。
原始指针容易发生内存泄漏
C语言中最常使用的是malloc（）函数分配内存,free（）函数释放内存，而C++中对应的是new、delete关键字。malloc（）只是分配了内存，而new则更进一步，不仅分配了内存，还调用了构造函数进行初始化；
int main()
{
// malloc返回值是 void*
int* argC = (int*)malloc(sizeof(int));
free(argC);
char *age = new int(25); // 做了两件事情 1.分配内存 2.初始化
delete age;
}
new和delete必须成对出现，有时候是不小心忘了delete，有时候则是很难判断在这个地方自己是不是该delete，这个和资源的生命周期有关，这个资源是食欲我这个管理类的还是由另外一个类管理的（其它类可能要使用），如果是别人管理的就由别人delete。
如果需要自己管理的内存的话，最好显示的将自己的资源传递进去，这样的话，就能知道是该资源确实应该由自己来管理。
char *getName(char* v, size_t bufferSize) {
return v;
}
上面还是小问题，自己小心一点，再仔细看看文档，还是有机会避免这些情况的。但是在 C++ 引入异常的概念之后，程序的控制流就发生了根本性的改变，在写了 delete 的时候还是有可能发生内存泄漏。如下例：
void badThing(){
throw 1;// 抛出一个异常
}
void test() {
char* a = new char[1000];
badThing();
// do something
delete[] a;
}
int main() {
try {
test();
}
catch (int i){
cout << "error happened " << i << endl;
}
}
上面的new和delete是成对出现的，但是程序在中间的时候抛出了异常，由于没有立即捕获，程序从这里退出了，并没有执行到delete，内存泄漏还是发生了。
使用构造函数和析构函数十分强大，可以使用构造和析构解决上面的内存泄漏问题，比如：
class SafeIntPointer {
public:
explicit SafeIntPointer(int v) : m_value(new int(v)) { }
~SafeIntPointer() {
delete m_value;
cout << "~SafeIntPointer" << endl;
}
int get() { return *m_value; }
private:
int* m_value;
};
void badThing(){
throw 1;// 抛出一个异常
}
void test() {
SafeIntPointer a(5);
badThing();
}
int main() {
try {
test();
}
catch (int i){
cout << "error happened " << i << endl;
}
}
// 结果
// ~SafeIntPointer
// error happened 1
可以看到，就算发生了异常，也能够保证析构函数成功执行！这里的例子是这个资源只有一个人使用，我不用了就将它释放掉。但还有种情况，一份资源被很多共同使用，要等到所有人都不再使用的时候才能放掉，对于这种问题，就需要对上面的SafeIntPoint增加一个引用计数，如下：
class SafeIntPointer {
public:
explicit SafeIntPointer(int v) : m_value(new int(v)), m_used(new int(1)) { }
~SafeIntPointer() {
cout << "~SafeIntPointer" << endl;
(*m_used) --; // 引用计数减1
if(*m_used <= 0){
delete m_used;
delete m_value;
cout << "real delete resources" << endl;
}
}
SafeIntPointer(const SafeIntPointer& other) {
m_used = other.m_used;
m_value = other.m_value;
(*m_used)++; // 引用计数加1
}
SafeIntPointer& operator= (const SafeIntPointer& other) {
if (this == &other) // 避免自我赋值!!
return *this;
m_used = other.m_used;
m_value = other.m_value;
(*m_used)++; // 引用计数加1
return *this;
}
int get() { return *m_value; }
int getRefCount() {
return *m_used;
}
private:
int* m_used; // 引用计数
int* m_value;
};
int main() {
SafeIntPointer a(5);
cout << "ref count = " << a.getRefCount() << endl;
SafeIntPointer b = a;
cout << "ref count = " << a.getRefCount() << endl;
SafeIntPointer c = b;
cout << "ref count = " << a.getRefCount() << endl;
}
/*
ref count = 1
ref count = 2
ref count = 3
~SafeIntPointer
~SafeIntPointer
~SafeIntPointer
real delete resources
*/
可以看到每一次赋值，引用计数都加一，最后每次析构一次后引用计数减去一，直到引用计数为0，才真正释放资源。要写出一个正确的管理资源的包装类还是很难的，上面那个例子就不是线程安全的，只能属于一个玩具，在实际工程中简直没法用。
C++11中引入了智能指针（Smart Pointer），它利用了一种叫做RAII（资源获取即初始化）的技术将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。这使得只能指针实质是一个对象，行为表现却像一个指针。
智能指针主要分为shared_ptr、unique_ptr和weak_ptr三种，使用时需要引用头文件.C++11中shared_ptr和weak_ptr都是参考boost库实现的。
shared_ptr共享的智能指针
shared_ptr的初始化
最安全的分配和使用动态内存的方法是调用一个make_sjhared的标准库函数。此函数在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr。与智能指针一样，make_shared也定义在头文件memory中。
shared_ptr<int> p3 = make_shared<int>(42);
shared_ptr<string> p4 = make_shared<string>(10,'9');
shared_ptr<int> p5 = make_shared<int>();
我们还可以用new返回的指针来初始化智能指针，不过接受指针参数的智能指针函数是explicit的。因此，我们不能将一个内置指针隐式转换为一个智能指针，必须使用直接初始化形式来初始化一个智能指针：
shared_ptr<int> pi = new int (1024);
shared_ptr<int> p2 (new int(1024));
处于相同的原因，一个返回shared_ptr 的函数不能在其返回语句中隐式转换一个普通指针：
shared_ptr<int> clone(int p)
{
return new int(p);
}
shared_ptr的基本使用
std::shared_ptr的基本使用很简单，看几个例子就明白了：
#include <memory>
#include <iostream>
class Test
{
public:
Test()
{
std::cout << "Test()" << std::endl;
}
~Test()
{
std::cout << "~Test()" << std::endl;
}
};
int main()
{
std::shared_ptr<Test> p1 = std::make_shared<Test>();
std::cout << "1 ref:" << p1.use_count() << std::endl;
{
std::shared_ptr<Test> p2 = p1;
std::cout << "2 ref:" << p1.use_count() << std::endl;
}
std::cout << "3 ref:" << p1.use_count() << std::endl;
return 0;
}
针对代码解读如下：
std::make_shared里面调用了 new 操作符分配内存；- 第二个
p1.use_count()之所以显示为 2，是因为增加了引用对象 p2，而随着大括号的结束，p2 的作用域结束，所以 p1 的引用计数变回 1，而随着 main 函数的结束，p1 的作用域结束，此时检测到计数为 1，那就会在销毁 p1 的同时，调用 p1 的析构函数 delete 掉之前分配的内存空间；
下面列出了shared_ptr独有的操作：
make_shared<T>(args) // 返回一个shared_ptr，指向一个动态分配的类型为T的对象。使用args初始化此对象
shared_ptr<T> p(q) // p是shared_ptr q的拷贝；此操作会递增q中的引用计数。q中的指针必须能转换成T*
p = q // p和q都是shared_ptr，所保存的指针必须能相互转换。此操作会递减p中的引用计数，递增q中的引用计数。若p中的引用计数变为0，则将其管理的原内存释放
p.unique() // 若p.use_count()为1，返回true；否则返回false
p.use_count() // 返回与p共享对象的智能指针数量；可能很慢，主要用于调试
下面介绍一些改变shared_ptr的其他方法：
p.reset () //若p是唯一指向其对象的shared_ptr，reset会释放此对象。
p.reset(q) //若传递了可选的参数内置指针q，会令P指向q，否则会将P置为空。
p.reset(q, d) //若还传递了参数d,将会调用d而不是delete 来释放q
weak_ptr弱引用的智能指针
shared_ptr的一个最大的陷阱是循环引用，循环引用会导致堆内存无法正确释放，导致内存泄漏。看下面的例子：
#include <iostream>
#include <memory>
class Parent;
class Child {
public:
Child() { std::cout << "hello child" << std::endl; }
~Child() { std::cout << "bye child" << std::endl; }
std::shared_ptr<Parent> father;
};
class Parent {
public:
Parent() { std::cout << "hello Parent" << std::endl; }
~Parent() { std::cout << "bye parent" << std::endl; }
std::shared_ptr<Child> son;
};
void testParentAndChild() {
}
int main() {
std::shared_ptr<Parent> parent(new Parent());
std::shared_ptr<Child> child(new Child());
parent->son = child;
child->father = parent;
return 0;
}
很惊讶的发现，用了shared_ptr管理资源，没有调用 Parent 和 Child 的析构函数，表示资源最后还是没有释放！内存泄漏还是发生了。
分析：
- 执行编号
1的语句时，构造了一个共享智能指针p，称呼它管理的资源叫做资源A（new Parent()产生的对象）吧， 语句2构造了一个共享智能指针c，管理资源B(new Child()产生的对象)，此时资源A和B的引用计数都是1，因为只有1个智能指针管理它们，执行到了语句3的时候，是一个智能指针的赋值操作，资源B的引用计数变为了2，同理，执行完语句4，资源A的引用计数也变成了2。 - 出了函数作用域时，由于析构和构造的顺序是相反的，会先析构共享智能指针
c，资源B的引用计数就变成了1；接下来继续析构共享智能指针p，资源A的引用计数也变成了1。由于资源A和B的引用计数都不为1，说明还有共享智能指针在使用着它们，所以不会调用资源的析构函数！ - 这种情况就是个死循环，如果资源
A的引用计数想变成0，则必须资源B先析构掉（从而析构掉内部管理资源A的共享智能指针），资源B的引用计数想变为0，又得依赖资源A的析构，这样就陷入了一个死循环。
weak_ptr如何解决相互引用的问题
要想解决上面循环引用的问题，只能引入新的智能指针std::weak_ptr std::weak_ptr有什么特点呢？与std::shared_ptr最大的差别是在赋值的时候，不会引起智能指针计数增加。
weak_ptr被设计为与shared_ptr共同工作，可以从一个shared_ptr或者另一个weak_ptr对象构造，获取资源的观测权。但weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。
同样，在weak_ptr析构时也不会导致引用计数的减少，它只是一个静静地观察者，weak_ptr没有重载operator*和->，这是特意的，因为它不共享指针，不能操作资源，这是它弱的原因。
如果要操作资源，则必须使用一个非常重要的成员函数lock()从被观测的shared_ptr获得一个可用的shared_ptr对象，从而操作资源。
当我们创建一个weak_ptr时，要用一个shared_ptr来初始化它：
auto p = make_shared<int>(42);
weak_ptr<int> wp(p); // wp弱共享p； p的引用计数未改变
我们在上面的代码的基础上使用std::weak_ptr进行修改，如下：
#include <iostream>
#include <memory>
class Parent; // Parent类的前置声明
class Child {
public:
Child() { std::cout << "hello child" << std::endl; }
~Child() { std::cout << "bye child" << std::endl; }
// 测试函数
void testWork()
{
std::cout << "testWork()" << std::endl;
}
std::weak_ptr<Parent> father;
};
class Parent {
public:
Parent() { std::cout << "hello Parent" << std::endl; }
~Parent() { std::cout << "bye parent" << std::endl; }
std::weak_ptr<Child> son;
};
void testParentAndChild() {
}
int main() {
std::shared_ptr<Parent> parent(new Parent());
std::shared_ptr<Child> child(new Child());
parent->son = child;
child->father = parent;
std::cout << "parent_ref:" << parent.use_count() << std::endl;
std::cout << "child_ref:" << child.use_count() << std::endl;
// 把std::weak_ptr类型转换成std::shared_ptr类型，以调用内部成员函数
std::shared_ptr<Child> tmp = parent.get()->son.lock();
tmp->testWork();
std::cout << "tmp_ref:" << tmp.use_count() << std::endl;
return 0;
}
/*
输出：
hello Parent
hello child
parent_ref:1
child_ref:1
testWork()
tmp_ref:2
bye child
bye parent
*/
由以上代码运行结果我们可以看到：
- 所有的对象最后都能正常释放，不会存在上一个例子中的内存没有释放的问题;
- parent 和 child 在 main 函数中退出前，引用计数均为 1，也就是说，对
std::weak_ptr的相互引用，不会导致计数的增加。
weak_ptr常用操作
weak_ptr<T> w; // 空weak_ptr可以指向类型为T的对象
weak_ptr<T> w(shared_ptr p); // 与p指向相同对象的weak_ptr, T必须能转换为sp指向的类型
w = p; // p可以是shared_ptr或者weak_ptr，赋值后w和p共享对象
w.reset(); // weak_ptr置为空
w.use_count(); // 与w共享对象的shared_ptr的计数
w.expired(); // w.use_count()为0则返回true，否则返回false
w.lock(); // w.expired()为true，返回空的shared_ptr;否则返回指向w的shared_ptr
unique_ptr的基本使用
unique_ptr相对其他两个智能指针更加简单，它和shared_ptr使用差不多，但是功能更为单一，它是一个独占型的智能指针，不允许其他的智能指针共享其内部的指针，更像原生的指针（但更为安全，能够自己释放内存）。不允许赋值和拷贝操作，只能够移动。
std::unique_ptr<int> ptr1(new int(0));
std::unique_ptr<int> ptr2 = ptr1; // 错误，不能复制
std::unique_ptr<int> ptr3 = std::move(ptr1); // 可以移动
在C++11中，没有类似std::make_shared的初始化方法，但是在C++14中，对于std::unique_ptr引入了std::make_unique方法进行初始化。
#include <iostream>
#include <memory>
int main()
{
std::unique_ptr<std::string> ptr1(new std::string("unique_ptr"));
std::cout << "ptr1 is " << *ptr1 << std::endl;
std::unique_ptr<std::string> ptr2 = std::make_unique<std::string>("make_unique init!");
std::cout << "ptr2 is " << *ptr2 << std::endl;
return 0;
}
/*
输出：
ptr1 is unique_ptr
ptr2 is make_unique init!
*/
下面列出了unique_ptr特有的操作。
unique_ptr<T> u1 // 空unique_ptr，可以指向类型为T的对象。u1会使用delete来释放它的指针
unique_ptr<T, D> u2 // u2会使用一个类型为D的可调用对象来释放它的指针
unique_ptr<T, D> u(d) // 空unique_ptr，指向类型为T的对象，用类型为D的对象d替代delete
u = nullptr // 释放u指向的对象，将u置为空
u.release() // u放弃对指针的控制权，返回指针，并将u置为空
u.reset() // 释放u指向的对象
u.reset(q) // 如果提供了内置指针q，另u指向这个对象；否则将u置为空
u.reset(nullptr)
虽然我们不能拷贝或赋值unique_ptr,但可以通过调用release或reset将指针的所有权从一个（非const）unique_ptr转移到另一个unique_ptr
unique_ptr<string> p1(new string("Stegosaurus"));
// 将所有权从pl (指向string Stegosaurus)转移给p2
unique_ptr<string> p2(p1, release()); // release 将 p1 置为空
unique_ptr<string> p3(new string("Trex"));
// 将所有权从p3转移给p2
p2.reset(p3.release()); // reset 释放了 p2 原来指向的内存
调用release会切断unique_ptr和它原来管理的对象间的联系，如果我们不用另一个智能指针来保存release返回的指针，我们的程序就要负责资源的释放：
p2.release(); // 错误：p2不会释放内存，而且我们丢失了指针
auto p = p2.release(); // 正确，但我们必须记得 delete(p)
delete(p);
传递unique_ptr参数和返回unique_ptr
不能拷贝unique_ptr的规则有一个例外：我们可以拷贝或赋值一个将要被销毁的unique_ptr。最常见的例子是从函数返回一个unique_ptr;
unique_ptr<int> clone (int p)
{
unique_ptr<int> ret(new int (p));
// ...
return ret;
}
对于上面这段代码，编译器都知道要返回的对象将要被销毁。在此情况下，编译器执行一种特殊的“拷贝”，在《C++ Primer》13.6.2节（第473页）中有介绍。
性能与安全的权衡
使用智能指针虽然能够解决内存泄漏问题，但是也付出了一定的代价。以shared_ptr举例：
shared_ptr的大小是原始指针的两倍，因为它的内部有一个原始指针指向资源，同时有个指针指向引用计数。
引用计数的内存必须动态分配。虽然一点可以使用make_shared()来避免，但也存在一些情况下不能够使用make_shared（）。
增加和减小引用计数必须是原子操作，因为可能会有读写操作在不同的线程中同时发生。比如在一个线程里有一个指向一块资源的shared_ptr可能调用了析构（因此所指向的资源的引用计数减一），同时，在另一线程里，指向相同对象的一个shared_ptr可能执行了拷贝操作（因此，引用计数加一）。原子操作一般会比非原子操作慢。但是为了线程安全，又不得不这么做，这就给单线程使用环境带来了不必要的困扰。
|