标签：
全局对象：启动时分配，结束时销毁
局部对象：程序块内分配，程序块外销毁
static对象：第一次使用分配，结束时销毁
动态内存使用new来分配对象，使用delete销毁对象
#include<memory>
shared_ptr: 多个指针可以指向同一个对象
unique_ptr: 独占指向的对象
weak_ptr: 一个伴随类，指向shared_ptr管理的对象，是弱引用
智能指针也是模板，定义时需要指明类型
shared_ptr<string> p1;
shared_ptr<list<int>> p2;
默认初始化为空指针
|
shared_ptr和unique_ptr都支持的操作 |
|
|
unique_ptr<T> up shared_ptr<T> sp |
空智能指针，指向类型为T的对象 |
|
p |
作为一个条件判断，指向一个对象则为true |
|
*p |
解引用，获得指向的对象 |
|
p->item |
等价于(*p).item |
|
p.get() |
返回p中保存的指针 |
|
swap(p, q) p.swap(q) |
交换p和q中的指针 |
|
shared_ptr独有的操作 |
|
|
make_shared<T>(args) |
返回一个shared_ptr，使用args初始化T的对象 |
|
shared_ptr<T> p(q) |
p是q的拷贝，指向同一个对象，q中计数器递增 |
|
p=q |
递减p中引用计数，递增q中引用计数 |
|
p.unique() |
如果p.use_count()为1，返回true |
|
p.use_count() |
返回p共享对象的智能指针的数量，很慢，用于调试 |
使用动态内存的三种原因
int *ptr = new int; //默认初始化，值未定义 int *ptr1 = new int();//值初始化为0 int *ptr2 = new int(1024); const int *ptr3 = new const int(1024); int *ptr4 = new (nothrow) int(1024);//分配失败，不抛出bad_alloc异常，而是返回空指针 string *str = new string; //默认初始化为空string string *str1 = new string();//值初始化为空string string *str2 = new string("string"); vector<int> *pv = new vector<int>{ 1, 2, 3, 4, 5 }; auto p = new auto("123");//为const char** auto p = new auto(string("123"));//为string* int i, *pi1 = &i, *pi2 = nullptr; double *pd = new double(33), *pd2 = pd; delete i; // 错误，i不是指针 delete pi1; // 未定义，pil是一个局部变量 delete pd; // 成功 delete pd2; // 未定义，pd2已经被释放 delete pi2; // 成功，释放了一个为空的指针
释放内存之后，指针变成了悬空指针（dangling pointer），通常仍然指向原来的内存地址，如果之后再次delete，会破坏自由空间内存，通常需要重新赋予nullptr。
shared_ptr<int> p2 = new int(42);// 错误int*不能隐式转换成智能指针 shared_ptr<int> p2(new int(42));// 正确，因为构造函数是explicit，上边才不成立 int* q = new int(10); shared_ptr<int> p(q, [](int* p) {cout << *p; delete p; });// 自定义释放内存的方法
不建议结合使用
其他操作
shared_ptr<int> p(new int(9)); int *pi = p.get();// 得到内置指针 if (!p.unique())//不是唯一引用 p.reset(new int(*p + 1));//改变p的指向,不影响其他引用的值 *p = *p + 1;//唯一引用，直接改变也不影响其他的了
void f(destination &d) { connection c = connect(&d); //保证在程序结束后释放c shared_ptr<connection> p(&c, [](auto c) {delete c; }); ... }
unique_ptr不能进行赋值、拷贝操作
unique_ptr<int> u; u = nullptr;//释放u的对象，并置空 u.release();//释放u的对象控制，并返回内置指针，置空u u.reset();//释放u的对象 u.reset(q);//指向q，释放u的对象
可以拷贝和返回一个将要被销毁的unique_ptr，例如参数返回时的拷贝，这其实是一种特殊的拷贝（13.6.2）。
自定义删除器需要在定义时指明类型，这与shared_ptr作为参数不同。
unique_ptr<int, decltype(process)*> u(new int(10), process);
weak_ptr将会绑定到一个shared_ptr，它不会改变shared_ptr的引用计数。
弱智能指针需要用shared_ptr对象初始化。
shared_ptr<int> u1(new int(50)); weak_ptr<int> w = u1; w.reset();// 置空w w.use_count();//共享shared_ptr的数量 w.expired();//user_count为0，返回true，否则为false w.lock();//返回对应的一个shared_ptr对象，如果expired为true，则返回的是空的对象 if (shared_ptr<int> u = w.lock())//可以判断并得到shared_ptr
最好使用vector、string等其他标准库中的容器，这些标准库可以使用默认版本的拷贝、赋值和析构操作，而使用动态数组，就需要自己考虑了。
int *pia = new int[10];//10个未初始化 int *pia1 = new int[10]();//10个值初始化为0 int *pia2 = new int[10]{ 1,2,3 };//前三个为1,2,3，其他的为0
释放时需要用到
delete[] pia;
对于释放时delete中如何知道内存中的大小，一般的编译器是通过在分配的动态数组前记录分配的内存的大小，然后释放的时候读取记录进行释放。
使用智能指针管理动态数组
unique_ptr<int[]> u(new int[10]); cout << u[10] << endl; u.release();//可以自动调用delete [] shared_ptr<int> sp(new int[10], [](int*p) {delete[] p; });//需要自定义销毁函数 sp.reset();//使用自定义销毁函数
shared_ptr不直接支持动态数组管理，所以也不支持下标运算和指针的算术运算，需要使用时，必须使用get获取内置指针。
|
allocator<T> a |
定义一个为T类型对象分配内存的allocator对象 |
|
a.allocate(n) |
为n个T类型对象分配内存 |
|
a.deallocate(p, n) |
收回为n个T类型对象分配的内存 |
|
a.construct(p, args) |
在p指向的位置构造T对象（需要一个一个构造） |
|
a.destroy(p) |
销毁p指向位置的T对象（需要一个一个销毁） |
int count = 10; allocator<string> a; //分配内存 string* p = a.allocate(count); for (int i = 0; i < count; i++) a.construct(p + i);//构造对象 for (int i = 0; i < count; i++) a.destroy(p + i);//销毁对象 //收回内存 a.deallocate(p, count);
|
uninitialized_copy(b,e,b2) |
从迭代器b到e的范围中的对象，内拷贝到b2内存中 |
|
uninitialized_copy_n(b,n,b2) |
从迭代器b开始的n个元素拷贝到b2内存中 |
|
uninitialized_fill(b,e,t) |
在b到e的范围中创建t的拷贝 |
|
uninitialized_fill_n(b,n,t) |
在b开始的n个元素内存中，创建t的拷贝 |
标签：
原文地址：http://www.cnblogs.com/qiusuo/p/5005727.html
