【C++基础】系列博客为参考《C++ Primer中文版（第5版）》（C++11标准）一书，自己所做的读书笔记。
本文为原创文章，未经本人允许，禁止转载。转载请注明出处。

1.动态内存与智能指针

到目前为止，我们编写的程序中所使用的对象都有着严格定义的生存期。全局对象在程序启动时分配，在程序结束时销毁。对于局部自动对象，当我们进入其定义所在的程序块时被创建，在离开块时销毁。局部static对象在第一次使用前分配，在程序结束时销毁。

除了自动和static对象外，C++还支持动态分配对象。动态分配的对象的生存期与它们在哪里创建是无关的，只有当显式地被释放时，这些对象才会销毁。

动态对象的正确释放被证明是编程中极其容易出错的地方。为了更安全地使用动态对象，标准库定义了两个智能指针类型来管理动态分配的对象。当一个对象应该被释放时，指向它的智能指针可以确保自动地释放它。

我们的程序到目前为止只使用过静态内存或栈内存。静态内存用来保存局部static对象、类static数据成员以及定义在任何函数之外的变量。栈内存用来保存定义在函数内的非static对象。分配在静态或栈内存中的对象由编译器自动创建和销毁。对于栈对象，仅在其定义的程序块运行时才存在；static对象在使用之前分配，在程序结束时销毁。

除了静态内存和栈内存，每个程序还拥有一个内存池。这部分内存被称作自由空间（free store）和堆（heap）。程序用堆来存储动态分配（dynamically allocate）的对象——即，那些在程序运行时分配的对象。动态对象的生存期由程序来控制，也就是说，当动态对象不再使用时，我们的代码必须显式地销毁它们。

在C++中，动态内存的管理是通过一对运算符来完成的：new，在动态内存中为对象分配空间并返回一个指向该对象的指针，我们可以选择对对象进行初始化；delete，接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。

动态内存的使用很容易出问题，因为确保在正确的时间释放内存是极其困难的。有时我们会忘记释放内存，在这种情况下就会产生内存泄漏；有时在尚有指针引用内存的情况下我们就释放了它，在这种情况下就会产生引用非法内存的指针。

为了更容易（同时也更安全）地使用动态内存，新的标准库提供了两种智能指针（smart pointer）类型来管理动态对象。智能指针的行为类似常规指针，重要的区别是它负责自动释放所指向的对象。新标准库提供的这两种智能指针的区别在于管理底层指针的方式：shared_ptr允许多个指针指向同一个对象；unique_ptr则“独占”所指向的对象。标准库还定义了一个名为weak_ptr的伴随类，它是一种弱引用，指向shared_ptr所管理的对象。这三种类型都定义在memory头文件中。

2.shared_ptr类

类似vector，智能指针也是模板。因此，当我们创建一个智能指针时，必须提供额外的信息——指针可以指向的类型。与vector一样，我们在尖括号内给出类型，之后是所定义的这种智能指针的名字：

shared_ptr<string> p1;//shared_ptr，可以指向string
shared_ptr<list<int>> p2;//shared_ptr，可以指向int的list

默认初始化的智能指针中保存着一个空指针。

智能指针的使用方式与普通指针类似。解引用一个智能指针返回它指向的对象。如果在一个条件判断中使用智能指针，效果就是检测它是否为空：

//p1用于检查是否是一个空指针，比如默认初始化就是一个空指针
//p1->empty()用于检查p1所指向的string是不是一个空字符串
if (p1 && p1->empty())
	*p1 = "hi";

表12.1列出了shared_ptr和unique_ptr都支持的操作。只适用于shared_ptr的操作列于表12.2中。

2.1.make_shared函数

最安全的分配和使用动态内存的方法是调用一个名为make_shared的标准库函数。此函数在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr。与智能指针一样，make_shared也定义在头文件memory中。

当要用make_shared时，必须指定想要创建的对象的类型。定义方式与模板类相同，在函数名之后跟一个尖括号，在其中给出类型：

//指向一个值为42的int的shared_ptr
shared_ptr<int> p3 = make_shared<int>(42);
//p4指向一个值为"9999999999"的string
shared_ptr<string> p4 = make_shared<string>(10,'9');
//p5指向一个值初始化的int，即，值为0
shared_ptr<int> p5 = make_shared<int>();

当然，我们通常用auto定义一个对象来保存make_shared的结果，这种方式较为简单：

//p6指向一个动态分配的空vector<string>
auto p6 = make_shared<vector<string>>();

2.2.shared_ptr的拷贝和赋值

当进行拷贝或赋值操作时，每个shared_ptr都会记录有多少个其他shared_ptr指向相同的对象：

auto p = make_shared<int>(42);//p指向的对象只有p一个引用者
auto q(p);//p和q指向相同对象，此对象有两个引用者

我们可以认为每个shared_ptr都有一个关联的计数器，通常称其为引用计数（reference count）。无论何时我们拷贝一个shared_ptr，计数器都会递增。例如，当用一个shared_ptr初始化另一个shared_ptr，或将它作为参数传递给一个函数以及作为函数的返回值时，它所关联的计数器就会递增。当我们给shared_ptr赋予一个新值或是shared_ptr被销毁（例如一个局部的shared_ptr离开其作用域）时，计数器就会递减。

一旦一个shared_ptr的计数器变为0，它就会自动释放自己所管理的对象：

