shared_ptr<string> p1; //shared_ptr,可以指向string 

shared_ptr<list<int>> p2; //shared_ptr,可以指向int的list 

int *p1=new int; //如果分配失败，new抛出std::bad_alloc;

int *p2=new (nothrow) int; //如果分配失败，new 返回一个空指针

delete p1,p2;

shared_ptr<int> p1=new int(1024); //错误；必须使用直接初始化形式。

shared_ptr<int> p2(new int(1024)); //正确：使用了直接初始化形式。

if(!p.unique())
    p.reset(new string(*p)); //我们不是唯一的用户；分配新的拷贝

*p+=newVal; //可以改变对象的值

//将所有权从一个unique_ptr转移给另一个unique

unique_ptr<string> p2(p1.release()); //release 将p1置为空

unique_ptr<string> p3(new string("Text"));
//将所有权从p3转移给p2

p2.reset(p3.release()); //reset释放了p2原来指向的内存

auto p=make_shared<int>(42);

weak_ptr<int> wp(p);//wp 弱共享p;p的引用计数未改变，因此使用时必须使用函数lock()

if(shared_ptr<int> np=wp.lock()){//如果np不空则条件成立
    
    //在if中，np与p共享对象
}

int *pia=new int[10]; //10个没有初始化的int

int *pia2=new int[10](); //10个初始化为0的int

string *psa=new string[10]; //10个空string

string *psa2=new string[10](); //10个空string

string *psa3=new string[10]{"a","an","the",sting(3,'x')}; //10个string初始化

unique_ptr<int []> up(new int[10]); //up指向10个未初始化int的数组

up.release(); //自动调用delete销毁其指针。

allocator<string > alloc; //可以分配stringd allocator对象

auto const p=alloc.allocate(n); //分配n个未初始化的string

auto q=p;  // q指向最后构造的元素之后的位置

alloc.construct(q++);  //*q为空字符串

alloc.construct(q++,10,'c'); // *q为cccccccccc

std::cout<<*p<<endl; //正确：使用string 的输出运算符

cout<<*q<<endl;  // 灾难： q指向未构造的内存。

//使用完成必须对每个构造的元素调用destory来销毁它们

while (q!=p)
    alloc.destory(--q);  //释放我们真正构造的string，此时元素被销毁，可以重新使用这部分内存来保存其它string

alloc.deallocate(p,n);  //释放内存操作

//分配比vi中元素所占用空间大一倍的动态内存

auto p=alloc.allocate(vi.size()*2);
//通过拷贝vi中的元素来构造从p中开始的元素

auto q=uninitialized_copy(vi.begin(),vi.end(),p);
//将剩余元素初始值为42
uninitialized_fill_n(q,vi.size(),42);

vector<int> v1(10); //正确：直接初始化

vector<int> v2=10; //错误：接受大小参数的构造函数时explicit的

void f(vector<int>); //f的参数进行拷贝初始化

f(10); //错误；不能用一个explicit的构造函数拷贝一个实参

f(vector<int>(10));正确：从一个int直接构造一个临时的vector

string null_book="9-99-99";//拷贝初始化

string null_book("9-99-99"); //编译器略过了拷贝构造函数
//重载赋值运算符

class Foo{
public:
    Foo& operator=(const Foo&); //赋值运算符
    ...
}

Foo& Foo::operator=(const Sales_data &rhs){
    bookNo=rhs.bookNo;  //调用 string::opeator=

    units_sold=rhs.units_sold; //使用内置的int赋值

    ...
    return *this;
}

HasPtr HasPtr::operator=(const HasPtr &rhs)
{
    auto newp=new string(*rhs.ps) ;// 拷贝底层string

    delete ps; //释放旧内存

    ps=newp; //从右侧运算对象拷贝数据到本对象

    i=rhs.i;
    return this; //返回对象本身

}

//stdvec.h
//类vector类内存分配策略的简化实现

class StrVec{
public:
    StrVec():
        elements(nullptr),first_free(nullptr),cap(nullptr){}
    StrVec(const StrVec&); //拷贝构造函数

    StrVec &operator=(const StrVec&); //拷贝赋值运算符

    ~StrVec();  //析构函数

    void push_back(const std::string&);  //拷贝元素

    size_t size() const {return first_free-elements;}
    size_t capacity() const {return cap-elements;}
    std::string *begin() const {return elements;}
    std::string *end() const {return first_free;}
    // ...
private:
    Static std::allocator<std::string> alloc; //分配元素
    //被添加元素的函数所使用
    
