class Foo{
public:
    Foo(); //默认构造函数 
    Foo(const Foo&); //拷贝构造函数
    //...
};

class Sales_data{
public:
    Sales_data(const Sales_data&); //其他成员和构造函数的定义，如前，与合成的拷贝构造函数等价的拷贝构造函数的声明
private:
    std::String bookNo;
    int units_sold = 0;
    double revenue = 0.0;
};
//与Sales_data 的合成的拷贝构造函数等价
Sales_data::Sales_data(const Sales_data &orig):
bookNo(orig.bookNo),  //使用string的拷贝构造函数
units_sold(orig.units_sold), //拷贝orig.units_sold
revenue(orig.revenue){} //拷贝orig.revenue

string dots(10,'.'); //直接初始化
string s(dots);  //直接初始化
string s2 = dots; //拷贝初始化
string nines = string(100,'9'); //拷贝初始化

string null_oo("0000000");
class Hasptr{
public:
    HasPtr(const string &s = string()):ps(new string(s)),i(0){}
private:
    string *ps;
    int i;
};

HasPtr::HasPtr(const HasPtr &ptr):ps(new string(*(ptr.ps))), i(ptr.i){}

Sales_data trans,accum;
trans = accum; // 使用Sales_data的拷贝赋值运算符

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

Sales_data& Sales_data::operator=(const Sales_data &rhs){
bookNo = rhs.bookNo; //调用string::operator=
units_sold = rhs.units_sold; //使用内置的int赋值
revenue = rhs.revenue; //使用内置的double赋值
return *this; //返回一个此对象的引用
}

#ifndef ex13_8_h
#define ex13_8_h

#include <string>
class HasPtr{
public:
    HasPtr(const string& s = string()):ps(new string()),i(0){}
    HasPtr(const HasPtr& hp):ps(new string(*hp.ps)),i(hp.i){}
    HasPtr& operator=(const HasPtr& hp){
        string *new_ps = new string(*hp.ps);
        delete ps;
        ps = new_ps;
        i = hp.i;
        return *this;
}
private:
    string *ps;
    int i;
};
#endif

class Foo{
public:
    ~Foo(); //
};

{//新作用域
Sales_data *p = new Sales_data; //p是一个内置指针
auto p2 = make_shared<Sales_data>(); //p2是一个shared_ptr
Sales_data item(*p); //拷贝构造函数将*p拷贝到item中
vector<Sales_data> vec; //局部对象
vec.push_back(*p2); //拷贝p2指向的对象
delete p; //对p指向的对象执行析构函数
} //退出局部作用域；对item、p2和vec调用析构函数
//销毁p2会递减其引用计数；如果引用计数变为0，对象被释放
//销毁vec会销毁它的元素

class Sales_data{
public:
~Sales_data(){}
};

void f(numbered s) { cout<< s.mysn <<endl; }

class Sales_data{
public:
Sales_data() = default;
Sales_data(const Sales_data&) = default;
Sales_data& operator=(const Sales_data &);
~Sales_data() = default;
};

Sales_data& Sales_data::operator=(const Sales_data&) = default;

struct noCopy{
    NoCopy() = default; //使用合成的默认构造函数
    NoCopy(const NoCopy&) = delete; //阻止拷贝
    NoCopy &operator=(const NoCopy&) = delete; //阻止赋值
    ～NoCopy() = default; // 使用合成的析构函数
};