auto r = make_shared<int>(42);//r指向的int只有一个引用者
r = q;
//给r赋值，令它指向另一个地址
//递增q指向的对象的引用计数
//递减r原来指向的对象的引用计数
//r原来指向的对象已没有引用者，会自动释放

此例中我们分配了一个int，将其指针保存在r中。接下来，我们将一个新值赋予r。在此情况下，r是唯一指向此int的shared_ptr，在把q赋给r的过程中，此int被自动释放。

int main(int argc, char** argv) {
    string s = "hi";
    string *ps1 = &s; 
    string *ps2 = &s; 
    cout << ps1 << endl; //0x7ff7bfeff2a8
    cout << ps2 << endl; //0x7ff7bfeff2a8，和ps1是一样的，都指向s
    shared_ptr<string> p1 = make_shared<string>(s);
    cout << "p1 : " << p1 << endl; //p1 : 0x600000c5fbb8，申请一块动态内存，并用s去初始化这块内存上的内容，但并不指向s
    cout << *p1 << endl; //hi
    cout << p1.use_count() << endl; //1
    shared_ptr<string> p2 = make_shared<string>(s);
    cout << "p2 : " << p2 << endl; //p2 : 0x600000c5fb88，再申请一块动态内存（和p1不同），也用s去初始化这块内存上的内容，同样不指向s
    cout << *p2 << endl; //hi
    cout << p1.use_count() << endl; //1
    cout << p2.use_count() << endl; //1
    s = "hello";
    cout << *p1 << endl; //hi
    cout << *p2 << endl; //hi
    cout << *ps1 << endl; //hello
    cout << *ps2 << endl; //hello
    return 0;
}

2.3.shared_ptr自动销毁所管理的对象

当指向一个对象的最后一个shared_ptr被销毁时，shared_ptr类会自动销毁此对象。它是通过另一个特殊的成员函数——析构函数（destructor）完成销毁工作的。类似于构造函数，每个类都有一个析构函数。就像构造函数控制初始化一样，析构函数控制此类型的对象销毁时做什么操作。析构函数一般用来释放对象所分配的资源。

shared_ptr的析构函数会递减它所指向的对象的引用计数。如果引用计数变为0，shared_ptr的析构函数就会销毁对象，并释放它占用的内存。

2.4.shared_ptr还会自动释放相关联的内存

当动态对象不再被使用时，shared_ptr类会自动释放动态对象，这一特性使得动态内存的使用变得非常容易。例如，我们可能有一个函数，它返回一个shared_ptr，指向一个Foo类型的动态分配的对象，对象是通过一个类型为T的参数进行初始化的：

//factory返回一个shared_ptr，指向一个动态分配的对象
shared_ptr<Foo> factory(T arg)
{
	//恰当地处理arg
	//shared_ptr负责释放内存
	return make_shared<Foo>(arg);
}

由于factory返回一个shared_ptr，所以我们可以确保它分配的对象会在恰当的时刻被释放。例如，下面的函数将factory返回的shared_ptr保存在局部变量中：

void use_factory(T arg)
{
	shared_ptr<Foo> p = factory(arg);
	//使用p
} //p离开了作用域，它指向的内存会被自动释放掉

由于p是use_factory的局部变量，在use_factory结束时它将被销毁。当p被销毁时，将递减其引用计数并检查它是否为0。在此例中，p是唯一引用factory返回的内存的对象。由于p将要销毁，p指向的这个对象也会被销毁，所占用的内存会被释放。

但如果有其他shared_ptr也指向这块内存，它就不会被释放掉：

void use_factory(T arg)
{
	shared_ptr<Foo> p = factory(arg);
	//使用p
	return p; //当我们返回p时，引用计数进行了递增操作
} //p离开了作用域，但它指向的内存不会被释放掉

在此版本中，use_factory中的return语句向此函数的调用者返回一个p的拷贝。拷贝一个shared_ptr会增加所管理对象的引用计数值。现在当p被销毁时，它所指向的内存还有其他使用者。对于一块内存，shared_ptr类保证只要有任何shared_ptr对象引用它，它就不会被释放掉。

由于在最后一个shared_ptr销毁前内存都不会释放，保证shared_ptr在无用之后不再保留就非常重要了。如果你忘记了销毁程序不再需要的shared_ptr，程序仍会正确执行，但会浪费内存。shared_ptr在无用之后仍然保留的一种可能情况是，你将shared_ptr存放在一个容器中，随后重排了容器，从而不再需要某些元素。在这种情况下，你应该确保用erase删除那些不再需要的shared_ptr元素。

2.5.使用了动态生存期的资源的类

程序使用动态内存出于以下三种原因之一：

程序不知道自己需要使用多少对象
程序不知道所需对象的准确类型
程序需要在多个对象间共享数据

容器类是出于第一种原因而使用动态内存的典型例子。在本节中，我们将定义一个类，它使用动态内存是为了让多个对象能共享相同的底层数据。

到目前为止，我们使用过的类中，分配的资源都与对应对象生存期一致。例如，每个vector“拥有”其自己的元素。当我们拷贝一个vector时，原vector和副本vector中的元素是相互分离的：

vector<string> v1; //空vector
{ //新作用域
	vector<string> v2 = {"a","an","the"};
	v1 = v2; //从v2拷贝元素到v1中
}
//v2被销毁，其中的元素也被销毁
//v1有三个元素，是原来v2中元素的拷贝

