《C++ Primer》第12章 动态内存（二）

参考资料：

• 《C++ Primer》第5版
• 《C++ Primer 习题集》第5版

12.1.5 unique_ptr（P417）

unique “拥有”它所指向的对象，某个时刻只能有一个 unique_ptr 指向一个给定对象。

当我们定义一个 unique_ptr 时，需要将其绑定到一个 new 返回的指针上，且必须采用直接初始化的形式：

unique_ptr<double> p1;    // 空unique_ptr
unique_ptr<int> p2(new int());    // 指向一个值初始化的int

unique_ptr 不支持普通的拷贝和赋值操作：

unique_ptr<string> p1(new string("hello"));
unique_ptr<string> p2(p1);    // 错误
unique_ptr<string> p3;
p3 = p2;    // 错误

我们可以通过 release 或 reset 将指针的所有权从一个（非 const ）unique_ptr 转移给另一个 unique_ptr ：

unique_ptr<string> p1(new string("hello"));
unique_ptr<string> p2(p1.release());
unique_ptr<string> p3;
p3.reset(p2.release());

传递unique_ptr参数和返回unique_ptr

不能拷贝 unique_ptr 的规则有一个例外：我们可以拷贝或赋值一个将要被摧毁的 unique_ptr ：

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

向unique_ptr传递删除器

unique 默认使用 delete 释放指向的对象。与 shared_ptr 不同的是，我们需要在构造 unique_ptr 时提供删除器的类型：

unique_ptr<objT, delT> p(new objT, fcn);

以上一篇笔记中提到的网络连接类为例：

void f(destination &d /* 其他参数 */) {
	connection c = connect(&d);
    unique_ptr<connection, decltype(end_connection)*>
        p(&c, end_connection);
    // 当p被销毁时，调用end_connection
}

12.1.6 weak_ptr（P420）

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

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

auto p = make_shared<int>();
weak_ptr<int> wp(p);

上述代码中 wp 不会改变 p 的引用计数。由于 wp 指向的对象可能被释放掉，我们不能使用 weak_ptr 直接访问对象，而必须调用 lock ：

if(shared_ptr<int> np = wp.lock()){    // 如果np不为空则条件成立
    ...
}

核查指针类

为了展示 weak_ptr 的用途，我们为 StrBlob 类定义一个伴随指针类 StrBlobPtr ，类中保存一个 weak_ptr ，指向 StrBlob 的 data 成员。使用 weak_ptr 可以阻止用户访问一个不再存在的 vector 。

class StrBlobPtr {
public:
	StrBlobPtr(): curr(0) {}
	StrBlobPtr(StrBlob &a, size_t sz = 0) :wptr(a.data), curr(sz){}
	string &deref() const;
	StrBlobPtr &incr();
private:
	shared_ptr<vector<string>> check(size_t, const string &) const;
	weak_ptr<vector<string>> wptr;
	size_t curr;    // 在数组中的当前位置
};

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

shared_ptr<vector<string>>
StrBlobPtr::check(size_t i, const string &msg)const {
	auto ret = wptr.lock();
	if (!ret)
		throw runtime_error("unbound StrBlobPtr");
	if (i >= ret->size())
		throw out_of_range(msg);
	return ret;
}

指针操作

我们定义 deref 和 incr 用来解引用和递增 StrBlobPtr ：

string &StrBlobPtr::deref()const {
	auto p = check(curr, "dereference past end");
	return (*p)[curr];
}

StrBlobPtr &StrBlobPtr::incr() {
	check(curr, "increment past end of StrBlobPtr");
	++curr;
	return *this;
}

由于我们在初始化 StrBlobPtr 时需要用到 StrBlob 中的 data 成员，所以我们要将 StrBlobPtr 声明成 StrBlob 的友元。

12.2 动态数组（P423）

C++ 和标准库提供了两种一次分配一个对象数组的方法。在大多数情况下，我们应该使用容器而非动态数组，使用容器的类可以使用默认版本的拷贝、赋值、析构操作，而使用动态数组的类必须定义自己版本的操作。

new和数组（P423）

为了让 new 分配一个对象数组，我们要在类型名后跟一对方括号，在其中指明要分配的对象的数目：

int *pia = new int[get_size()];    // 方括号中必须为整型，但不必为常量

也可以用类型别名来分配数组：

using arrT = int[1024];
int *p = new arrT;

分配一个数组会得到一个元素类型的指针

