C++ 使用指针的意义及智能指针（动态内存）的作用

在初学C++的时候，我们会去了解代码中的指针，并掌握它的用法，但有时我们会去思考，为什么要去使用指针，为什么不直接调用对象，使用指针的意义是什么，什么是智能指针，在这我将结合我自己的理解聊一聊这些问题

参考： 指针详解
参考： 智能指针
参考：智能指针2

什么是指针

指针（Pointer），从其英文字面上来理解就是一个指向某一物件的东西，在程序中就是指向数据的地址（Address）。计算机的内存可以看作是一个紧密排列的数据序列，每一小块数据序列，每一小块数据（也就是字节）的旁边都有一个编号代表数据地址。这在现实中可以用房屋的地址来理解，我们可以说这一栋房子是小李家，也可以说一栋房子是xx路xxx号（指针表示）

指针的代码初理解：

#include <iostream>
using namespace std;

//指针的含义

int main()
{
	int arr[5] = { 0, 1, 2, 3, 4 };
	int *ptr = arr;
	for (int i = 0; i < 5 ; i++)
	{
		cout << *ptr << " ";
		cout << "地址：" << ptr <<endl;
		ptr++;
	}
	return 0 ;
}

为什么要使用指针

1.指针允许你以更简洁的方式引用大的数据结构

程序的数据结构从原子级别的数据结构：整型、浮点型、字符型、枚举型，到分子级别的数组、结构体（又称为“记录”），再到数据结构中的队列、栈、链表、树等，无论如何复杂，数据结构总是位于计算机的内存中，因此必有地址。利用指针就可以使用地址作为一个完整值的速记符号，因为一个内存地址在内部表示为一个整数。当数据结构本身很大时，这种策略能节约大量内存空间。在操作大型数据和类时，由于指针可以通过内存地址直接访问数据，从而避免在程序中大量的复制代码，因此指针的效率是最高的。

2.指针使程序的不同部分能够共享数据

类似于共享内存，如果将某一个数据值的地址从一个函数传递到另外一个函数，这两个函数就能使用同一数据。

3.利用指针，能在程序执行过程中预留新的内存空间

大多数情况下，可以看到程序使用的内存是通过显式声明分配给变量的内存（也就是静态内存分配）。这一点对于节省计算机内存是有帮助的，因为计算机可以提前为需要的变量分配内存。但是在很多应用场合中，可能程序运行时不清楚到底需要多少内存，这时候可以使用指针，让程序在运行时获得新的内存空间（实际上应该就是动态内存分配），并让指针指向这一内存更为方便。

4.指针可以用来记录数据项之间的关系

在高级程序设计应用中，指针被广泛应用于构造单个数据值之间的联系。比如，程序员通常在第一个数据的内部表示中包含指向下一个数据项的指针（实际上就是链表了），来说明这两个数据项之间有概念上的顺序关系。

其它网上相关使用指针可以带来如下的好处：
（1）可以提高程序的编译效率和执行速度，使程序更加简洁。

（2）通过指针被调用函数可以向调用函数处返回除正常的返回值之外的其他数据，从而实现两者间的双向通信。

（3）利用指针可以实现动态内存分配。

（4）指针还用于表示和实现各种复杂的数据结构，从而为编写出更加高质量的程序奠定基础。

（5）利用指针可以直接操纵内存地址，从而可以完成和汇编语言类似的工作。

（6）更容易实现函数的编写和调用

什么是智能指针（动态内存与智能指针）

讲智能指针前，我们先讲讲动态内存。根据以往我们学习的知识，我们接触了静态内存或栈内存。静态内存用来保存局部static对象、类static数据成员（必须类外初始化，此时分配内存）以及定义在任何函数外的变量（全局变量）。栈内存用来保存定义在函数内的非static对象。分配在静态或者栈内存中的对象由编译器自动创建和销毁，对于栈对象，仅在其定义的程序块运行时才存在，static对象在使用之前分配，在程序结束后销毁。
除了静态内存和栈内存，每个程序还拥有一个内存池，这部分内存被称作自由空间或堆。程序用堆来存储动态分配的对象，即，那些在程序运行时分配的对象。动态对象的生存期由程序来控制，也就是所，当动态对象不再使用时，我们的代码必须显式地销毁它们。
在C++中，动态内存的管理时通过一对运算符来完成的：new，在动态内存中为对象分配空间并返回一个指向该对象的指针，我们可以选择对对象进行初始化；delete，接受一个动态对象的指针。销毁该对象，并释放与之关联的内存（delete操作只是释放掉了堆中的空间，并不会将指针p的值置为NULL；所以p仍然指向堆中对应的位置（空悬指针），但是注意这个位置已经被回收了，可以随时分配给别的对象。所以delete之后最好置为NULL）
动态内存的使用很容易出问题，因为确保在正确的时间释放内存是极其困难的。有时候我们会忘记释放内存，在这种情况下会产生内存泄漏；有时在尚有指针引用内存的情况下，我们就释放了它，在这种情况下就会产生引用非法内存的指针。