由一个vector分配的元素只有当这个vector存在时才存在。当一个vector被销毁时，这个vector中的元素也都被销毁。

但某些类分配的资源具有与原对象相独立的生存期。例如，假定我们希望定义一个名为Blob的类，保存一组元素。与容器不同，我们希望Blob对象的不同拷贝之间共享相同的元素。即，当我们拷贝一个Blob时，原Blob对象及其拷贝应该引用相同的底层元素。

一般而言，如果两个对象共享底层的数据，当某个对象被销毁时，我们不能单方面地销毁底层数据：

Blob<string> b1; //空Blob
{ //新作用域
	Blob<string> b2 = {"a","an","the"};
	b1 = b2; //b1和b2共享相同的元素
}
//b2被销毁了，但b2中的元素不能销毁
//b1指向最初由b2创建的元素

2.6.定义StrBlob类

现在我们先定义一个管理string的类，此版本命名为StrBlob。实现一个新的集合类型的最简单方法是使用某个标准库容器来管理元素。采用这种方法，我们可以借助标准库类型来管理元素所使用的内存空间。在本例中，我们将使用vector来保存元素。

但是，我们不能在一个Blob对象内直接保存vector，因为一个对象的成员在对象销毁时也会被销毁。例如，假定b1和b2是两个Blob对象，共享相同的vector。如果此vector保存在其中一个Blob中——例如是b2中，那么当b2离开作用域时，此vector也将被销毁，也就是说其中的元素都将不复存在。为了保证vector中的元素继续存在，我们将vector保存在动态内存中。

为了实现我们所希望的数据共享，我们为每个StrBlob设置一个shared_ptr来管理动态分配的vector。此shared_ptr的成员将记录有多少个StrBlob共享相同的vector，并在vector的最后一个使用者被销毁时释放vector。

我们的类有一个默认构造函数和一个构造函数，接受单一的initializer_list<string>类型参数。此构造函数可以接受一个初始化器的花括号列表。

class StrBlob{
public:
	typedef std::vector<std::string>::size_type size_type;
	StrBlob();
	StrBlob(std::initializer_list<std::string> il);
	size_type size() const { return data->size(); } //const成员函数
	bool empty() const { return data->empty(); }
	//添加和删除元素
	void push_back(const std::string &t) { data->push_back(t); }
	void pop_back();
	//元素访问
	std::string& front();
	std::string& back();
private:
	std::shared_ptr<std::vector<std::string>> data;
	//如果data[i]不合法，抛出一个异常
	void check(size_type i, const std::string &msg) const; //const成员函数
};

const成员函数。

2.7.StrBlob构造函数

两个构造函数都使用初始化列表来初始化其data成员，令它指向一个动态分配的vector。默认构造函数分配一个空vector：

StrBlob::StrBlob() : data(make_shared<vector<string>>()) { } //构造函数初始值列表
StrBlob::StrBlob(initializer_list<string> il) : data(make_shared<vector<string>>(il)) { }

构造函数初始值列表。

接受一个initializer_list的构造函数将其参数传递给对应的vector构造函数。此构造函数通过拷贝列表中的值来初始化vector的元素。

2.8.元素访问成员函数

我们为StrBlob定义了一个名为check的private工具函数，它检查一个给定索引是否在合法范围内。除了索引，check还接受一个string参数，它会将此参数传递给异常处理程序，这个string描述了错误内容：

void StrBlob::check(size_type i, const string &msg) const
{
	if( i >= data->size())
		throw out_of_range(msg);
}

throw表达式。

pop_back和元素访问成员函数首先调用check。如果check成功，这些成员函数继续利用底层vector的操作来完成自己的工作：

string& StrBlob::front()
{
	//如果vector为空，check会抛出一个异常
	check(0, "front on empty StrBlob");
	return data->front();
}
string& StrBlob::back()
{
	check(0, "back on empty StrBlob");
	return data->back();
}
void StrBlob::pop_back()
{
	check(0, "pop_back on empty StrBlob");
	data->pop_back();
}

2.9.StrBlob的拷贝、赋值和销毁

StrBlob使用默认版本的拷贝、赋值和销毁成员函数来对此类型的对象进行这些操作（参见拷贝、赋值和析构）。默认情况下，这些操作拷贝、赋值和销毁类的数据成员。我们的StrBlob类只有一个数据成员，它是shared_ptr类型。因此，当我们拷贝、赋值或销毁一个StrBlob对象时，它的shared_ptr成员会被拷贝、赋值或销毁。

3.直接管理内存

C++语言定义了两个运算符来分配和释放动态内存。运算符new分配内存，delete释放new分配的内存。

相对于智能指针，使用这两个运算符管理内存非常容易出错。而且，自己直接管理内存的类与使用智能指针的类不同，它们不能依赖类对象拷贝、赋值和销毁操作的任何默认定义。因此，使用智能指针的程序更容易编写和调试。

3.1.使用new动态分配和初始化对象

在自由空间分配的内存是无名的，因此new无法为其分配的对象命名，而是返回一个指向该对象的指针：

int *pi = new int; //pi指向一个动态分配的、未初始化的无名对象

此new表达式在自由空间构造一个int型对象，并返回指向该对象的指针。

默认情况下，动态分配的对象是默认初始化的，这意味着内置类型或组合类型的对象的值将是未定义的，而类类型对象将用默认构造函数进行初始化：

