动态内存的使用

1. new运算符
   自由空间分配的内存是无名的，因此new无法为其分配的对象命名，而是发挥一个指向该对象的指针：

int *ip = new int;
string *sp = new string;

默认情况下，动态分配的对象是默认初始化的，意味着int型的值是未定义的，类对象将使用默认构造函数进行初始化。
可以使用直接初始化或者构造方式（使用圆括号）来初始化一个动态分配的对象：

int *ip = new int(2048);
string *sp = new string(10, '9');
vector<int> *vp = new vector<int> {1,2,3,4,5,6};

int *ip2 = new int();
string *sp = new string();

当内存被使用完，自由空间被耗尽可能发生，这时new表达式会失败，会抛出一个bad_alloc异常，可以通过定位new方式来阻止抛出异常，而改为返回一个空指针：

int *ip = new (nothrow) int;

常量对象的new：

const int *ip = new const int();

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

int *pia = new int[get_size()]; // get_size()返回一个整型值，括号中不必是常量，pia指向数组的第一个元素

也可以使用数组类型的类型别名：

typedef int arrT[42]; // arrT表达42个int的数组类型
int *p = new arrT; // p指向数组的第一个元素

可以初始化动态分配的数组：

int *pia = new int[10]();
int *pia2 = new int[10](1);
int *pia3 = new int[10]{0,1,2,3,4,5,6,7,8,9};

2. delete运算符
   delete表达式接受一个指针，指向想要释放的对象：

delete ip; //ip必须指向一个动态分配的对象或是一个空指针

delete表达式执行了两个动作：销毁给定的指针指向的对象；释放对应的内存；
释放一块并非new分配的内存，或者将相同的指针值释放多次，其行为是未定义的；
释放一个空指针总是没有错误的。

在释放内存后将指针置为空，可以检测空指针来避免使用已经释放的对象，或者再次删除搞对象。

释放动态数组：
delete [] pia; // pia必须指向一个动态分配的数组或为空
使用unique_ptr删除new分配的数组：

unique_ptr<int[]> up(new int[10]);
up.release(); // 自动调用delete[]销毁其指针

3. 常见错误
   动态内存的指针的生命周期是知道被显式释放之前他都是存在的。调用new操作的调用者有义务释放开辟的内存。调用者有可能忘记释放对象：

T * factory(T argv) {
	return new T();
}

void use_factory(T argv) {
	Foo *p = factory(argv);
} // p离开了它的作用域，但它所指向的内存都没有释放

动态内存的管理非常容易出错

1. 忘记delete内存。导致“内存泄漏”，很难检测。
2. 使用已经释放掉的对象。通过在释放内存后将指针置为空，可以检测出这种错误。
3. 同一块内存释放两次。当有两个指针指向相同的动态分配对象时，可能发生。如果对其中一个进行了delete，对象的内存已经归还给自由空间。如果随后又delete第二个，自由空间就可能被破坏。

坚持只使用智能指针可以避免以上所有问题。

4. shared_ptr和new结合使用
   可以用new返回的指针来初始化智能指针：
   直接初始化方式

shared_ptr<int> p(new int(42));

shared_prt<int> clone(int p) {
	return shared_ptr<int>(new int(p));
}

不可以使用隐式转换：

shared_ptr<int> p1 = new int(42); // 错误，必须使用直接初始化方式

shared_ptr<int> clone(int p) {
	return new int(p);
}