class PrivateCopy{
PrivateCopy(const PrivateCopy&);
PrivataCopy &operator=(const PrivateCopy&);
public:
PrivateCopy() = default;//使用合成的默认构造函数
~PrivateCopy(); // 用户可以定义此类型的对象，但是无法拷贝它

class Employee{
public:
    Employee();
    Employee(const string& name);
    Employee(const Employee&) = delete;
    Employee& operator=(const Employee&)=delete;
    const int id() const{ return id_;}
private:
    string name_;
    int id_;
    static int s_increment;
};

int Employee::s_increment = 0;
Employee::Employee(){
    id_ = s_increment++;
}
Employee::Employee(const string& name){
    id_ = s_increment++;
    name_ = name;
}
#endif

class HasPtr{
public:
HasPtr(const std::string &s = std::string()):ps(new std::string(s)),i(0){}
HasPtr(const HasPtr&):ps(new string(*hp.ps)),i(hp.i){};
HasPtr& operator=(const HasPtr &hp){
auto new_p = new string(*hp.ps);
delete ps;
ps = new_p;
i = hp.i;
return *this;
}
~HasPtr(){
delete ps;
}
private:
string *ps;
int i;
};

class HasPtr{
    public:
        HasPtr(const string &s = string()):ps(new string(s)),i(0){} //对ps指向的string，每个HasPtr对象都有自己的拷贝
        HasPtr(const HasPtr &p):ps(new string(*p.ps)),i(p.i){}
        HasPtr& operator=(const HasPtr &);
        ~HasPtr(){delete ps;}
    private:
        string *ps;
        int i;
}

HasPtr& HasPtr::operator=(const HasPtr &rhs){
    auto newp = new string(*rhs.ps); //拷贝底层string
    delete ps; //释放旧内存
    ps = newp; //从右侧运算对象拷贝数据到本对象
    i = rhs.i;
    return *this; //返回本对象
}

#ifndef ex13_26_h
#define ex13_26_h

#include <vector>
#include <string>
#include <initializer_list>
#include <memory>
#include <exception>

using std::vector; using std::string;

class ConstStrBlobPtr;

class StrBlob
{
public:
	using size_type = vector<string>::size_type;
	friend class ConstStrBlobPtr;

	ConstStrBlobPtr begin() const;
	ConstStrBlobPtr end() const;

	StrBlob() :data(std::make_shared<vector<string>>()) {}
	StrBlob(std::initializer_list<string> il) :data(std::make_shared<vector<string>>(il)) {}

	// copy constructor
	StrBlob(const StrBlob& sb) : data(std::make_shared<vector<string>>(*sb.data)) {}
	// copyassignment operators
	StrBlob& operator=(const StrBlob& sb);

	size_type size() const { return data->size(); }
	bool empty() const { return data->empty(); }

	void push_back(const string &t) { data->push_back(t); }
	void pop_back()
	{
		check(0, "pop_back on empty StrBlob");
		data->pop_back();
	}

	std::string& front()
	{
		check(0, "front on empty StrBlob");
		return data->front();
	}

	std::string& back()
	{
		check(0, "back on empty StrBlob");
		return data->back();
	}