内存泄漏：

#include <iostream>
#include <string>
#include <memory>

using namespace std;


// 动态分配内存，没有释放就return
void memoryLeak1() {
	string *str = new string("动态分配内存！");
	return;
}

// 动态分配内存，虽然有些释放内存的代码，但是被半路截胡return了
int memoryLeak2() {
	string *str = new string("内存泄露！");

	// ...此处省略一万行代码

	// 发生某些异常，需要结束函数
	if (1) {
		return -1;
	}
	/
	// 另外，使用try、catch结束函数，也会造成内存泄漏！
	/

	delete str;	// 虽然写了释放内存的代码，但是遭到函数中段返回，使得指针没有得到释放
	return 1;
}


int main(void) {

	memoryLeak1();

	memoryLeak2();

	return 0;
} 

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

1、shared_ptr（一种强引用指针）
多个shared_ptr指向同一处资源，当所有shared_ptr都全部释放时，该处资源才释放。
（有某个对象的所有权（访问权，生命控制权） 即是 强引用，所以shared_ptr是一种强引用型指针）
（1）内部大概实现：每次复制，多一个共享同处资源的shared_ptr时，计数+1。每次释放shared_ptr时，计数-1。
当shared计数为0时，则证明所有指向同一处资源的shared_ptr们全都释放了，则随即释放该资源（哦，还会释放new出来的SharedPtrControlBlock）。

//shared计数放在这个结构体里面，实际上结构体里还应该有另一个weak计数。下文介绍weak_ptr时会解释。
struct SharedPtrControlBlock
{　　
  int shared_count;
};
//大概长这个样子（简化版）
template<class T>
class shared_ptr
{　　
  T* ptr;　　
  SharedPtrControlBlock* count;
};

（2）示例用法：

void runGame()
{　　
    std::shared_ptr<Monster> monster1(new Monster());　 //计数加到1
　do{
       std::shared_ptr<Monster> monster2 = monster1;　	//计数加到2　　
    }while(0);　　　　　　　　　　
　　//该栈退出后，计数减为1，monster1指向的堆对象仍存在
　　std::shared_ptr<Monster> monster3 = monster1;　　 	//计数加到2
}//该栈退出后，shared_ptr都释放了，计数减为0，它们指向的堆对象也能跟着释放.

缺陷：模型循环依赖(互相引用或环引用)时，计数会不正常

假如有这么一个怪物模型，它有2个亲人关系：

class Monster
{　　
    std::shared_ptr<Monster> m_father;　　
    std::shared_ptr<Monster> m_son;

public:　　
    void setFather(std::shared_ptr<Monster>& father);    　　
    void setSon(std::shared_ptr<Monster>& son);　　　 
    ~Monster(){std::cout << "A monster die!";}　　　　   
};

void runGame()
{
     std::shared_ptr<Monster> father = new Monster();
     std::shared_ptr<Monster> son = new Monster();
     father->setSon(son);
     son->setFather(father);
}

函数退出时栈的shared_ptr对象陆续释放后的情形：
（1）一开始：father,son指向的堆对象 shared计数都是为2；
（2）son智能指针退出栈：son指向的堆对象 计数减为1，father指向的堆对象 计数仍为2。
（3）father智能指针退出栈：father指向的堆对象 计数减为1 , son指向的堆对象 计数仍为1。
（4）函数结束：所有计数都没有变0，也就是说中途没有释放任何堆对象。

为了解决这一缺陷的存在，弱引用指针weak_ptr的出现很有必要。

--------->
创建智能指针时必须提供额外的信息，指针可以指向的类型：

shared_ptr<string>p1;
shared_ptr<list<int>> p2;

默认初始化的智能指针中保存着一个空指针。
智能指针的使用方式和普通指针类似，解引用一个智能指针返回它指向的对象，在一个条件判断中使用智能指针就是检测它是不是空。

if(p1 && p1->empty())
  *p1 = "hi";

如下表所示是shared_ptr和unique_ptr都支持的操作：

如下表所示是shared_ptr特有的操作：

函数说明
1）make_share函数
最安全的分配和使用动态内存的方法就是调用一个名为make_shared的标准库函数，此函数在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr。头文件和share_ptr相同，在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>();

make_shared用其参数来构造给定类型的对象，如果我们不传递任何参数，对象就会进行值初始化。

2）shared_ptr的拷贝和赋值
当进行拷贝和赋值时，每个shared_ptr都会记录1有多少个其他shared_ptr都会记录有多少个其他shared_ptr指向相同的对象。