    void chk_n_alloc() {if(size()==capacity()) reallocate();}
    //工具函数，被拷贝构造函数、赋值运算符和析构函数所使用
    
    std::pair<std::string*,std::string*> alloc_n_copy(const std::string*,const std::string*);
    void free();  //销毁元素并释放内存

    void reallocate();  //获得更多内存并拷贝已有元素

    std::string *elemets;  //指向数组首元素的指针

    std::string *frist_free; //指向数组第一个空闲元素的指针

    std::string *cap; // 指向数组尾后位置的指针

};

//strvec.cpp

void Strvec::push_back(const string& s)
{
    chk_n_alloc();  //确保有空间容纳新元素

    //在frist_free指向的元素中构造s的副本
    
    alloc.construct(first_free++,s);
};

std::pair<std::string*,std::string*> alloc_n_copy(const std::string* b,const std::string* e)
{
    //分配空间保存给定范围中的元素
    
    auto data=alloc.allocate(e-b);
    //初始化并返回一个pair,该pair由data和uninitialized_copy的返回值构成
    
    return {data.uninitialized_copy(b,e,data)};
}

void StrVec::free()
{
    //不能传递给deallocate 一个空指针，如果elements为0，函数什么也不做
    
    if(elements){
        //逆序销毁旧元素
        
        for(auto p=first_free;p!=elements;)
        {
            alloc.destory(--p);
            alloc.deallocate(elements,cap-elements);
        }
    }
}

StrVec::StrVec(const StrVec &s)
{
    //调用alloc_n_copy 分配内存空间以容纳与s中一样多的元素
    
    auto newdata=alloc_n_copy(s.begin(),s.end());
    elements=newdata.frist;
    frist_free=cap=newdata.second;
}

StrVec::~StrVec(){free();}

StVec &StrVec::operator=(const StrVec &rhs)
{
    //调用alloc_n_copy 分配内存，大小与rhs中元素占用空间一样多
    
    auto data=alloc_n_copy(rhs.begin(),rhs.end());
    free();
    elements=data.first;
    frist_free=cap=data.second;
    return *this;
}

void StrVec::reallocate()
{
    //我们将分配当前大小两倍的内存空间
    
    auto newcapacity=size()?2*size():1;
    //分配新内存
    
    auto newdata=alloc.allocate(newcapacity);
    //将数据从旧内存移动到新内存
    auto dest=newdata;  //指向新数组中下一个空闲位置

    auto elem=elements; //指向旧数组中下一个元素

    for(size_t i=0;i!=size();++i)
    {
        alloc.construct(dust++,std::move(*elem++));
    }
    free(); //一旦我们移动完成元素就释放旧内存空间

    //更新我们的数据结构，执行新元素
    elements=newdata;
    first_free=dest;
    cap=element+newcapacity;

}

auto s1="hello";
auto s2="word";
s1+s2="wow!";

class Foo{
public:
    Foo &operator=(const Foo&) &; //只能向可修改的左值赋值

}

class Foo{
public:
    Foo someMem() & const; //错误限定符const 必须在前
    
    Foo anotherMem() const &; //正确
}

Foo &retFoo();  //返回一个引用；retFoo调用时一个左值

Foo retVal();  // 返回一个值；retVal调用时一个右值

Foo i,j; //i,j均是左值

i=j; //正确：i是左值

retFoo()=j ;// 正确:retFoo()返回一个左值

retVal()=j; //错误:retVal()返回一个右值

i=retVal();  //正确：我们将一个右值作为赋值操作的右侧运算对象

//成员函数可以根据const区分其重载版本，引用也可以区分重载版本

class Foo{
public:
    Foo sorted() &&;  //可用于可改变的右值

    Foo sorted() const &; //可用于任何类型的Foo
}

//本对象为右值，因此可以原址排序

Foo Foo::sorted() &&
{
    sort(data.begin(),data.end());
    return *this;
}

//本对象是const或者是一个左值，不论何种情况我们都不能对其进行原址排序

Foo Foo::sorted() const & {
    Foo ret(*this);  //拷贝一个副本

    sort(ret.data.begin(),ret.data.end());  //排序副本

    return ret;  //返回副本

}

//这里编译器会根据sorted 的对象的左值/右值属性来确定使用那个sorted版本

data1+data2; //普通的表达式

operator+(data1,data2); //等价的函数调用

data1.operator+=(data2); //等价的函数调用

ostream &operator<<(ostream &os,const Sales_data &item)
{
    os<<item.isbn()<<" "<<item.units_sold<<""
    <<item.revenue<<" "<<item.avg_price();

    return os;
}

