C++ primer 第十二章 复习（1）

#include<list>#include<string>#include<memory>//智能指针也是模板,默认初始化的智能指针中保存着一个空指针
std::shared_ptr<std::string> p1;//可指向string
std::shared_ptr<std::list<int>> p2; //可指向 指向int的list(即std::list<int>)
//如果p1不为空,检查它是否可以指向一个空字符串
if (p1&&p1->empty()){
  *p1 ="HI";//解引用p1,将HI赋予其指向的对象
}

//指向一个值为42的int shared_ptr
std::shared_ptr<int> p3 = std::make_shared<int>(42);
//指向一个值为 "9999999999" 的string
std::shared_ptr<std::string> p4 = std::make_shared<std::string>(10,'9');
//指向一个值初始化的int,即值为0
std::shared_ptr<int> p5 = std::make_shared<int>();
//指向一个动态分配的空std::vector<std::string>
auto p6 = std::make_shared<std::vector<std::string>>();

auto r = std::make_shared<int>(42);//r指向的int只有一个引用者
r = q;//给r赋值,令它指向另一个地址
//递增q的引用计数,递减r原来的引用计数,r原来指向的对象没有引用者,会自动释放

//factory返回一个shared_ptr,指向一个动态分配内存的对象
std::shared_ptr<FOO> factory(T arg){
    return std::shared_ptr<FOO>(arg);
}
void use_factory(T arg){
    std::shared_ptr<FOO> p = factory(arg);
}//离开作用域时, arg对象的内存将被自动释放

int* pi = new int; //指向一个动态分配的,未初始化的无名对象
string* ps= new string; //初始化空string

string* ps1 = new string; //默认初始化空string
string* ps2 = new string(); //值初始化为空string
int* pi1 = new int; //默认初始化: 其值未定义
int* pi2 = new int(); //值初始化为 0

auto p1 = new auto(obj); //p1指向一个与 obj 类型相同的对象,该对象使用 obj 初始化
auto p1 = new auto(a,b,c);  //错误:括号中只能有单个初始化器

//分配并初始化一个 const int
const int* pci = new const int(1024);
//分配并默认初始化一个 const 的空 string
const string *pcs = new const string;

int* p1 = new int; //分配失败,则new 抛出std::bad_alloc
int* p1 = new(nothrow); //分配失败,则返回一个空指针
//定位 new 表达式,nothrow 对象告诉它不能抛出异常

int i, *pil = &i, *pi2 = nullptr;
double *pd = new double(33),*pd2 = pd;
delete i; //错误
delete pil; //错误,非动态内存的指针(没有new也不需要delete)
delete pd; //正确
delete pd2; //错误,pd2指向的内存已经被释放了
delete pi2; //正确释放一个空指针没有错
const int* pci = new const int(1024);
delete pci; //正确,释放一个const对象

int *p(new int(42)); //p指向动态内存
auto q = p; //p 和 q 指向相同的内存
delete p; //p 和 q 均变为无效
p = nullptr; //p不再绑定到任何对象
//q依赖是空悬指针

std::shared_ptr<double> p1; 
std::shared_ptr<int> p2(new int(42)); 

std::shared_ptr<int> p1 = new int(1024); //错误,必须直接初始化 
std::shared_ptr<int> p2(new int(42));  //正确
std::shared_ptr<int> clone(int p){
  return std::shared_ptr<int>(new int(p))
}

std::shared_ptr<int> p (new int(42)); //引用计数为1
process(p); //拷贝p会递增它的引用计数,在process中引用计数为2
int i = *p; //正确,引用计数为1
//用内置指针显式构造一个shared_ptr,这样做会导致错误
int* x(new int(1024)); //x是一个普通指针
process(x); //错误,不能将 int* 转换为 shared_ptr<int>
process(std::shared_ptr<int>(x)); //合法,但是内存将会被释放
int j = *x; //j未定义,因为 x 指向的内存已经被释放,x是空悬指针

std::shared_ptr<int> p(new int(42)); //引用计数为1
int* q = p.get(); //正确,但使用q的时候要注意,不要让其管理的指针释放
{ //新程序块
//未定义:两个独立的shared_ptr指向相同的内存
  std::shared_ptr<int>(q);
}
int foo = *p //未定义的,p指向的内存已经被释放了

std::shared_ptr<int> p = new int(42); //错误,不能将一个指针赋予 shared_ptr
std::shared_ptr<int> p;
p.reset(new int(42)); //正确,p指向一个新对象
//-------------------------------------------------
std::shared_ptr<std::string> p;
if (!p.unique()){ //p.use_count为1,返回true,否则返回false
  p.reset(new std::string(*p)); //不是唯一使用者,分配新的拷贝给智能指针
}
*p += newVal; //是唯一对象的使用者,可直接改变对象的值

/*
  使用智能指针,即使程序块过早结束,也能正确释放内存
*/
void f(){
    std::shared_ptr<int> sp(new int(42)); //分配一个新对象
    //这段代码抛出一个异常,且 f()函数未捕获
}//在函数结束时,智能指针会自动释放内存
void f(){
    int *ip = new int(42); //动态分配对象
     //这段代码抛出一个异常,且 f()函数未捕获
    delete ip; //在退出前释放内存,这段释放内存的操作并未被执行
}