auto p = make_shared<int>(42);
auto q(p);

我们可以认为每个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原来指向的对象已没有引用者，会自动释放

3）shared_ptr自动销毁所管理的对象
当指向一个对象的最后一个shared_ptr被销毁时，shared_ptr类会自动销毁此对象，它是通过另一个特殊的成员函数-析构函数完成销毁工作的，类似于构造函数，每个类都有一个析构函数。

析构函数控制对象销毁时做什么操作。析构函数一般用来释放对象所分配的资源。shared_ptr的析构函数会递减它所指向的对象的引用计数。如果引用计数变为0，shared_ptr的析构函数就会销毁对象，并释放它所占用的内存。

4）shared_ptr还会自动释放相关联的内存
当动态对象不再被使用时，shared_ptr类还会自动释放动态对象，这一特性使得动态内存的使用变得非常容易。如果你将shared_ptr存放于一个容器中，而后不再需要全部元素，而只使用其中一部分，要记得用erase删除不再需要的那些元素。

使用了动态生存期的资源的类，程序使用动态内存的原因：

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

5）不要混合使用普通指针和智能指针
如果混合使用的话，智能指针自动释放之后，普通指针有时就会变成悬空指针，当将一个shared_ptr绑定到一个普通指针时，我们就将内存的管理责任交给了这个shared_ptr。一旦这样做了，我们就不应该再使用内置指针来访问shared_ptr所指向的内存了。

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

shared_ptr<int> p(new int(42));//引用计数为1
int *q = p.get();//正确：但使用q时要注意，不要让它管理的指针被释放
{
    //新程序块

    //未定义：两个独立的share_ptr指向相同的内存
    shared_ptr(q);
}//程序块结束，q被销毁，它指向的内存被释放

int foo = *p;//未定义，p指向的内存已经被释放了

6）其他shared_ptr操作
可以使用reset来将一个新的指针赋予一个shared_ptr:

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

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

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

7）智能指针和异常
如果使用智能指针，即使程序块过早结束，智能指针也能确保在内存不再需要时将其释放，sp是一个shared_ptr,因此sp销毁时会检测引用计数，当发生异常时，我们直接管理的内存是不会自动释放的。如果使用内置指针管理内存，且在new之后在对应的delete之前发生了异常，则内存不会被释放。

使用我们自己的释放操作：
默认情况下，shared_ptr假定他们指向的是动态内存，因此当一个shared_ptr被销毁时，会自动执行delete操作，为了用shared_ptr来管理一个connection，我们必须首先必须定义一个函数来代替delete。这个删除器函数必须能够完成对shared_ptr中保存的指针进行释放的操作。

8）智能指针陷阱：

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

1、weak_ptr（一种弱引用指针）
weak_ptr是为了辅助shared_ptr的存在，它只提供了对管理对象的一个访问手段，同时也可以实时动态地知道指向的对象是否存活。

（只有某个对象的访问权，而没有它的生命控制权 即是 弱引用，所以weak_ptr是一种弱引用型指针）

（1）内部大概实现

计数区域(SharedPtrControlBlock)结构体引进新的int变量weak_count，来作为弱引用计数。
每个weak_ptr都占指针的两倍空间，一个装着原始指针，一个装着计数区域的指针（和shared_ptr一样的成员）。
weak_ptr可以由一个shared_ptr或者另一个weak_ptr构造。
weak_ptr的构造和析构不会引起shared_count的增加或减少，只会引起weak_count的增加或减少。
被管理资源的释放只取决于shared计数，当shared计数为0，才会释放被管理资源，也就是说weak_ptr不控制资源的生命周期。
但是计数区域的释放却取决于shared计数和weak计数，当两者均为0时，才会释放计数区域。

//shared引用计数和weak引用计数
//之前的计数区域实际最终应该长这个样子
struct SharedPtrControlBlock
{　　
   int shared_count;　　
   int weak_count;
};
//大概长这个样子（简化版）
template<class T>
class weak_ptr
{　　
   T* ptr;　　
   SharedPtrControlBlock* count;
};

（2）针对空悬指针问题
空悬指针问题是指：无法知道指针指向的堆内存是否已经释放。

得益于引入的weak_count,weak_ptr指针可以使计数区域的生命周期受weak_ptr控制，

从而能使weak_ptr获取 被管理资源的shared计数，从而判断被管理对象是否已被释放。（可以实时动态地知道指向的对象是否被释放,从而有效解决空悬指针问题）

它的成员函数**expired()**就是判断指向的对象是否存活。

（3）针对循环引用问题