string *ps = new string; //初始化为空string
int *pi = new int; //pi指向一个未初始化的int

我们可以使用直接初始化方式来初始化一个动态分配的对象。我们可以使用传统的构造方式（使用圆括号），在新标准下，也可以使用列表初始化（使用花括号）：

int *pi = new int(1024); //pi指向的对象的值为1024
string *ps = new string(10,'9'); //*ps为"9999999999"
//vector有10个元素，值依此从0到9
vector<int> *pv = new vector<int>(0,1,2,3,4,5,6,7,8,9);

也可以对动态分配的对象进行值初始化，只需在类型名之后跟一对空括号即可：

string *ps1 = new string; //默认初始化为空string
string *ps = new string(); //值初始化为空string
int *pi1 = new int; //默认初始化；*pi1的值未定义
int *pi2 = new int(); //值初始化为0；*pi2为0

对于定义了自己的构造函数的类类型（例如string）来说，要求值初始化是没有意义的；不管采用什么形式，对象都会通过默认构造函数来初始化。但对于内置类型，两种形式的差别就很大了；值初始化的内置类型对象有着良好定义的值，而默认初始化的对象的值则是未定义的。类似的，对于类中那些依赖于编译器合成的默认构造函数的内置类型成员，如果它们未在类内被初始化，那么它们的值也是未定义的。

如果我们提供了一个括号包围的初始化器，就可以使用auto从此初始化器来推断我们想要分配的对象的类型。但是，由于编译器要用初始化器的类型来推断要分配的类型，只有当括号中仅有单一初始化器时才可以使用auto：

auto p1 = new auto(obj); //p指向一个与obj类型相同的对象，该对象用obj进行初始化
auto p2 = new auto(a,b,c); //错误：括号中只能有单个初始化器

p1的类型是一个指针，指向从obj自动推断出的类型。若obj是一个int，那么p1就是int*；若obj是一个string，那么p1是一个string*；依此类推。新分配的对象用obj的值进行初始化。

3.2.动态分配的const对象

用new分配const对象是合法的：

//分配并初始化一个const int
const int *pci = new const int(1024);
//分配并默认初始化一个const的空string
const string *pcs = new const string;

类似其他任何const对象，一个动态分配的const对象必须进行初始化。对于一个定义了默认构造函数的类类型，其const动态对象可以隐式初始化，而其他类型的对象就必须显式初始化。由于分配的对象是const的，new返回的指针是一个指向const的指针。

3.3.内存耗尽

虽然现代计算机通常都配备大容量内存，但是自由空间被耗尽的情况还是有可能发生。一旦一个程序用光了它所有可用的内存，new表达式就会失败。默认情况下，如果new不能分配所要求的内存空间，它会抛出一个类型为bad_alloc的异常。我们可以改变使用new的方式来阻止它抛出异常：

//如果分配失败，new返回一个空指针
int *p1 = new int; //如果分配失败，new抛出std::bad_alloc
int *p2 = new (nothrow) int; //如果分配失败，new返回一个空指针

我们称这种形式的new为定位new（placement new）。定位new表达式允许我们向new传递额外的参数。在此例中，我们传递给它一个由标准库定义的名为nothrow的对象。如果将nothrow传递给new，我们的意图是告诉它不能抛出异常。如果这种形式的new不能分配所需内存，它会返回一个空指针。bad_alloc和nothrow都定义在头文件new中。

3.4.释放动态内存

为了防止内存耗尽，在动态内存使用完毕后，必须将其归还给系统。我们通过delete表达式（delete expression）来将动态内存归还给系统。delete表达式接受一个指针，指向我们想要释放的对象：

delete p; //p必须指向一个动态分配的对象或是一个空指针

与new类型类似，delete表达式也执行两个动作：销毁给定的指针指向的对象；释放对应的内存。

3.5.指针值和delete

我们传递给delete的指针必须指向动态分配的内存，或者是一个空指针。释放一块并非new分配的内存，或者将相同的指针值释放多次，其行为是未定义的：

int i, *pi1 = &i, *pi2 = nullptr;
double *pd = new double(33), *pd2 = pd;
delete i; //错误：i不是一个指针
delete pi1; //未定义：pi1指向一个局部变量
delete pd; //正确
delete pd2; //未定义：pd2指向的内存已经被释放了
delete pi2; //正确：释放一个空指针总是没有错误的

对于delete i的请求，编译器会生成一个错误信息，因为它知道i不是一个指针。执行delete pi1和pd2所产生的错误则更具潜在危害：通常情况下，编译器不能分辨一个指针指向的是静态还是动态分配的对象。类似的，编译器也不能分辨一个指针所指向的内存是否已经被释放了。对于这些delete表达式，大多数编译器会编译通过，尽管它们是错误的。

虽然一个const对象的值不能被改变，但它本身是可以被销毁的。如同任何其他动态对象一样，想要释放一个const动态对象，只要delete指向它的指针即可：

const int *pci = new const int(1024);
delete pci; //正确：释放一个const对象

3.6.动态对象的生存期直到被释放时为止

如前所述，由shared_ptr管理的内存在最后一个shared_ptr销毁时会被自动释放。但对于通过内置指针类型来管理的内存，就不是这样了。对于一个由内置指针管理的动态对象，直到被显式释放之前它都是存在的。

返回指向动态内存的指针（而不是智能指针）的函数给其调用者增加了一个额外负担——调用者必须记得释放内存：