	const std::string& front() const
	{
		check(0, "front on empty StrBlob");
		return data->front();
	}
	const std::string& back() const
	{
		check(0, "back on empty StrBlob");
		return data->back();
	}

private:
	void check(size_type i, const string &msg) const
	{
		if (i >= data->size()) throw std::out_of_range(msg);
	}

private:
	std::shared_ptr<vector<string>> data;
};

class ConstStrBlobPtr
{
public:
	ConstStrBlobPtr() :curr(0) {}
	ConstStrBlobPtr(const StrBlob &a, size_t sz = 0) :wptr(a.data), curr(sz) {} // should add const
	bool operator!=(ConstStrBlobPtr& p) { return p.curr != curr; }
	const string& deref() const
	{ // return value should add const
		auto p = check(curr, "dereference past end");
		return (*p)[curr];
	}
	ConstStrBlobPtr& incr()
	{
		check(curr, "increment past end of StrBlobPtr");
		++curr;
		return *this;
	}

private:
	std::shared_ptr<vector<string>> check(size_t i, const string &msg) const
	{
		auto ret = wptr.lock();
		if (!ret) throw std::runtime_error("unbound StrBlobPtr");
		if (i >= ret->size()) throw std::out_of_range(msg);
		return ret;
	}
	std::weak_ptr<vector<string>> wptr;
	size_t curr;
};

ConstStrBlobPtr StrBlob::begin() const // should add const
{
	return ConstStrBlobPtr(*this);
}
ConstStrBlobPtr StrBlob::end() const // should add const
{
	return ConstStrBlobPtr(*this, data->size());
}

StrBlob& StrBlob::operator=(const StrBlob& sb)
{
	data = std::make_shared<vector<string>>(*sb.data);
	return *this;
}


#endif // !ex13_26_h

HasPtr p1("haha");
HasPtr p2(p1); //p1和p2指向相同的string
HasPtr p3(p1); // p1、p2和p3都指向相同的string

class HasPtr{
	public:
	// 构造函数分配新的string和新的计数器，将计数器置为1.
	HasPtr(const string &s = string()):ps(new string(s)),i(0),use(new size_t(1));
	// 拷贝构造函数拷贝所有三个数据成员，并递增计数器
	HasPtr(const HasPtr &p):ps(p.ps),i(p.i),use(p.use){++*use;}
	HasPtr& operator=(const HasPtr&);
	~HasPtr();
	private:
	string *ps;
	int i;
	size_t *use; //用来记录有多少个对象共享*ps的成员
}

HasPtr::~HasPtr(){
	if(--*use == 0){
		delete ps;
		delete use;
	}
}

HasPtr& HasPtr::operator=(const HasPtr &rhs){
	++*rhs.use;
	if(--*use == 0){
		delete ps;
		delete use;
	}
   	ps = rhs.ps; // 将数据从rhs拷贝到本对象
	i = rhs.i;
	use = rhs.use;
	return *this; //返回本对象
}

class TreeNode{
	public:
	TreeNode():value(string()),count(1){};
	TreeNode(const TreeNode& tn):value(tn.value),count(tn.count),left(tn.left),right(tn.right){
     ++count;
	}
	TreeNode& operator=(const TreeNode &tn);
	~TreeNode(){
		if(--count == 0){
			if(left){
				delete left;
				left = nullptr;
			}
			if(right){
				delete right;
				right = nullptr;
			}
		}
	};
	private:
	   string value;
	   int count;
	   TreeNode *left;
	   TreeNode *right;
}

TreeNode& TreeNode::operator=(const TreeNode &tn){
	++tn.count;
	if(--count == 0){
			if(left){
				delete left;
				left = nullptr;
			}
			if(right){
				delete right;
				right = nullptr;
			}
		}
	value = tn.value
	left = tn.left;
	right = tn.right;
	count = tn.count;
	return *this;
}
// 记住啦，衰仔！呢度
class BinStrTree{
	public:
	BinStrTree():root(new TreeNode()){}
	BinStrTree(const BinStrTree &bst):root(new TreeNode(*bst.root)){}
	BinStrTree& operator=(const BinStrTree &bst);
	~BinStrTree(){delete root;}
	private:
	TreeNode *root;
}
BinStrTree& BinStrTree::operator=(const BinStrTree &bst){
	TreeNode *new_root = new TreeNode(*bst.root);
	delete root;
	root = new_root;
	return *this;
}

class HasPtr{
	friend void swap(HasPtr&, HasPtr&);
};
inline void swap(HasPtr &lhs,HasPtr &rhs){
	using swap;
	swap(lhs.ps,rhs.ps); //交换指针，而不是string数据
	swap(lhs.i,rhs.i); // 交换int成员
}

void swap(HasPtr &lhs,HasPtr &rhs){
	using swap;
	swap(lhs.ps,rhs.ps); //交换指针，而不是string数据
	swap(lhs.i,rhs.i); // 交换int成员
}

// 注意 rhs是按值传递的，意味着HasPtr的拷贝构造函数
// 将右侧运算对象中的string拷贝到rhs
HasPtr& HasPtr::operator=(HasPtr rhs){
	// 交换左侧运算对象和局部变量rhs的内容
	swap(*this,rhs); //rhs现在指向本对象曾经使用的内存
	return *this; // rhs被销毁，从而delete了rhs中的指针
}

bool operator<(const HasPtr& rhs, const HasPtr& lhs){
	return *rhs.ps < *lhs.ps;
}

// Message
class Message{
	friend class Folder;
	public:
	// folders 被隐式初始化为空集合
	explicit Message(const string &str = ""):contents(str){}
	// 拷贝控制成员，用来管理指向本Message的指针
	Message(const Message&); // 拷贝构造函数
	Message& operator=(const Message&); // 拷贝赋值运算符
	~Message(); //析构函数
	void save(Folder&);
	void remove(Folder&);
	private:
    string contents; // 消息文本
	set<Folder*> folders; // 包含本Message的Folder
	// 拷贝构造函数、拷贝赋值运算符和析构函数所使用的工具函数将本Message添加到指向参数的Folder中
	void add_to_Folders(const Message&);
	// 从folders中的每个Folder中删除本Message
	void remove_from_Folders();
};

class Folder{
    friend void swap(Message&, Message&);
	friend void swap(Folder&, Folder&);
	friend class Message;
    public:
	Folder() = default;
	Folder(const Folder&);
	Folder& operator=(const Folder&);
	~Folder();
	void print_debug();
    private:
	std::set<Message*> msgs;
	void add_to_Message(const Folder&);
	void remove_to_Message();
	void addMsg(Message* m) { msgs.insert(m); }
	void remMsg(Message *m) { msgs.erase(m); }
};
void swap(Folder&, Folder&);
// save and remove
void Message::save(Folder &f){
	folders.insert(&f);
	f.addMsg(this);
}

void Message::remove(Folder &f){
	folders.erase(&f);
	f.remMsg(this);
}
// 当我们拷贝一个Message时，得到的副本与 原Message出现在相同的Folder中。因此，我们必须遍历Foloder指针的set，对每个指向原Message的Folder添加一个指向新Message的指针。拷贝构造函数和拷贝赋值运算符都需要做这个工作。
void Message::add_to_Folders(const Message &m){
	for(auto f:m.folders) // 对每个包含m的Folder
	    f->addMsg(this);  // 向该Folder添加一个指向本Message的指针
}

// Message的拷贝构造函数拷贝给定对象的数据成员
Message::Message(const Message &m):contents(m.contents),folders(m.folders){
	add_to_Folders(m);
}
// 调用add_to_Folders将新创建的Message的指针添加到每个包含原Message的Folder中

// 析构函数
// 当一个Message被销毁时，我们必须从指向此Message的Folder中删除它。
void Message::remove_from_Folders(){
	for(auto f:folders)
	f->remMsg(this);
}
Message::~Message(){
	remove_from_Folders();
}
// 拷贝赋值运算符
// 从左侧运算对象的folders中删除此Message的指针，然后再将指针添加到右侧运算对象的folders中，从而实现了自赋值
Message& Message::operator=(const Message &rhs){
	remove_from_Folders(); // 更新已有的Folder
	contents = rhs.contents; //从rhs拷贝消息内容
	folders = rhs.folders; //从rhs拷贝Folder指针
	add_to_Folders(rhs);
	return *this;
}
// 两遍扫描folders中每个成员来正确处理Folder指针
void swap(Message &lhs, Message &rhs){
	using std::swap;
	for(auto f:lhs.folders)
	f->remMsg(&lhs);
	for(auto f:rhs.folders)
	f->remMsg(&rhs);
    swap(lhs.folders, rhs.folders);
	swap(lhs.contents, rhs.contents);
	for(auto f:lhs.folders) // 对每个包含lhs的Folder
	    f->addMsg(&lhs);  // 向该Folder添加一个指向本Message的指针
	for(auto f:rhs.folders) // 对每个包含rhs的Folder
	f->addMsg(&rhs);  // 向该Folder添加一个指向本Message的指针
	
}

class StrVec{
	public:
	StrVec():elements(nullptr),first_free(nullptr),cap(nullptr){}
	StrVec(const StrVec&);
	// StrVec(initializer_list<sting>);// 13.40
	StrVec &operator=(const StrVec&);
	~StrVec();
	void push_back(const string&);
	size_t size() const{ return first_free - elements; }
	size_t capacity() const {return cap-elements;}
	string *begin() const { return elements; }
	string *end() const { return first_free; }
	// ...
	private:
	static allocator<string> alloc; //分配元素
	// 被添加元素的函数所使用
	// void range_initialize(const sting*,const string*); // 13.40
	void chk_n_alloc() { if(size()==capacity()) reallocate();}
	// 工具函数，被拷贝构造函数、赋值运算符和析构函数所使用
	pair<string*, string*> alloc_n_copy(const string*, const string*);
	void free();
	void reallocate();
	string *elements;
	string *first_free;
	string *cap;
};
// 使用construct
void StrVec::push_back(const string& s){
	chk_n_alloc();
	alloc.construct(first_free++, s);
}
// alloc_n_copy成员，类似vector，StrVec类有类值行为。当我们拷贝或赋值StrVec时，必须分配独立的内存，并从原StrVec对象拷贝元素至新对象
// alloc_n_copy 成员会分配足够的内存来保存给定范围的元素，并将这些元素拷贝到新分配的内存中。此函数返回一个指针的pair，两个指针分别指向新空间的开始位置和拷贝的尾后的位置:
pair<string *, string*> StrVec::alloc_n_copy(const string *b, const string *e){
	// 分配空间保存给定范围中的元素
	auto data = alloc.allocate(e-b);
	// 初始化并返回一个pair，该pair由data和uninitialized_copy的返回值构成,uninitialized_copy(b,e,data)返回的是一个指针，指向最后一个构造元素之后的位置
	return { data, uninitialized_copy(b,e,data)};
}
// free 成员 for循环调用allocator的destory成员，从构造的尾元素开始，到首元素为止，逆序销毁所有元素:
void StrVec::free(){
	// 不能传递给deallocate一个空指针，如果elements为0，函数什么也不做
	if(elements){
		//逆序销毁旧元素
		for(auto p = first_free; p!=elements;)
		alloc.destory(--p);
		alloc.deallocate(elements, cap-elements);
	}
} // destory函数会运行string的析构函数。string的析构函数会释放string自己分配的内存空间
// 另一种写法
void StrVec::free(){
    for_each(elements, first_free,[this](string &rhs){ alloc.destory(&rhs);});
}
// 实现拷贝控制成员
StrVec::StrVec(const StrVec &s){
    // 调用alloc_n_copy分配空间以容纳与(s中一样多的元素
	auto newdata = alloc_n_copy(s.begin(),s.end());
	elements = newdata.first;
	first_free = cap = newdata.second;
}
// 析构函数
StrVec::~StrVec() { free(); }
// 拷贝赋值运算符
StrVec &StrVec::operator=(const StrVec &rhs){
	// 调用alloc_n_copy分配内存，大小与rhs中元素占用空间一样多
	auto data = alloc_n_copy(ths.begin(),rhs.end());
	free();
	elements = data.first;
	first_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(dest++,std::move(*elem++)); // 这里要注意时std::move❕
	free();// 一旦我们移动完元素就释放旧内粗空间
	// 更新我们的数据结构，执行新元素
	elements = newdata;
	first_free = dest;
	cap = elements + newcapacity;
}

// 编写自己的string类
#include <memory>
class String{
	public:
	String():String(""){}
	String(const char*);
	String(const String&);
	String& operator=(const String&);
	~String();
	const char* c_str() const {return elements;}
	size_t size() const {return end-elements;}
	size_t lenght() const{return end-elements+1;}
	private:
	std::pair<char*, char*> alloc_n_copy(const char*,const char*);
	void range_initializer(const char*, const char*);
	void free();
	private:
	char *elements;
	char *end;
	std::allocator<char> alloc;
}

#include <algorithm>
#include <iostream>

std::pair<char*,char*> String::alloc_n_copy(const char* b, const char* e){
     auto str = alloc.allocate(e-b);
	 return {str,std::uninitialized_copy(b,e,str)};
}

void String::range_initializer(const char* first, const char* last){
	auto newstr = alloc_n_copy(first,last);
	elements = newstr.first;
	end = newstr.second;
}

String::String(const char* s){
	char *s1 = const_cast<char*>(s);
	while(*s1){
		++s1;
	}
	range_initializer(s,++s1);
}

String::String(const String& rhs){
	range_initializer(rhs.elements,rhs,end);
	cout<<"copy construct"<<endl;
}

void String::free(){
	if(elements){
		std::for_each(elements,end,[this](char &c){alloc.destory(&c);});
		alloc.deallocate(elements, end-elements);
	}
}

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

String& String::operator=(const String& rhs){
	auto newstr = alloc_n_copy(rhs.elements,rhs,end);
	free();
	elements = newstr.first;
	end = newstr.second;
	std::cout<<"copy-assignment"<<std::endl;
	return *this;
}

int i=42;
int &r = i; // 正确，r引用i
int &&rr = i; // 错误，不能将一个右值引用绑定到一个左值上
int &r2 = i*42 // 错误，i*42是一个右值
const int &r3 = i*42; // 将一个const的引用绑定到一个右值上
int &&rr2 = i*42; // 将rr2绑定到乘法结果上

int &&rr1 = 42;
int &&rr2 = rr1; //错误：表达式rr1是左值！
int &&rr3 = std::move(rr1); //正确： 转换为对应的右值引用类型
int f();
vector<int> vi(100);
int&& r1 = f();
int& r2 = vi[0];
int& r3 = r1;
int&& r4 = vi[0] * f();

StrVec::StrVec(StrVec &&s) noexcept //移动操作不应抛出任何异常
:elements(s.elements), first_free(s.first_free),cap(s.cap){ //成员初始化器接管s中的资源
	s.elements = s.first_free = s.cap = nullptr; // 令s进入这样的状态---对其运行析构函数是安全的。
}

class StrVec{
	public:
	StrVec(StrVec&&) noexcept;
};

StrVec::StrVec(StrVec &&s) noexcept:...

StrVec &StrVec::operator=(StrVec &&rhs) noexcept{
	//直接检测自赋值
	if(this != &rhs){
		free(); // 释放已有元素
		elements = rhs.elements; // 从rhs接管资源
		first_free = rhs.first_free;
		cap = rhs.cap;
		// 将rhs置于可析构状态
		rhs.elements = rhs.first_free = rhs.cap = nullptr;
	}
	return *this;
}

struct X{
	int i; //内置类型可以移动
	std::string s; // string定义了自己的移动操作
};
struct hasX{
	X mem; // X有合成的移动操作
}
X x,x2 = std::move(x); //使用合成的移动构造函数
hasX hx,hx2 = std::move(hx); // 使用合成的移动构造函数

struct hasY{
	hasY() = default;
	hasY(hasY&&) = default;
	Y mem; //hasY将又一个删除的移动构造函数
}；
hasY hy,hy2 = std::move(hy); // 🙅 错误：移动构造函数是删除的。

StrVec v1,v2;
v1=v2; // v2是左值；使用拷贝赋值
StrVec getVec(istream &); // getVec返回一个右值
v2 = getVec(cin);// getVec(cin) 是一个右值；使用移动赋值

class Foo{
	public:
	Foo() = default;
	Foo(const Foo&); // 拷贝构造函数
	// 其他成员定义，但Foo未定义移动构造函数
};
Foo x;
Foo y(x);// 拷贝构造函数；x是一个左值
Foo z(std::move(x)); // 拷贝构造函数，因为未定义移动构造函数。 返回一个绑定到x的Foo&&

class HasPtr{
	public:
	// 添加的移动构造函数
	HasPtr(HasPtr &&p) noexcept:ps(p.ps),i(p.i){p.ps = 0;}
	// 赋值运算符既是移动赋值运算符，也是拷贝赋值运算符
	HasPtr& operator=(HasPtr rhs){swap(*this,rhs); return *this; }
};

hp = hp2; // hp2 是一个左值；hp2通过拷贝构造函数来拷贝
hp = std::move(hp2); // 移动构造函数移动hp2

void Message::move_Folders(Message *m){
	folders = std::move(m->folders); // 使用set的移动赋值运算符
	for(auto f : folders){ // 对每个Folder
		f->remMsg(m); // 从Folder中删除旧Message
		f->addMsg(this); //将本Message添加到Folder中
	}
	m->folders.clear(); // 确保销毁m是无害的
}

Message::Message(Message &&m):contents(std::move(m.contents)){
	move_Folders(&m); // 移动folders并更新Folder指针
}

Message& Message::operator=(Message &&rhs){
	if(this != &rhs){ // 直接检查自赋值情况
		remove_from_Folders();
		contents = std::move(rhs.contents); // 移动赋值运算符
		move_Folders(&rhs); // 重置Folders指向本Message
	}
	return *this;
}

void StrVec::reallocate(){
	auto newcapacity = size()?2*size():1;
	auto first = alloc.allocate(newcapacity);
	auto last = unitialized_copy(make_move_iterator(begin()),make_move_iterator(end()),first);
	free();
	elements = first;
	first_free = last;
	cap = elements+newcapacity;
}