class Monster{
　　//尽管父子可以互相访问，但是彼此都是独立的个体，无论是谁都不应该拥有另一个人的所有权。
　　std::weak_ptr<Monster> m_father;　　　　//所以都把shared_ptr换成了weak_ptr
　　std::weak_ptr<Monster> m_son;　　　　　　//同上

public:
　　void setFather(std::shared_ptr<Monster>& father); //实现细节懒得写了
　　void setSon(std::shared_ptr<Monster>& son);　　　　//懒
　　~Monster(){std::cout << "A monster die!";}　　　　 //析构时发出死亡的悲鸣
};

然后执行下面的函数：

void runGame()
{　　
std::shared_ptr father(new Monster());　　
std::shared_ptr son(new Monster());　　
father->setSon(son);　　
son->setFather(father);
}
那么我们再来模拟一遍，函数退出时栈的shared_ptr对象陆续释放后的情形：

一开始：father指向的堆对象 shared计数为1,weak计数为1；son指向的堆对象 shared计数为1,weak计数为1；
son智能指针退出栈：son指向的堆对象 shared计数减为0,weak计数为1,释放son的堆对象；father指向的堆对象 shared计数为1,weak计数减为0;
father智能指针退出栈：father指向的堆对象 shared计数减为0,weak计数为0;释放father的堆对象和father的计数区域；son指向的堆对象 shared计数为0,weak计数减为0;释放son的计数区域。
函数结束，释放行为正确。
（可以说，当生命控制权没有彼此互相掌握时，才能正确解决循环引用问题，而弱引用的使用可以使生命控制权互相掌握的情况消失）

此外：
weak_ptr没有重载 * 和 -> ，所以并不能直接使用资源。但可以使用lock()获得一个可用的shared_ptr对象，如果对象已经死了，lock()会失败，返回一个空的shared_ptr。

void runGame()
{　　
  std::shared_ptr<Monster> monster1(new Monster());　　 
  std::weak_ptr<Monster> r_monster1 = monster1;　　
  r_monster1->doSomething();//Error! 编译器出错！weak_ptr没有重载* 和 -> ，无法直接当指针用　　   		      std::shared_ptr<Monster> s_monster1 = r_monster1.lock();//OK!可以通过weak_ptr的lock方法获得shared_ptr。
}

2、unique_ptr（一种强引用）
正如它的名字，独占 是它最大的特点。

（1）内部大概实现
它其实算是auto_ptr的翻版(都是独占资源的指针,内部实现也基本差不多).

但是unique_ptr的名字能更好的体现它的语义，而且在语法上比auto_ptr更安全（尝试复制unique_ptr时会编译期出错，而auto_ptr能通过编译期从而在运行期埋下出错的隐患）

假如你真的需要转移所有权（独占权），那么你就需要用std::move(std::unique_ptr对象)语法，尽管转移所有权后 还是有可能出现原有指针调用（调用就崩溃）的情况。
但是这个语法能强调你是在转移所有权，让你清晰的知道自己在做什么，从而不乱调用原有指针。

（2）示例用法

void runGame()
{　　
  std::unique_ptr<Monster> monster1(new Monster());//monster1 指向 一个怪物　　
  std::unique_ptr<Monster> monster2 = monster1;//Error!编译期出错，不允许复制指针指向同一个资源。　　   	std::unique_ptr<Monster> monster3 = std::move(monster1);//转移所有权给monster3.　　
  monster1->doSomething();//Oops!monster1指向nullptr，运行期崩溃 
}

（额外：boost库的boost::scoped_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当前保存的指针并将其置为空。因此，p2被初始化为p1原来保存的指针，而p1被置为空。

reset成员接受一个可选的指针参数，令unique_ptr重新指向给定的指针。

调用release会切断unique_ptr和它原来管理的的对象间的联系。release返回的指针通常被用来初始化另一个智能指针或给另一个智能指针赋值。

不能拷贝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的类，它具有uniqued_ptr的部分特性，但不是全部。

用unique_ptr传递删除器
unique_ptr默认使用delete释放它指向的对象，我们可以重载一个unique_ptr中默认的删除器

我们必须在尖括号中unique_ptr指向类型之后提供删除器类型。在创建或reset一个这种unique_ptr类型的对象时，必须提供一个指定类型的可调用对象删除器。

6、小结
1）不要使用std::auto_ptr
2）当你需要一个独占资源所有权（访问权+生命控制权）的指针，且不允许任何外界访问，请使用std::unique_ptr
3）当你需要一个共享资源所有权（访问权+生命控制权）的指针，请使用std::shared_ptr
4）当你需要一个能访问资源，但不控制其生命周期的指针，请使用std::weak_ptr

推荐用法：一个shared_ptr和n个weak_ptr搭配使用 而不是n个shared_ptr。
逻辑上，大部分模型的生命在直观上总是受某一样东西直接控制而不是多样东西共同控制。
程序上，能够完全避免生命周期互相控制引发的 循环引用问题。