//factory返回一个指针，指向一个动态分配的对象
Foo* factory(T arg)
{
	//视情况处理arg
	return new Foo(arg); //调用者负责释放此内存
}

void use_factory(T arg)
{
	Foo *p = factory(arg);
	//使用p但不delete它
} //p离开了它的作用域，但它所指向的内存没有被释放！

当use_factory返回时，局部变量p被销毁。此变量是一个内置指针，而不是一个智能指针。

与类类型不同，内置类型的对象被销毁时什么也不会发生。特别是，当一个指针离开其作用域时，它所指向的对象什么也不会发生。如果这个指针指向的是动态内存，那么内存将不会被自动释放。

在本例中，p是指向factory分配的内存的唯一指针。一旦use_factory返回，程序就没有办法释放这块内存了。根据整个程序的逻辑，修正这个错误的正确方法是在use_factory中记得释放内存：

void use_factory(T arg)
{
	Foo *p = factory(arg);
	//使用p
	delete p; //现在记得释放内存，我们已经不需要它了
}

还有一种可能，我们的系统中的其他代码要使用use_factory所分配的对象，我们就应该修改此函数，让它返回一个指针，指向它分配的内存：

Foo* use_factory(T arg)
{
	Foo *p = factory(arg);
	//使用p
	return p; //调用者必须释放内存
}

使用new和delete管理动态内存存在三个常见问题：

忘记delete内存。忘记释放动态内存会导致人们常说的“内存泄漏”问题，因为这种内存永远不可能被归还给自由空间了。查找内存泄漏错误是非常困难的，因为通常应用程序运行很长时间后，真正耗尽内存时，才能检测到这种错误。

使用已经释放掉的对象。通过在释放内存后将指针置为空，有时可以检测出这种错误。

同一块内存释放两次。当有两个指针指向相同的动态分配对象时，可能发生这种错误。如果对其中一个指针进行了delete操作，对象的内存就被归还给自由空间了。如果我们随后又delete第二个指针，自由空间就可能被破坏。

坚持只使用智能指针，就可以避免所有这些问题。对于一块内存，只有在没有任何智能指针指向它的情况下，智能指针才会自动释放它。

3.7.delete之后重置指针值

当我们delete一个指针后，指针值就变为无效了。虽然指针已经无效，但在很多机器上指针仍然保存着（已经释放了的）动态内存的地址。在delete之后，指针就变成了人们所说的空悬指针（dangling pointer），即，指向一块曾经保存数据对象但现在已经无效的内存的指针。

未初始化指针的所有缺点空悬指针也都有。有一种方法可以避免空悬指针的问题：在指针即将要离开其作用域之前释放掉它所关联的内存。这样，在指针关联的内存被释放掉之后，就没有机会继续使用指针了（个人理解：就是释放掉指针自身占据的内存）。如果我们需要保留指针，可以在delete之后将nullptr赋予指针，这样就清楚地指出指针不指向任何对象。

3.8.这只是提供了有限的保护

动态内存的一个基本问题是可能有多个指针指向相同的内存。在delete内存之后重置指针的方法只对这个指针有效，对其他任何仍指向（已释放的）内存的指针是没有作用的。例如：

int *p(new int (42)); //p指向动态内存
auto q = p; //p和q指向相同的内存
delete p; //p和q均变为无效
p = nullptr; //指出p不再绑定到任何对象

重置p对q没有任何作用，在我们释放p所指向的（同时也是q所指向的！）内存时，q也变为无效了。在实际系统中，查找指向相同内存的所有指针是异常困难的。

4.shared_ptr和new结合使用

如前所述，如果我们不初始化一个智能指针，它就会被初始化为一个空指针。如表12.3所示，我们还可以用new返回的指针来初始化智能指针：

shared_ptr<double> p1; //shared_ptr可以指向一个double
shared_ptr<int> p2(new int(42)); //p2指向一个值为42的int

接受指针参数的智能指针构造函数是explicit的。因此，我们不能将一个内置指针隐式转换为一个智能指针，必须使用直接初始化形式来初始化一个智能指针：

shared_ptr<int> p1 = new int(1024); //错误：必须使用直接初始化形式
shared_ptr<int> p2(new int(1024)); //正确：使用了直接初始化形式

同理，一个返回shared_ptr的函数不能在其返回语句中隐式转换一个普通指针：

shared_ptr<int> clone(int p)
{
	return new int(p); //错误：隐式转换为shared_ptr<int>
}

我们必须将shared_ptr显式绑定到一个想要返回的指针上：

shared_ptr<int> clone(int p)
{
	//正确：显式地用int*创建shared_ptr<int>
	return shared_ptr<int>(new int(p));
}

默认情况下，一个用来初始化智能指针的普通指针必须指向动态内存，因为智能指针默认使用delete释放它所关联的对象。我们可以将智能指针绑定到一个指向其他类型的资源的指针上，但是为了这样做，必须提供自己的操作来替代delete。

4.1.不要混合使用普通指针和智能指针

shared_ptr可以协调对象的析构，但这仅限于其自身的拷贝（也是shared_ptr）之间。这也是为什么我们推荐使用make_shared而不是new的原因。这样，我们就能在分配对象的同时就将shared_ptr与之绑定，从而避免了无意中将同一块内存绑定到多个独立创建的shared_ptr上。