	error: ambiguous overload for 'operator=' (operand types are 'HasPtr' and 'std::remove_reference<HasPtr&>::type { aka HasPtr }')
	hp1 = std::move(*pH);
	^

void push_back(const X&); // 拷贝，绑定到任意类型的X
void push_back(X&&); // 移动，只能绑定到类型X的可修改的右值

class StrVec{
	public:
	void push_back(const std::string&); // 拷贝，绑定到任意类型的X
    void push_back(string&&); // 移动，只能绑定到类型X的可修改的右值
};
void StrVec::push_back(const string& s){
	chk_n_alloc();
	alloc.construct(first_free++,s); // 在first_free 指向的元素中构造s的副本
}
void StrVec::push_back(string &&s){
	chk_n_alloc(); //如果需要的话为StrVec重新分配内存。
	alloc.construct(first_free++,std::move(s));
}

class Foo{
	public:
	Foo &operator=(const Foo&) &; // 限定只能向可修改的左值赋值
}
Foo &Foo::operator=(const Foo &rhs) &{
	return *this;
}

class Foo{
	public:
	Foo sorted() &&;
	Foo sorted() const &;
	private:
	vector<int> data;
}

Foo Foo::sorted() &&{
	sort(data.begin(),data.end());
	return *this;
}
Foo Foo::sorted() const &{
	Foo ret(*this);
	sort(ret.data.begin(),ret.data.end()); // 不能改变原对象，因此就需要在排序前拷贝data
	return ret;
};

void push_back(string &&s) { data->push_back(std::move(s)); }

Foo Foo::sorted() const & {
	Foo ret(*this);
	return ret.sorted();
}