静态内存：用来保存static 栈内存：保存非static
智能指针：
shared_ptr：允许多个指针指向一个对象
unique_ptr：独占所指对象
weak_ptr：一种弱引用，指向shared_ptr的对象
shared_ptr:
shared_ptr<T> p;
p.get(); //返回p中保存的指针
p.unique(); //指针数量为1返回
p.use_count(); //返回共享指针数量
shared_ptr<string > p = make_shared_ptr<string>(10,'9');
shared_ptr<int> p = make_share_ptr<int>();
auto p = make_share_ptr<int>();
拷贝会使shared_ptr的计数器增加.初始化，函数参数或者函数返回值。
一旦计数器为0时就会通过析构函数释放自己
函数结束会返回一个p的拷贝，增加计数器，所以函数结束含有指针指向p的内存，所以不会被销毁
void use_factory(T arg)
{
shared_ptr<Foo> p = factory(arg);
return p;
}
所以如果你将shared_ptr放在一个容器中，而后不再需要全部的元素，记得把不用元素删除。
使用动态生存周期的资源：
1.程序不知道自己有多少的对象 //容器类
2.程序不知道自己做需要对象的准确类型
3.程序需要在多个对象间共享数据 //通过shared_ptr的计数器特性实现
直接管理内存：
通过new和delete来管理内存，与智能指针不同的是，直接管理内存无法依赖类对象拷贝、赋值和销毁操作的任何默认定义。
默认初始化和值初始化：
对于定义了构造函数的类类型来说两者都会调用构造函数初始化，没意义；但对于内置类型，值初始化有良好定义的值，而默认初始化
的值是未定义的。
int *p = new int; //默认初始化,值未定义
int *p = new int(); //值初始化为0,*p为0
所以在定义const对象时，如果有构造函数的类类型其const对象可以隐式初始化，但是其他类型就必须显示初始化了。
const int *pci = new const int(1024);
const string *s = new const string;
如果提供一个初始化器，就能使用auto判断我们想要的类型，但是只有当单一的初始化器时才能使用
auto p = new auto(obj);
auto p = new auto(a,b,c); //error
释放一块并非new分配的内存或者多次释放相同指针是未定义的行为。
动态对象的生命周期到被释放为止：
当离开作用域时，局部的指针被销毁了，但是所指内存并没有释放
void use_factory(T arg)
{
Foo *p = factory(arg);
//使用p但不delete
//即便离开作用于，所指内存没被释放
}
常见问题：忘记delete、使用已经释放了的内存，同一块内存释放了两次
shared_ptr和new的结合使用:
接受指针参数的智能指针的构造函数是explicit,new会返回一个指向该对象的指针
shared_ptr<int>p1 = new int(1024); //error 需要隐式转换成shared_ptr
shared_ptr<int>p2(new int(1024));
shared_ptr<int> clone(int p)
{
return new int(p); //error 需要隐式转换成shared_ptr
return shared_ptr<int>(new int(p));
}
默认情况下初始化智能指针的普通指针必需指向动态内存，因为智能指针默认使用delete释放。
否则需要自定义操作来替代delete
shared_ptr<T> p(q); //p管理q所指向的对象
shared_ptr<T> p(u); //p接管unique_ptr并将u置为空
shared_ptr<T> p(q,d); //p接管q,用d代替delete
shared_ptr<T> p(p2,d); //p2的一个拷贝
p.reset();
p.reset(q);
p.reset(q,d);
不要混用普通指针和智能指针：
当智能指针和普通指针指向了同一个内存，如果智能内存的计数减为0，那么内存会被释放
所以当同时用的时候，将内存管理交给shared_ptr
int *x = &q;
process(shared_ptr<int>(x) ); //只能指针会被销毁，内存释放
int j = *x; //空悬指针
可以通过get()向不能使用智能指针的传递一个内置指针，但get返回的指针不能delete
get最好用来传递访问权限，不能用get初始化另外一个智能指针或者为另一个智能指针赋值
无法将普通指针赋值给shared_ptr,所以需要reset
p = new int(42); //error 不能隐式转换？
p.reset(new int(42)); //correct
对于异常，智能指针无论怎样都能确保内存释放，但是直接管理内存时，如果在delete之前异常弹出，那么直接管理的内存
并不会释放。
如果类没有析构函数而且没有显示的关闭连接，那么会出现资源泄露。
可以考虑将其与一个shared_ptr绑定，然后指定delete该指针的方法，从而保证正常关闭
void end_connection(connection *p) {disconnect(p);}
void f(destination &d)
{
connection c = connect(&d);
shared_ptr<connection> p(&c,end_connection);
}
智能指针error：
1.不使用相同的内置指针(或者reset)初始化多个智能指针。 //计数器全是1？
shared_ptrp1(p);
shared_ptrp2(p);
cout << p1.use_count() << " " <<p2.use_count() <<endl;
//1 1
2.不delete get()返回的指针
3.不适用get初始化或者reset另一个智能指针
4.注意get()返回的指针会在智能指针销毁后失效
5.如果你管理的不是new分配的内存，指定一个删除器
unique_ptr:
没有类似make_shared的函数，只能绑定到一个new返回的指针上面。同样只能直接初始化
unique_ptr<string> p1(new string("123"));
unique_ptr<string> p2(p1.release());
//转移控制权，release放弃控制并返回指针
unique_ptr<string> p3(new string("abc"));
p2.reset(p3.release());
而且可以拷贝一个将要被销毁的unique_ptr，因为编译器知道它将被销毁所以执行一种特殊的拷贝
unique_ptr<int> clone(int p)
{
return unique_ptr<int>(new int(p));
}
unique_ptr可以自定义删除器：
connection c = connect(&d);
unique_ptr<connection , decltype(end_connection)*>
p(&c,end_connection);
weak_ptr:
是一种不控制所指对象生存期的只能指针，指向一个shared_ptr对象，但不会改变引用计数。
w.use_count(); //返回shared_ptr数量
w.expired(); //use_count为0返回true
w.lock(); //如果expired()为true返回一个空指针，否则返回一个shared_ptr
动态数组：
vector和string都是连续内存中保存元素，所以每次要分配大量内存。
可以进行默认初始化或者值初始化，由于不能在()中给出初始化器，意味着不能auto分配数组
int *p = new int[10]; //10个未初始化int
int *p = new int[10](); //10初始化为0的int
int *p = new int[10]{0,1,2,3,4}; //前几个用给定初始化器初始化
delete []p;
delete时[]告诉编译器指针指向对象数组的第一个元素，如果不加[]是未定义的行为。而且释放内存时逆序销毁
1.与unique_ptr:
unique_ptr<int[]> p(new int[10]);
p.release(); //自动调用delete
2.与shared_ptr:
和unique不同的是，shared不支持自动管理动态数组QAQ，所以需要定义删除器
如果没有删除器，那么产生问题和delete没加[]一样(即默认调用delete p)
shared_ptr<int> p(new int[10],[](int *p){delete[] p;});
p.reset(); //通过lambda表达式释放
shared_ptr没有下标运算符，而且只能指针不支持指针算术运算，所以访问数组中的元素。
必需要get()获取内置指针
*(p.get() + i) = i;
allocator
在用new分配的时候，不知道数量所以可能把数组分配过大。 而且每个使用的元素都要赋值两次，默认初始化 + 赋值。
如果没有默认构造函数，那么不能动态分配数组。
allocator<string> alloc;
auto p = alloc.allocate(5); //分配5个未构造原始内存
auto q = p;
alloc.construct(q++,"Orz");
cout << *p <<endl;
alloc.destroy(--q);
alloc.deallocate(p,5);
destory() 释放对象内的动态内存（如果有） deallocate是释放对象本身占有的内存
所以要先destory再进行deallocate
unintialized_copy(b,e,b2)：从迭代器b和e指出的输入范围中拷贝元素到迭代器b2指定的未构造的原始内存中。b2指向的内存必须足够大，能容纳输入序列中元素的拷贝
uninitialized_copy_n(b,n,b2)：从迭代器b指向的元素开始，拷贝n个元素到b2开始的内存
unintialized_fill(b,e,b2)：在[b,e]创建b2的拷贝
uninitialized_fill_n(b,n,b2)：在b开始创建b个
pair<string*,string*>
alloc_n_copy(const string* b,const string* e)
{
auto data = alloc.allocate(e-b);
return {data,uninitialized_copy(b,e,data)};
}