C++语言定义了两个运算符来分配和释放动态内存。运算符new分配内存，delete释放new分配的内存。
相对于智能指针，使用这来年刚给运算符管理内存非常容易出错，随着我们逐步详细介绍这两个四月份，这一点会更为清楚。而且，自己直接管理内存的类与使用智能指针的类不同，它们不能依赖类对象拷贝、赋值和销毁操作的任何默认定义。因此，使用智能指针的程序更容易编写和调试。
使用new动态分配和初始化对象
在自由空间分配的内存是无名的。因此，new无法为其分配的对象命名，而是返回一个执行对象的指针：
int *pi=new int ;// pi指向一个动态分配的、未初始化的无名对象
此new表达式在自由空间构造一个int型对象，并返回指向该对象的指针。
默认情况下，动态分配的对象是默认初始化的，这意味着内置类型或组合类型的对象的值将是未定义的，而类类型对象将用默认函数进行初始化：
string *ps=new string; //初始化为空string
int *pi=new int ; // pi指向一个未初始化的int
我们可以使用直接初始化方式来初始化一个动态分配的对象。我们可以使用传统的构造方式（使用圆括号），在新标准下，也可以使用列表初始化（使用花括号）：
int *pi=new int(1024) ;//pi的对象的值为1024
string *ps=new string(10,‘9‘) ; //vector有10个元素，值依次从0到9
vector<int> *pv=new vector<int>{0,1,2,3,4,5,6,7,8,9};
也可以对动态的对象进行值初始化，只需在类型名之后根一对空括号即可：
string *ps1=new string; //默认初始化为空string
string *ps=new string(); //值初始化为空string
int *pi1=new int; //默认初始化：*pi1的值未定义
int *pi2=new int(); // 值初始化为0 *pi2为0
对于定义与自己的构造函数的类类型（例如string）来说，要求值初始化是没有意义的；不管采用什么形式，对象都会通过默认构造函数来初始化。但对于内置类型，两种形式的差别就很大了；值初始化的内置类型对象有着良好定义的值，而默认初始化的对象的值则是未定义的。类似的，对于类中那些依赖于编译器合成的默认构造函数的内置类型成员，如果它们未在类内被初始化，那么它们的值也是未定义的。
如果我们提供了一个括号包围的初始化器，就可以使用auto从此初始化器来推断我们想要分配的对象的类型。但是，由于编译器要用初始化器的类型来推断要分配的类型，只有当括号中仅有单一初始化器时才可以使用auto：
auto p1=new auto(obj) ; //p指向一个与obj类型相同的对象
auto p2=new auto(a,b,c) ; //错误：括号中只能有单个初始化器
p1的类型是一个指针，执行从obj自动推断的类型。若obj是一个int，那么p1就算int*；若obj是一个string，那么p1是一个string*；依次类推。新分配的对象用obj的值进行初始化。
动态分配的const对象
用new分配const对象是合法的：
//分配并初始化一个const int
const int *pci=new const int(1024);
//分配并默认初始化一个const的空string
const string *pcs=new const string;
类似其他任何const对象，一个动态分配的const对象必须进行初始化。对于一个定义了默认构造函数的类类型，其const动态对象可以隐式初始化，而其他类型的对象就必须显式初始化。由于分配的对象是const的，new 返回的指针是一个指向const的指针。
内存耗尽
虽然现代计算机通常都配备大容量内存，但是自由空间被耗尽的情况还是有可能发生。一旦一个程序用光了它所有可用的内存，new表达式就会失败，默认情况下，如果new不能分配所要求的内存空间，它就会抛出一个类型为bad_alloc的异常。我们可以改变使用new的方式来阻止它抛出异常：
//如果分配失败，new返回一个空指针
int *p1=new int ; //如果分配失败，new抛出std::bad_alloc
int *p2=new (nothrow) int ; //如果分配失败，new返回一个空指针
我们称这种形式的new为定位new。定位new表达式允许我们向new传递额外的参数，在此例中，我们传递给它一个由标准库定义的名为nothrow的对象。如果将nothrow传递给new，我们的意图是告诉它不能抛出异常。如果这种形式的new不能分配所需内存，它会返回一个空指针。bad_alloc和nothrow都定义在头文件new中。
释放动态内存
为了防止内存耗尽，在动态内存使用完毕后，必须将其归还给系统。我们通过delete表达式来将动态内存归还给系统。delete表达式接受一个指针，指向我们想要释放的对象：
delete p; // p必须指向一个动态分配的对象或是一个空指针
与new 类型类似，delete表达式也执行里那个个动作：销毁给定的指针指向的对象；释放对应的内存。
指针值和delete
我们传递给delete的指针必须指向动态分配的内存，或是一个空指针。释放一块并非new分配的内存，或者将相同的指针值释放多次，其行为都是未定义的：
int i,*pi1=&i,*pi2=nullptr;
double *pd=new double(33),*pd2=pd;
delete i; //错误，i不是一个指针
delete pi1; //未定义：pi1执行一个局部变量
delete pd; //正确
delete pd2; //未定义，pd2指向的内存已经被释放了
delete pi2; //正确：释放一个空指针总是没有错误的
对于delete i的请求，编译器会生成一个错误信息，因为它知道i不是一个指针。执行delete pi1和pd2所产生的错误则更具潜在危害：通常情况下，编译器不能分辨一个指针指向的是静态还是动态分配的对象。类似的，编译器也不能分辨一个指针所指向的内存是否已经被释放了。对于这些delete表达式，大多数编译器会编译通过，尽管它们是错误的。
虽然一个const对象的值不能被改变，但它本身是可以被销毁的，如同任何其他动态对象一样，想要释放一个const动态对象，只要delete窒息那个它的指针即可。
const int *pci=new const int(1024);
delete pci; //正确：释放一个从const对象
动态对象的生存期直到被释放时为止
由shared_ptr管理的内存在最后一个shared_ptr销毁时会被自动释放。但对于通过内置指针类型来管理的内存，就不是这样了。对于一个由内置指针管理的动态对象，知道被显示释放之前它都是存在的。
返回指向动态内存的指针（而不是智能指针）的函数给其调用者增加了一个额外负担——调用者必须记得释放内存：
//factory返回一个指针，指向一个动态分配的对象
Foo* factory(T arg)
{
//视情况处理arg
return new Foo(arg); //调用者负责释放此内存
}
类似我们之前定义的factory函数，这个版本的factory分配一个对象，但并不delete它。factory的调用者负责在不需要此对象时释放它。不幸的是，调用者经常忘记释放对象：
void use_factory(T arg)
{
Foo *p=factory(arg);
//使用p但不delete它
} //p离开了它的作用域，但它所指向的内存没有被释放
此外，use_factory函数调用factory，后者分配一个类型为Foo的新对象。当use_factory返回时，局部变量p被销毁，此变量是一个内置指针，而不是一个智能指针。
与类类型不同，内置类型的对象被销毁时什么也不会发生。特别是，当一个指针离开其作用域时，它所指的对象什么也不会发生。如果这个指针指向的是动态内存，那么内存将不会被自动释放。
注意：由内置指针（而不是智能指针）管理的动态内存在被显式释放前一直都会存在。
在本例中，p是指向factory分配的内存的唯一指针。一旦use_factory返回，程序就没有办法释放这块内存了。根据整个程序的逻辑，修正这个错误的正确方法是在use_factory中记得要释放内存：
void use_factory(T arg)
{
Foo *p=factory(arg);
//使用p
delete p ; //现在记得释放内存，我们已经不需要它了
}
还有一种可能，我们的系统中的其他代码要使用use_factory所分配的对象，我们就应该修改此函数，让他返回一个指针，指向它分配的内存：
Foo* use_factory(T arg)
{
Foo *p=factory(arg);
//使用p
return p; //调用者必须释放内存
}
小心：动态内存的管理非常容易出错
使用new和delete管理动态内存存在三个常见问题：
1 忘记delete内存。忘记释放动态内存会导致人们常说的“内存泄漏”问题，因为这种内存不可能被归还给自由空间了。查找内存泄漏错误是非常困难的，因为通常应用程序运行很长时间后，真正耗尽内存时，才能检测到这种错误。
2 使用以及释放掉的对象，通过在释放内存后将指针置为空，有时可以检测出这种错误
3 同一块内存被释放两次，当有来年刚给指针指向相同的动态分配对象时，可能发生这种错误。如果对其中一个指针进行了delete操作，对象的内存就被归还给自由空间了，如果我们随后又delete第一个指针，自由空间就可能会被破坏。
相对于查找和修正这种错误来源，制造出这些错误要简单很多。
坚持只使用智能指针，就可以避免所有这些问题。对于一块内存，只有在没有任何只能智能指针指向它的情况下，智能指针才会自动释放它。
delete之后重置指针值。。。。
当我们delete一个指针后，指针值就变为无效了。虽然指针已经无效，但在很多机器上指针仍然保存着（已经释放了的）动态内存的地址。在delete之后，指针就变成了人们所说的空悬指针，即，指向一块层级保存数据对象但现在以及无效的内存的指针。
为初始化指针的所有确定空悬指针也都有，有一种方法可以避免空悬指针的问题；在指针即将要离开其作用域之前释放掉它所关联的内存。这样在指针关联的内存被释放掉之后，就没有机会继续使用指针了。如果我们需要保留指针，可以在delete之后将nullptr赋予指针，这样就清楚地指出指针不指向任何对象。
这只是提供了有限的保护
动态内存的一个基本问题是可能有多个指针指向相同的内存，在delete内存之后重置指针的方法只对这个指针有效，对其他任何指向（已释放的）内存的指针是没有作用的。例如：
int *p(new int (42)); //p指向动态内存
auto q=p; //p和q指向相同的内存
delete p; //p和q均变为无效
p=nullptr; //指出p不再绑定到任何对象
本例中p和q指向相同的动态分配的对象。我们delete此内存，然后将p置为nullptr指出它不再指向任何对象，但是，重置p对q没有任何作用，在我们释放p所指向的（同时也是q所指向的）内存时，q也变为无效了。