考虑下面对shared_ptr进行操作的函数：

//在函数被调用时ptr被创建并初始化
void process(shared_ptr<int> ptr)
{
	//使用ptr
} //ptr离开作用域，被销毁

process的参数是传值方式传递的，因此实参会被拷贝到ptr中。拷贝一个shared_ptr会递增其引用计数，因此，在process运行过程中，引用计数值至少为2。当process结束时，ptr的引用计数会递减，但不会变为0。因此，当局部变量ptr被销毁时，ptr指向的内存不会被释放。

使用此函数的正确方法是传递给它一个shared_ptr：

shared_ptr<int> p(new int(42)); //引用计数为1
process(p); //拷贝p会递增它的引用计数；在process中引用计数值为2
int i = *p; //正确：引用计数值为1

虽然不能传递给process一个内置指针，但可以传递给它一个（临时的）shared_ptr，这个shared_ptr是用一个内置指针显式构造的。但是，这样做很可能会导致错误：

int *x(new int(1024)); //危险：x是一个普通指针，不是一个智能指针
process(x); //错误：不能将int*转换为一个shared_ptr<int>
process(shared_ptr<int>(x)); //合法的，但内存会被释放！
int j = *x; //未定义的：x是一个空悬指针！

使用一个内置指针来访问一个智能指针所负责的对象是很危险的，因为我们无法知道对象何时会被销毁。

4.2.也不要使用get初始化另一个智能指针或为智能指针赋值

智能指针类型定义了一个名为get的函数（参见表12.1），它返回一个内置指针，指向智能指针管理的对象。此函数是为了这样一种情况而设计的：我们需要向不能使用智能指针的代码传递一个内置指针。使用get返回的指针的代码不能delete此指针。

虽然编译器不会给出错误信息，但将另一个智能指针也绑定到get返回的指针上是错误的：

shared_ptr<int> p(new int(42)); //引用计数为1
int *q = p.get(); //正确：但使用q时要注意，不要让它管理的指针被释放
{
	//新程序块
	//未定义：两个独立的shared_ptr指向相同的内存
	shared_ptr<int>(q);
} //程序块结束，q被销毁，它指向的内存被释放
int foo = *p; //未定义：p指向的内存已经被释放了

在本例中，p和q指向相同的内存。由于它们是相互独立创建的，因此各自的引用计数都是1。当q所在的程序块结束时，q被销毁，这会导致q指向的内存被释放。从而p变成一个空悬指针，意味着当我们试图使用p时，将发生未定义的行为。而且，当p被销毁时，这块内存会被第二次delete。

4.3.其他shared_ptr操作

shared_ptr还定义了其他一些操作，参见表12.2和表12.3所示。我们可以用reset来将一个新的指针赋予一个shared_ptr：

p = new int(1024); //错误：不能将一个指针赋予shared_ptr
p.reset(new int(1024)); //正确：p指向一个新对象

与赋值类似，reset会更新引用计数，如果需要的话，会释放p指向的对象。reset成员经常与unique一起使用，来控制多个shared_ptr共享的对象。在改变底层对象之前，我们检查自己是否是当前对象仅有的用户。如果不是，在改变之前要制作一份新的拷贝：

if (!p.unique())
	p.reset(new string(*p)); //我们不是唯一用户；分配新的拷贝
*p += newVal; //现在我们知道自己是唯一的用户，可以改变对象的值

5.智能指针和异常

如果使用智能指针，即使程序块过早结束，智能指针类也能确保在内存不再需要时将其释放：

void f()
{
	shared_ptr<int> sp(new int(42)); //分配一个新对象
	//这段代码抛出一个异常，且在f中未被捕获
} //在函数结束时shared_ptr自动释放内存

函数的退出有两种可能，正常处理结束或者发生了异常，无论哪种情况，局部对象都会被销毁。在上面的程序中，sp是一个shared_ptr，因此sp销毁时会检查引用计数。在此例中，sp是指向这块内存的唯一指针，因此内存会被释放掉。

与之相对的，当发生异常时，我们直接管理的内存是不会自动释放的。如果使用内置指针管理内存，且在new之后在对应的delete之前发生了异常，则内存不会被释放：

void f()
{
	int *ip = new int(42); //动态分配一个新对象
	//这段代码抛出一个异常，且在f中未被捕获
	delete ip; //在退出之前释放内存
}

如果在new和delete之间发生异常，且异常未在f中被捕获，则内存就永远不会被释放了。在函数f之外没有指针指向这块内存，因此就无法释放它了。

5.1.智能指针和哑类

包括所有标准库类在内的很多C++类都定义了析构函数，负责清理对象使用的资源。但是，不是所有的类都是这样良好定义的。特别是那些为C和C++两种语言设计的类，通常都要求用户显式地释放所使用的任何资源。

那些分配了资源，而又没有定义析构函数来释放这些资源的类，可能会遇到与使用动态内存相同的错误——程序员非常容易忘记释放资源。类似的，如果在资源分配和释放之间发生了异常，程序也会发生资源泄漏。

与管理动态内存类似，我们通常可以使用类似的技术来管理不具有良好定义的析构函数的类。例如，假定我们正在使用一个C和C++都使用的网络库，使用这个库的代码可能是这样的：

