C++Primer——第十二章(动态内存)

void process(shared_ptr<int> ptr) {           // 调用该函数时 ptr被创建并初始化(实参被拷贝到ptr中)，因此ptr指向对象的 引用计数+1
	++(*ptr);
}                                             // ptr离开作用域 而被销毁，因此ptr指向对象的 引用计数-1


int main() {
	// 接受指针参数的智能指针构造函数 是explicit的:
	shared_ptr<int> p1 = new int(123);                 // 错误: 不支持隐式转换
	shared_ptr<int> p2(new int(123));                  // 正确: 使用了直接初始化形式


	// 默认情况下，一个用来初始化智能指针的普通指针 必须指向动态内存:
	int a = 123, * p_a = &a;
	shared_ptr<int> p3(p_a);                           // 错误: p_a不是一个 指向动态内存的指针
	shared_ptr<int> p4(new int(123));                  // 正确
	

	// 不要混合使用 普通指针和智能指针:
	shared_ptr<int> p5(new int(123));                  // p5指向的对象 引用计数为1 （*p5=123）
	process(p5);                                       // p5指向对象值+1 （形参拷贝实参p5时 引用计数+1，因此在process中p5指向的对象 引用计数为2。process结束，形参被销毁后 引用计数为-1，因此p5指向的对象 引用计数为1）
	int i = *p5;                                       // p5指向的对象 引用计数为1 （i=124）

	int* x = new int(123);                             // 危险: x是一个普通指针
	process(x);                                        // 错误: 不能将int* 隐式转换为一个shared_ptr<int>
	process(shared_ptr<int>(x));                       // 合法，但是x指向的内存 会被释放! （形参拷贝实参x时 引用计数+1，因此在process中x指向的对象 引用计数为1。process结束，形参被销毁后 引用计数为-1，因此x指向的对象 引用计数为0。所以x指向的内存 被自动释放）
	int j = *x;                                        // 未定义: x此时是一个空悬指针 （x指向的内存已经被释放，不能再使用x的值）


	// 不要使用get初始化另一个智能指针 或为智能指针赋值:
	shared_ptr<int> p6(new int(123));                  // p指向的对象 引用计数为1
	int* q = p6.get();                                 // 正确: 但使用q时要注意，不要让它管理的指针被释放 （危险: 使用get返回的指针的代码 不能delete此指针）
	{
		shared_ptr<int> p7(q);                         // 未定义: 两个独立的shared_ptr指向 相同的内存! （p6和p7指向相同的内存，因为它们是相互独立创建的，因此它们的引用计数都是1）
	}                                                  // 程序块结束，p7被销毁后 其指向对象引用计数-1(即0)，因此p7指向的内存被释放
	int k = *p6;                                       // 未定义: p7指向的内存已经被释放，也就是p6指向的内存被释放


	// 使用reset()函数，可以取消 shared_ptr对象与相关指针的关联:
	shared_ptr<int> p8(new int(123));                  // p8指向的对象 引用计数为1
	shared_ptr<int> p9(p8);                            // p8指向的对象 引用计数为2
	shared_ptr<int> p10(p9);                           // p8指向的对象 引用计数为3

	p10.reset();                                       // p8指向的对象 引用计数为2 （解除p10与其指向的对象的关联，因此其指向对象的 引用计数-1=2）
	p9.reset(new int(456));                            // 正确: p9指向一个新的对象，p9指向对象的 引用计数为1 （p8指向对象的 引用计数-1=1）
	p9 = new int(456);                                 // 错误: 不能将一个指针赋予 shared_ptr


	// reset经常与unique一起使用，来控制多个 shared_ptr共享的对象:
	if (!p8.unique()) {
		p8.reset(new int(*p8));                        // 如果我们不是唯一用户，则分配新的拷贝（即解除p8与其原指向对象的关联，重新关联到另一个对象，并且先后对象的值是相同的）
	}                                                  // 因为我们不是唯一的用户，为了不能影响到其他用户，得把自己从原对象先分离出来，再绑定到一个 新的、自己独有的、且值和原对象值相同的 新对象，而不能直接改变 多个用户共享的原对象。
	*p8 += 1;                                          // 现在我们知道自己是"唯一的用户"，因此可以改变对象的值 （*p8=124）
}        

• 如果使用智能指针管理内存，即使程序块由于异常过早结束，智能指针类也能确保在内存不需要的时候将其释放。
• 如果使用内置指针管理内存，且在new之后在对应的delete之前发生了异常，则内存不会被释放。

• 不使用相同的内置指针 初始化(或reset)多个智能指针。
• 不delete get()返回的指针。
• 如果你使用get()返回的指针，记得当最后一个对应的智能指针销毁后，你的指针就无效了。
• 如果你使用智能指针管理的资源 不是new分配的内存，记住传递给它一个删除器。（默认情况下，智能指针管理的资源是 动态内存，且默认使用delete释放 其指向的动态内存）