《c++primer》笔记：动态内存

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

1.1 shared_ptr类

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

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

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

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

举个栗子：

//如果p1不为空 检测它是否指向一个空string
if(p1 && p1->empty())
    *p1="hi!"//如果p1指向一个空string 赋予其新值

下面第一张图中式shared_ptr和unique_ptr都支持的操作。只适用于shared_ptr的操作列在第二章表中。

make_shared函数

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

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

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

类似顺序容器的emplace成员，make_shared用其参数来构造给定类型的对象。例如，调用make_shared<string>时传递的参数必须与string的某个构造函数相匹配，调用make_shared<int>时传递的参数必须能用来初始化一个int，以此类推。如果我们不传递任何参数，对象就会进行值初始化。

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

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

shared_ptr的拷贝和赋值

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

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

我们可以认为每个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被自动释放。

shared_ptr自动销毁所管理的对象

当指向一个对象的最后一个shared_ptr被销毁时，shared_ptr类会自动销毁此对象。它是通过析构函数完成销毁工作的。类似于构造函数，每个类都有一个析构函数。就像构造函数控制初始化一样，析构函数控制此类型的对象销毁时做什么操作。

析构函数一般用来能释放对象分配的资源。例如，string的构造函数会分配内存来保存构成string的字符。string的析构函数就负责释放这些内存。类似的，vector的若干操作都会分配内存来保存其元素。vector的析构函数负责销毁这些元素，并释放它们所占用的内存。

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

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

当我们返回一个shared_ptr时，引用计数会增加。

note:如果将shared_ptr放在一个容器中，而后不再需要全部元素，而只使用其中的一部分，要记得用erase删除那些不再需要的shared_ptr元素

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

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

1.程序不知道自己需要使用多少对象

2.程序不知道所需对象的准确类型

3.程序需要在多个对象间共享数据

第一种情况是最典型的。

这里对第三种情况举个栗子

定义StrBlob类

我们用shared_ptr来管理动态分配的vector：

class StrBlob
{
public:
  typedef vector<string>::size_type size_type;
  StrBlob(/* args */);
  StrBlob(initializer_list<string>i1);
  size_type size() const {return data->size();}
  bool empty() const {return data->empty();}
  //添加和删除元素
  void push_back(const string &t) {data->push_back(t);}
  void pop_back();
  //元素访问
  string &front();
  string &back();
  ~StrBlob();
private:
  /* data */
  shared_ptr<vector<string>> data;
  void check(size_type i,const string &msg) const;
};

StrBlob::StrBlob(/* args */) : data(make_shared<vector<string>>()){}
StrBlob::StrBlob(initializer_list<string> i1) : data(make_shared<vector<string>>(i1)){}
StrBlob::~StrBlob()
{

}
void StrBlob::check(size_type i,const string &msg) const
{
  if(i>=data->size()) throw out_of_range(msg);
}
string& StrBlob::front()
{
  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();
}

类似Sales_data类，StrBlob使用默认版本的拷贝，赋值和销毁成员函数来对此类型的对象进行这些操作。当我们拷贝，赋值或销毁一个StrBlob对象时，它的shared_ptr成员会被拷贝，赋值或销毁。

1.2直接管理内存

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

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

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

int *pi=new int;
string *ps=new string;
//指定初值
int *pi=new int(1024);
string *ps=new string(10,'9');
vector<int> *pv= new vector<int>{1,2,3}

动态分配的const对象

const int *pci=new const int(1024);
const int *pcs=new const string;

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

内存耗尽

一旦一个程序用光了它所有可用的内存，new表达式就会失败，默认情况下如果分配失败，new会抛出一个类型为bad_alloc的异常，我们可以改变使用new的方式来阻止它抛出异常。

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

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

释放动态内存

为了防止内存耗尽，在动态内存使用完毕之后，必须将其归还给系统。我们通过delete表达式来将动态内存归还给系统。

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

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

指针值和delete

我们传递给delete的指针必须指向动态分配的内存，或者是一个空指针。

动态内存的管理非常容易出错

常见三个问题如下：

1.忘记delete

2.使用已经释放的对象

3.同一块内存释放两次

1.3 shared_ptr和new结合使用

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

shared_ptr<double> p1;
shared_ptr<int> p2(new int(42));

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

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

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

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

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

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

举个例子：

上面的例子中不会出现错误，但是如果我们强转一个内置指针就很可能出现错误：

这里由于原来是一个内置指针，在函数里边仍然会由shared_ptr来处理，所以这样在出函数之后引用计数为0，内存会被释放。

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

1.4智能指针和异常

智能指针和哑类

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

那些分配了资源，又没有定义析构函数来释放这些资源的类，可能会遇到与使用动态内存相同的错误。即忘记释放资源。

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

使用我们自己的释放操作

当p被销毁时，它不会对自己保存的指针执行delete，而是调用end_connection。接下来，end_connection会调用disconnect，从而确保连接被关闭。如果f正常退出，那么p的销毁会作为结束处理的一部分。如果发生了异常，p同样会被瞎弄会，从而连接被关闭。

智能指针陷阱

为了正确使用智能指针，我们必须坚持一些基本规范：

不使用相同的内置指针值（或reset）初始化多个智能指针
不delete get()返回的指针
不使用get()初始化或reset另一个智能指针
如果你使用get()返回的指针，记住当最后一个对应的智能指针销毁后，指针就变得无效了
如果你使用智能指针管理的资源不是new返回的内存，记住传递给它一个删除器

1.5unique_pte

一个unique_ptr拥有它所指向的对象。与shared_pte不同，某个时刻只能有一个unique_pte指向一个给定对象。

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

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

unique_ptr的一些操作如下所示：

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

调用release会切断unique_pte和它原来管理的对象间的联系。release返回的指针通常被用来初始化另一个智能指针或给另一个智能指针赋值。在本例中，管理内存的责任简单地从一个智能指针赋值。但是，如果我们不用另一个智能指针来保存release返回的指针，我们的程序就要负责资源的释放：

传递unique_ptr参数和返回unique_pte

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

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

向unique_ptr传递删除器

类似shared_ptr，unique_ptr默认情况下使用delete释放它所指的对象。于shared_ptr一样，我们可以重载一个unique_ptr中默认的删除器。

1.6weak_ptr

weak_ptr是一种不受所指向对象生存周期的智能指针，它指向由一个shared_ptr管理的对象。将一个weak_ptr绑定到一个shared_ptr管理的对象。将一个weak_ptr绑定到一个shared_ptr上不会改变shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放。即使有weak_ptr指向对象，对象也还是会被释放。