struct destination; //表示我们正在连接什么
struct connection; //使用连接所需的信息
connection connect(destination*); //打开连接
void disconnect(connection); //关闭给定的连接
void f(destination &d /* 其他参数 */)
{
	//获得一个连接；记住使用完后要关闭它
	connection c = connect(&d);
	//使用连接
	//如果我们在f退出前忘记调用disconnect，就无法关闭c了
}

如果connection有一个析构函数，就可以在f结束时由析构函数自动关闭连接。但是，connection没有析构函数。这个问题与我们上一个程序中使用shared_ptr避免内存泄漏几乎是等价的。使用shared_ptr来保证connection被正确关闭，已被证明是一种有效的方法。

5.2.使用我们自己的释放操作

默认情况下，shared_ptr假定它们指向的是动态内存。因此，当一个shared_ptr被销毁时，它默认地对它管理的指针进行delete操作。为了用shared_ptr来管理一个connection，我们必须首先定义一个函数来代替delete。这个删除器（deleter）函数必须能够完成对shared_ptr中保存的指针进行释放的操作。在本例中，我们的删除器必须接受单个类型为connection*的参数：

void end_connection(connection *p) { disconnect(*p); }

当我们创建一个shared_ptr时，可以传递一个（可选的）指向删除器函数的参数：

void f(destination &d /* 其他参数 */)
{
	connection c = connect(&d);
	shared_ptr<connection> p(&c, end_connection);
	//使用连接
	//当f退出时（即使是由于异常而退出），connection会被正确关闭
}

当p被销毁时，它不会对自己保存的指针执行delete，而是调用end_connection。

智能指针可以提供对动态分配的内存安全而又方便的管理，但这建立在正确使用的前提下。为了正确使用智能指针，我们必须坚持一些基本规范：

不使用相同的内置指针值初始化（或reset）多个智能指针。

不delete get()返回的指针。

不使用get()初始化或reset另一个智能指针。

如果你使用get()返回的指针，记住当最后一个对应的智能指针销毁后，你的指针就变为无效了。

如果你使用智能指针管理的资源不是new分配的内存，记住传递给它一个删除器。

6.unique_ptr

一个unique_ptr“拥有”它所指向的对象。与shared_ptr不同，某个时刻只能有一个unique_ptr指向一个给定对象。当unique_ptr被销毁时，它所指向的对象也被销毁。表12.4列出了unique_ptr特有的操作。与shared_ptr相同的操作列在表12.1中。

与shared_ptr不同，没有类似make_shared的标准库函数返回一个unique_ptr。当我们定义一个unique_ptr时，需要将其绑定到一个new返回的指针上。类似shared_ptr，初始化unique_ptr必须采用直接初始化形式：

unique_ptr<double> p1; //可以指向一个double的unique_ptr
unique_ptr<int> p2(new int(42)); //p2指向一个值为42的int

由于一个unique_ptr拥有它指向的对象，因此unique_ptr不支持普通的拷贝或赋值操作：

unique_ptr<string> p1(new string("Stegosaurus"));
unique_ptr<string> p2(p1); //错误：unique_ptr不支持拷贝
unique_ptr<string> p3;
p3 = p2; //错误：unique_ptr不支持赋值

虽然我们不能拷贝或赋值unique_ptr，但可以通过调用release或reset将指针的所有权从一个（非const）unique_ptr转移给另一个unique：

//将所有权从p1（指向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返回的指针通常被用来初始化另一个智能指针或给另一个智能指针赋值。在本例中，管理内存的责任简单地从一个智能指针转移给另一个。但是，如果我们不用另一个智能指针来保存release返回的指针，我们的程序就要负责资源的释放：

p2.release(); //错误：p2不会释放内存，而且我们丢失了指针
auto p = p2.release(); //正确，但我们必须记得delete(p)

6.1.传递unique_ptr参数和返回unique_ptr

不能拷贝unique_ptr的规则有一个例外：我们可以拷贝或赋值一个将要被销毁的unique_ptr。最常见的例子是从函数返回一个unique_ptr：

unique_ptr<int> clone(int p)
{
	//正确：从int*创建一个unique_ptr<int>
	return unique_ptr<int>(new int(p));
}

还可以返回一个局部对象的拷贝：

unique_ptr<int> clone(int p)
{
	unique_ptr<int> ret(new int(p));
	// ...
	return ret;
}

对于两段代码，编译器都知道要返回的对象将要被销毁。在此情况下，编译器执行一种特殊的“拷贝”。

向后兼容：auto_ptr

标准库的较早版本包含了一个名为auto_ptr的类，它具有unique_ptr的部分特性，但不是全部。特别是，我们不能在容器中保存auto_ptr，也不能从函数中返回auto_ptr。

虽然auto_ptr仍是标准库的一部分，但编写程序时应该使用unique_ptr。

6.2.向unique_ptr传递删除器

类似shared_ptr，unique_ptr默认情况下用delete释放它指向的对象。与shared_ptr一样，我们可以重载一个unique_ptr中默认的删除器。但是，unique_ptr管理删除器的方式与shared_ptr不同。

重载一个unique_ptr中的删除器会影响到unique_ptr类型以及如何构造（或reset）该类型的对象。与重载关联容器的比较操作类似，我们必须在尖括号中unique_ptr指向类型之后提供删除器类型。在创建或reset一个这种unique_ptr类型的对象时，必须提供一个指定类型的可调用对象（删除器）：

//p指向一个类型为objT的对象，并使用一个类型为delT的对象释放objT对象
//它会调用一个名为fcn的delT类型对象
unique_ptr<objT, delT> p (new objT, fcn);