istream &opertaor>>(istream &is,Sales_data &item)
{
    double price;// 不需要初始化，因为我们将先读入数据到`price`,之后才使用它

    is>>item.bookNo>>iten.units_sold>>price;
    //检查输入是否成功

    if(is)
    {
        item.revenue=item.units_sold*price;
    }else{
        item=Sales_data(); //输入失败：对象呗赋予默认的状态

    }
    return is;


}

//重载赋值运算符
StrVec &StrVec::operator=(initializer_list<string> il)
{
    //alloc_copy分配内存空间，并从给定安慰内拷贝元素
    
    auto data=alloc_n_copy(il.begin(),il.end());
    free();  // 销毁对象中的元素并释放内存空间

    elements=data.frist;//更新数据成员，使其指向新空间

    first_free=cap=data.second; 
    return *this;  

} 

//重载复合赋值运算符

StrVec &StrVec::operator+=(initializer_list<string> il)
{
    unit_sold+=rhs.units_sold;
    revenue+=rhs.revenue;
    return *this;
}

class StrVec{
public:
    std::string& operator [](std::size_t n){return elements[n];}

    const std::string& operator[] (std::size_t n) const
    { return element[n];}

private:
    std::string *elements;  //指向数组首元素的指针
}

const StrVec cvec=svec;  //把svec的元素拷贝到cvec中

//如果svec中含有元素，对第一个元素运行string的empty函数

if(svec.size()&&svec[0].empty){
    svec[0]="zero";  //正确：下标运算符返回string的引用

    svec[0]="Zip";  //错误；对cvec取下标返回的是常量引用
}

//前置版本：返回递增/递减对象的引用

StrBlobPtr& StrBlobPtr::operator++()
{
    //如果curr已经指向了容器的尾后位置，则无法递增它
    
    check(curr,"xxxx");
    ++curr;  //将curr在当前状态下向前移动一个元素

    return *this;
} 

//后置版本:递增/递减对象的值，但是返回原值
StrBlobPtr StrBlobPtr::operator++(int)
{
    //此处无需检查有效性，调用前置递增运算时才需要检查
    
    StrBlobPtr ret=*this;  //记录当前的值

    ++*this   //向前移动一个元素，前置++需要检查递增的有效性

    return ret;  //返回之前记录的状态

}

class StrBlobPtr{
public:
    std::string& operator*() const
    {
        auto p=check(curr,"dereference past end");
        return (*p)[curr];  //(*p)是对象所指的vector

    }
    std::string* operator->() const
    {
        //将实际工作委托给解引用运算符
        return& this->operator*();
    }
    //将两个运算符定义成了const成员，这是因为与递增和递减预算符不一样，获取一个元素并不会改变StrBlobPtr对象的状态
}

strcut absInt{
    int operator()(int val) const
    {
        return val<0?-val:val;
    }
};

//使用

int i=-42; 
absInt absObj;  // 含有函数调用运算符符对象

int ui=absObj(i);  //将i传递给absObj.operator()

vector<string  *> nameTable; //指针的vector
//错误会产生未定义的行为

sort(nameTable.begin(),nameTable.end(),[](string *a,string *b){return a<b;});
//正确：标准库规定指针的less是定义良好的

sort(nameTable.begin(),nameTable.end(),less<string *>());

function<int(int,int)> f1=add;  //函数指针

function<int(int,int)> f2=divide();  //函数对象类的指针

function<int(int,int)> f3=[](int i,int l){return i*j;};  //函数指针

cout<<f1(4,2)<<endl;  //打印

cout<<f2(4,2)<<endl;  //打印

cout<<f3(4,2)<<endl;  //打印8

//使用map映射

map<string,function<int(int,int)> > binops={
    {"+",add},  //函数指针

    {"-",std::minus<int>()},  //标准库函数对象

    {"/",divide()},  // 用户定义的函数对象

    {"*",[](int i,int j){return i*j;}},  //未命名的lambda

    {"%",mod} //已命名的lambda对象
};

class SmallInt{
public:
    //编译器不会自动执行这一类型转换

    explicit operator int() const {return val;}
}
//显式地请求类型转换

SmallInt si=3;
static_cast<int>(si)+3;

class SmallInt{
    friend SmallInt operator+ (const SmallInt&,const SmallInt&);
public:
    SmallInt(int =0);  // 转换源为int的类型转换

    operator int() const {return val;} //转换目标为int的类型转换

private:
    std::size_t val;
};

SmallInt s1,s2;
SmallInt s3=s1+s2;   //使用重载的operator+

int i=s3+0;  //二义性错误