无论用 new T[] 还是类型别名，我们得到的都是一个指向数组元素类型的指针，而不是一个数组。下面的代码验证了这个事实：

int x = 0;
decltype(new int[10]) p1 = &x;    // 正确
int arr[10];
decltype(arr) p2 = &x;    // 错误

动态数组并不是数组类型

初始化动态分配对象的数组

默认情况下，new 分配的对象，不论是单个对象还是数组，都是默认初始化的。要对数组中的元素执行值初始化，可以在大小后跟一对圆括号：

int *pia1 = new int[10];    // 10个默认初始化的int
int *pia2 = new int[10]();    // 10个值初始化的int

在新标准中，我们还可以提供初始值列表：

int *pia3 = new int[10] {0, 1, 2, 3};

动态分配一个空数组是合法的

char arr[0];    // 错误
char *cp = new char[0];    // 正确

当我们用 new 分配一个大小为 0 的数组时，new 返回一个合法的非空指针。

释放动态数组

为了释放动态数组，我们也要在 delete 后跟一对方括号：

delete p;    // p必须指向一个动态分配的对象或为空
delete [] pa;    // pa必须指向一个动态分配的对象数组或为空

数组中的元素按逆序销毁。如果我们在 delete 一个数组时忽略了方括号或在 delete 一个对象时使用了方括号，结果是未定义的。

前面提到，当我们使用类型别名来定义数组类型时，在 new 中可以不使用方括号，但是在 delete 时则必须使用方括号：

using arrT = int[1024];
auto p = new arrT;
delete[] p;

此处产生一个疑问，既然前面提到，new[] 得到的仅仅是一个指针，而并不是一个数组，那么 delete[] 是怎么知道需要释放多少空间的呢？答案见C++中delete是如何获知需要释放的内存(数组)大小的？ - 知乎 (zhihu.com)

智能指针和动态数组

标准库提供了一个可以管理 new 分配的数组的 unique_ptr 版本：

unique_ptr<int[]> up(new in[10]);
up.release();    // 自动使用delete[] 

当 unique_str 指向一个数组时，我们不能使用点运算符和箭头运算符，但我们可以使用下标运算符访问数组中的元素。

shared_ptr 不支持直接管理动态数组。如果希望使用 shared_ptr 管理动态数组，必须定义自己的删除器：

shared_ptr<int> sp(new int[10], [](int *p) {delete[] p; });

如果未提供删除器，shared_ptr 将使用 delete 释放一个动态数组，这个行为是未定义的。由于 shared_ptr 不支持下标运算符，为了访问访问数组中的元素，必须用 get 获得一个内置指针：

for (size_t i = 0; i != 10; ++i) {
	*(sp.get() + i) = i;
}

12.2.2 allocator类（P427）

new 在灵活性上有一些局限，因为它将内存分配和对象构造组合在一起了。当分配一大块内存时，我们通常希望将内存分配和对象构造分离，而将内存分配和对象构造组合在一起可能造成不必要的浪费：

// 初始化了n个string，但某些string可能永远用不到
string *const p = new string[n];

此外，没有默认构造函数的类不能用 new 分配动态数组。

allocator类

allocator 类定义在头文件 memory 中，它帮助我们将内存分配和对象构造分离开来。

allocator<string> alloc;
const auto p = alloc.allocate(n);     // 分配n个未初始化的string

allocator分配未构造的内存

auto q = p;    // 顶层const被忽略
alloc.construct(q++);
alloc.construct(q++, 10, 'c');
alloc.construct(q++, "hi");

当我们用完对象后，必须对每个元素调用 destroy 销毁它们：

while(q != p){
    alloc.destroy(--q);    // 释放真正构造的string
}

调用 deallocate 释放内存：

alloc.deallocate(p, n);

拷贝和填充未初始化内存的算法

标准库还为 allocator 类定义了两个伴随算法，定义在头文件 memory 中：

allocator<string> alloc;
vector<string> vs = {"hello", "hi", "him"};
auto p = alloc.allocate(vs.size() * 2);
auto q = uninitialized_copy(vs.begin(), vs.end(), p);
uninitialized_fill_n(q, vs.size(), "world");

allocator<string> alloc;
vector<string> vs = {"hello", "hi", "him"};
auto p = alloc.allocate(vs.size() * 2);
auto q = uninitialized_copy(vs.begin(), vs.end(), p);
uninitialized_fill_n(q, vs.size(), "world");