作为一个更具体的例子，我们将重写连接程序，用unique_ptr来代替shared_ptr，如下所示：

void f(destination &d /* 其他需要的参数 */)
{
	connection c = connect(&d); //打开连接
	//当p被销毁时，连接将会关闭
	unique_ptr<connection, decltype(end_connection)*> p(&c, end_connection);
	//使用连接
	//当f退出时（即使是由于异常而退出），connection会被正确关闭
}

在本例中我们使用了decltype来指明函数指针类型。由于decltype(end_connection)返回一个函数类型，所以我们必须添加一个*来指出我们正在使用该类型的一个指针。

7.weak_ptr

weak_ptr（见表12.5）是一种不控制所指向对象生存期的智能指针，它指向由一个shared_ptr管理的对象。将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放。即使有weak_ptr指向对象，对象也还是会被释放，因此，weak_ptr的名字抓住了这种智能指针“弱”共享对象的特点。

当我们创建一个weak_ptr时，要用一个shared_ptr来初始化它：

auto p = make_shared<int>(42);
weak_ptr<int> wp(p); //wp弱共享p；p的引用计数未改变

本例中wp和p指向相同的对象。由于是弱共享，创建wp不会改变p的引用计数；wp指向的对象可能被释放掉。

由于对象可能不存在，我们不能使用weak_ptr直接访问对象，而必须调用lock。此函数检查weak_ptr指向的对象是否仍存在。如果存在，lock返回一个指向共享对象的shared_ptr。与任何其他shared_ptr类似，只要此shared_ptr存在，它所指向的底层对象也就会一直存在。例如：

if (shared_ptr<int> np = wp.lock())
{
	//如果np不为空则条件成立
	//在if中，np与p共享对象
}

7.1.核查指针类

作为weak_ptr用途的一个展示，我们将为StrBlob类定义一个伴随指针类。我们的指针类将命名为StrBlobPtr，会保存一个weak_ptr，指向StrBlob的data成员，这是初始化时提供给它的。通过使用weak_ptr，不会影响一个给定的StrBlob所指向的vector的生存期。但是，可以阻止用户访问一个不再存在的vector的企图。

StrBlobPtr会有两个数据成员：wptr，或者为空，或者指向一个StrBlob中的vector；curr，保存当前对象所表示的元素的下标。类似它的伴随类StrBlob，我们的指针类也有一个check成员来检查解引用StrBlobPtr是否安全：

//对于访问一个不存在元素的尝试，StrBlobPtr抛出一个异常
class StrBlobPtr
{
public:
	StrBlobPtr() : curr(0) { }
	StrBlobPtr(StrBlob &a, size_t sz = 0) : wptr(a.data), curr(sz) { }
	std::string& deref() const;
	StrBlobPtr& incr(); //前缀递增
private:
	//若检查成功，check返回一个指向vector的shared_ptr
	std::shared_ptr<std::vector<std::string>> check(std::size_t, const std::string&) const;
	//保存一个weak_ptr，意味着底层vector可能会被销毁
	std::weak_ptr<std::vector<std::string>> wptr;
	std::size_t curr; //在数组中的当前位置
};

值得注意的是，我们不能将StrBlobPtr绑定到一个const StrBlob对象。这个限制是由于构造函数接受一个非const StrBlob对象的引用而导致的。

StrBlobPtr的check成员与StrBlob中的同名成员不同，它还要检查指针指向的vector是否还存在：

std::shared_ptr<std::vector<std::string>>
StrBlobPtr::check(std::size_t i, const std::string &msg) const
{
	auto ret = wptr.lock(); //vector还存在吗？
	if (!ret)
		throw std::runtime_error("unbound StrBlobPtr");
	if (i >= ret->size())
		throw std::out_of_range(msg);
	return ret; //否则，返回指向vector的shared_ptr
}

7.2.指针操作

现在，我们将定义名为deref和incr的函数，分别用来解引用和递增StrBlobPtr。

deref成员调用check，检查使用vector是否安全以及curr是否在合法范围内：

std::string& StrBlobPtr::deref() const
{
	auto p = check(curr, "dereference past end");
	return (*p)[curr]; //(*p)是对象所指向的vector
}

incr成员也调用check：

//前缀递增：返回递增后的对象的引用
StrBlobPtr& StrBlobPtr::incr()
{
	//如果curr已经指向容器的尾后位置，就不能递增它
	check(curr, "increment past end of StrBlobPtr");
	++curr; //推进当前位置
	return *this;
}

当然，为了访问data成员，我们的指针类必须声明为StrBlob的friend。我们还要为StrBlob类定义begin和end操作，返回一个指向它自身的StrBlobPtr：

//对于StrBlob中的友元声明来说，此前置声明是必要的
class StrBlobPtr;
class StrBlob {
	friend class StrBlobPtr;
	//其他成员与第2.6部分中声明相同
	//返回指向首元素和尾后元素的StrBlobPtr
	StrBlobPtr begin() { return StrBlobPtr(*this); }
	StrBlobPtr end() 
		{ auto ret = StrBlobPtr(*this, data->size());
		  return ret; }
};

【C++基础】第六十六课：[动态内存]动态内存与智能指针

动态内存，智能指针，shared_ptr，make_shared，new，delete，空悬指针，unique_ptr，weak_ptr