shared_ptr<string> p1;				// shared_ _ptr, 可以指向string
shared_ptr<list<int>> p2;			// shared_ ptr， 可以指向int的list

//如果p1不为空，检查它是否指向一个空string
if (p1 && pl->empty())
	*p1 = "hi"; 			//如果p1指向一个空string,解引用p1,将一个新值赋予string

//指向一个值为42的int的shared_ ptr
shared_ptr<int> p3 = make_shared<int> (42) ;
// p4指向一个值为"999999999"的string
shared_ptr<string> p4 = make_shared<string>(10， '9') ;
// p5指向一个值初始化的(参见3.3.1节，第88页)int,即，值为0
shared_ptr<int> p5 = make_shared<int>() ;

// p6指向一个动态分配的空vector<string>
auto p6 = make_shared<vector<string>>() ;

auto p = make shared<int>(42); // p指向的对象只有p一个引用者
auto q(p); // p和q指向相同对象，此对象有两个引用者

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

// factory 返回一个shared_ ptr, 指向一个动态分配的对象
shared_ptr<Foo> factory(T arg)
	//恰当地处理arg
	// shared_ ptr负责释放内存
	return make_shared<Foo> (arg) ;
}
void use_factory(T arg)
	shared_ptr<Foo> P = factory(arg) ;
	//使用p
} 	// p离开了作用城，它指向的内存会被自动释放掉

Blob<string> bl; // 空Blob
{ 	//新作用域
	Blob<string> b2 = {"a", "an", "the"};
	bl = b2;//bl和b2共享相同的元素
} 	// b2被销毁了，但b2中的元素不能销毁
	// bl指向最初由b2创建的元素

class StrB1ob {
public:
	typedef std::vector<std::string>::size_type size_type;
	StrBlob() ;
	StrBlob(std::initializer_list<std::string> il) ;
	size_type size() const { return data->size(); }
	bool empty() const { return data->empty() ; }
	//添加和删除元素
	void push_back (const std: :string &t) {data->push_ back(t); }
	void pop_back() ;
	//元素访问
	std::string& front () ;
	std::string& back() ;
private:
	std::shared_ptr<std::vector<std::string>> data;
	//如果data[i]不合法，抛出一个异常
	void check(size_type i, const std::string &msg) const;
};

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

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

string& StrBlob::front ()
{
	//如果vector为空，check 会抛出一个异常
	check(0，"front on empty StrB1ob") ;
	return data->front () ;
}
string& StrBlob::back()
{
	check(0，"back on empty StrB1ob") ;
	return data->back() ;
}
void StrBlob::pop_back()
{
	check(0, "pop_back on empty StrBlob") ;
	data->pop_back() ;
}

const string& StrBlob::front ()
{
	//如果vector为空，check 会抛出一个异常
	check(0，"front on empty StrB1ob") ;
	return data->front () ;
}
const string& StrBlob::back()
{
	check(0，"back on empty StrB1ob") ;
	return data->back() ;
}

int *pi = new int; 			// pi指向一个动态分配的、未初始化的无名对象
// 默认情况下，动态分配内存是默认初始化的，意味着内置类型或组合类型的值是未定义的。
string *ps = new string; 	//初始化为空string
int *pi = new int;			// pi指向一个未初始化的int

int *pi = new int(1024);			// pi指向的对象的值为1024
string *ps = new string(10， '9');	// *ps 为"999999999"
// 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 *pil = new int;					//默认初始化; *pi1 的值未定义
int *pi2 = new int();					//值初始化为0; *pi2为0

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

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

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

// factory 返回一个指针，指向一个动态分配的对象
Foo* factory(T arg)
{
	//视情况处理arg
	return new Foo(arg);	 // 调用者负责释放此内存
}
void use_factory(T arg)
{
	Foo *p = factory(arg) ;	//使用p但不delete它
}//p离开了它的作用域，但它所指向的内存没有被释放!

shared_ptr<double> p1; 			//shared_ ptr可以指向一个double
shared_ptr<int> p2 (new int(42)); 	//p2指向一个值为42的int

shared_ptr<int> p1 = new int (1024);		// 错误:必须使用直接初始化形式
shared_ptr<int> p2 (new int(1024));			// 正确:使用了直接初始化形式
shared_ptr<int> clone (int p) {
	return new int(p) ; // 错误:隐式转换为shared ptr<int>
}
shared_ ptr<int> clone(int p) {
return shared_ ptr<int> (new int(p)) ;//正确:显式地用int*创建shared_ ptr<int>
}

int *x(new int (1024)) ;
//危险: x是一个普通指针，不是一个智能指针
process(x); //错误:不能将int*转换为一个shared_ ptr<int>
process(shared_ptr<int>(x)); // 合法的，但内存会被释放!
int j = *x;//未定义的:x是一个空悬指针!

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

p = new int(1024) ;		//错误:不能将一个指针赋予shared_ ptr
p.reset(new int (1024)) ;	//正确: p指向一个新对象

if (!p.unique())
	p.reset (new string(*p)); // 我们不是唯一用户;分配新的拷贝
*p += newVal; //现在我们知道自己是唯一的用户，可以改变对象的值

struct destination;						//表示我们正在连接什么
struct connection;						//使用连接所需的信息
connection connect (destination*) ;		//打开连接
void disconnect(connection) ;			//关闭给定的连接
void f(destination &d /*其他参数*/)
{
	//获得一个连接;记住使用完后要关闭它
	connection C = connect(&d) ;
	//使用连接
	//如果我们在f退出前忘记调用disconnect,就无法关闭c了
}

void end_connection (connection *p) { disconnect(*p); }
void f (destination &d /*其他参数*/)
{
	connection C = connect (&d) ;
	shared_ptr<connection> P(&C, end_connection) ;
	//使用连接
	//当f退出时(即使是由于异常而退出), connection会被正确关闭
}

unique_ ptr <double> p1; //可以指向一个double的unique_ ptr
unique_ ptr<int> p2 (new int(42)); // p2指向一个值为42的int

//将所有权从p1 (指向string Stegosaurus)转移给p2
unique_ptr<string> p2(p1.release()); // release 将p1置为空
unique_ptr<string> p3(new string ("Trex"));
//将所有权从p3转移给p2
p2.reset (p3.release()); // reset 释放了p2原来指向的内存

unique_ptr<int> clone(int p) {
//正确:从int*创建一个unique_ ptr<int>
return unique_ ptr<int> (new int(p) ) ;
}
//还可以返回一个局部对象的拷贝:
unique_ptr<int> clone(int p) {
unique_ptr<int> ret (new int (p) ) ;
return ret;
}

// P指向一个类型为objT的对象，并使用一个类型为delT的对象释放objT对象
//它会调用一个名为fcn的delT类型对象
unique_ptr<objT, delT> P (new objT, fcn) ;

void f(destination &d /*其他需要的参数*/)
{
	connection c = connect (&d); //打开连接
	//当p被销毁时，连接将会关闭
	unique_ptr<connection, decltype(end_connection)*> P(&C， end_connection) ;
	//使用连接
	//当f退出时(即使是由于异常而退出), connection会被正确关闭
}

auto P = make_shared<int> (42) ;
weak_ptr<int> wp(p); // wp弱共享p; p的引用计数未改变

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

//对于访问一个不存在元素的尝试，StrBlobPtr抛出一个异常
class StrBlobPtr {
public:
	StrBlobPtr():curr (0) { }
	StrBlobPtr(StrB1ob &a， size_t sz = 0) :
	wptr(a.data)，curr(sz) { }
	std::string& deref () const;
	StrBlobPtr& incr(); // 前缀递增
private:
	//若检查成功，check返回一个指向vector的shared_ptr
	std::shared_ptr<std::vector<std::string>>
	check(std::size_t，const std::string&) const ;
	//保存一个weak_ptr,意味着底层vector可能会被销毁
	std::weak_ptr<std::vector<std::string>> wptr;
	std::size_t curr; // 在数组中的当前位置
};

std::shared_ptr<std: :vector<std: :string>>
StrBlobPtr::check(std::size_t i, const std::string &msg) const
{
	auto ret = wptr.lock(); // vector还存在吗?
	if (!ret)
		throw std::runtime_error ("unbound StrBlobPtr") ;
	if (i >= ret->size())
		throw std::out_of_range (msg) ;
	return ret; // 否则，返回指向vector的shared_ptr
}

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

//前缀递增:返回递增后的对象的引用
StrBlobPtr& StrBlobPtr::incr ()
{
	// 如果curr已经指向容器的尾后位置，就不能递增它
	check(curr, " increment past end of StrBlobPtr") ;
	++curr; //推进当前位置
	return *this;
}

//此外为了访问data成员需要声明StrBlob的friend
//对于StrBlob 中的友元声明来说， 此前置声明是必要的
class StrBlobPtr;
class StrBlob {
	friend class StrBlobPtr;
	//其他成员与12.1.1节(第405页)中声明相同
	//返回指向首元素和尾后元素的StrBlobPtr
	StrBlobPtr begin() { return StrBlobPtr(*this) ; }
	StrBlobPtr end ()
	{ auto ret = StrBlobPtr(*this， data->size()); return ret;}
    //这里就是
};

//调用get_size确定分配多少个int
int *pia = new int[get_size()]; // pia指向第一个int

//也可以用一个表示数组类型的类型别名分配：
typedef int arrT[42];	// arrT表示42个int的数组类型
int *p = new arrT;		//分配一个42个int的数组; p指向第一个int

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

//10个int分别用列表中对应的初始化器初始化
int *pia3 = new int[10]{0,1,2,3,4,5,6, 7,8,9};
//10个string,前4个用给定的初始化器初始化，剩余的进行值初始化
string *psa3 = new string[10]{"a"， "an", "the", string(3,'x') };

size_t n = get_size(); 	//get_size 返回需要的元素的数目
int* P = new int[n];		//分配数组保存元素
for (int* q = p; q != p + n; ++q) .
	/*处理数组*/ ;

//即使为0，也能够正常运作
char arr[0] ;			//错误:不能定义长度为0的数组.
char *cp = new char[0]; // 正确:但cp不能解引用

delete P;		// p必须指向一个动态分配的对象或为空
delete [] pa; 	//pa必须指向一个动态分配的数组或为空

typedef int arrT[42] ;		// arrT是42个int的数组的类型别名
int *p = new arrT;			//分配一个42个int的数组; p指向第一个元素
delete [] p;				//方括号是必需的，因为我们当初分配的是一个数组

//up指向一个包含10个未初始化int的数组
unique_ptr<int[]> up (new int[10]) ;
up.release(); //自动用delete[]销毁其指针

for (size_t i = 0;i != 10; ++i)
	up[i] = i; //为每个元素赋予一个新值

//为了使用shared_ptr，必须提供一个删除器
shared_ptr<int> sp(new int[10]， [](int *p) { delete[] P; }) ;
sp.reset(); //使用我们提供的lambda释放数组，它使用delete []

// shared_ ptr未定义下标运算符，并且不支持指针的算术运算
for (size_t i = 0;i != 10; ++i)
	* (sp.get() + i) = i; //使用get获取一个内置指针

string *const P = new string[n]; // 构造n个空string
string s;
string *q = P;		// q指向第一个string
while(cin >> s && q != P + n)
	*q++ = s;			//赋予*q一个新值
const size_t size = q - P;		//记住我们读取了多少个string
//使用数组
delete[] p; // P指向一个数组;记得用delete[]来释放

allocator<string> alloc;				//可以分配string的allocator对象
auto const P = alloc.allocate (n) ;		// 分配n个未初始化的string

auto q = p; 						//q指向最后构造的元素之后的位置
alloc.construct(q++);				//*q为空字符串
alloc.construct(q++，10, 'c');		//*q为cccccccccc  
alloc.construct(q++, "hi");			 //*q为hi !

cout << *p <<endl; //正确:使用string的输出运算符
cout << *q <<endl; //灾难:q指向未构造的内存!

while (q != p)
	alloc.destroy(--q);//释放我们真正构造的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(g, vi.size() , 42);

//统计每个单词在输入中出现的次数
map<string，size_t > word_count; // string到size_t 的空map
string word;
while (cin >> word)
	++word_count[word] ;				//提取word的计数器并将其加1
for (const auto &w : word_ count) // 对map中的每个元素
	//打印结果
	cout << w.first << " occurs”<< w.second << ((w.second>1)?”times":”time") << endl;

//统计输入中每个单词出现的次数
map<string，size_t > word_count; 	// string 到size_ t的空map .
set<string> exclude = { "The", "But", "And"， "Or"， "An", "A",
						"the"，"but", "and"， "or"， "an"， "a"};
string word;
while (cin >> word)
	//只统计不在exclude中的单词
	if (exclude. find (word) == exclude.end() )
	++word_ count [word]; 			// 获取并递增word的计数器

map<string，size_ t> word_ count; //空容器
//列表初始化
set<string> exclude = { "the", "but", "and", "or", "an", "a",
						"The", "But"， "And"， "Or", "An"， "A"};
//三个元素; authors将姓映射为名
map<string，string> authors = { {"Joyce", "James"},
								{ "Austen", "Jane"},
								{"Dickens", "Charles"} };

bool compareIsbn (const Sales_data &1hs， const Sales_data &rhs)
{
	return lhs.isbn() < rhs.isbn() ;
}
//然后定义容器时传入该函数,需要提供想要使用的操作的指针：
//bookstore中多条记录可以有相同的ISBN
// bookstore中的元素以ISBN的顺序进行排列
multiset<Sales_data, dec1type(compareIsbn)*>
	bookstore (compareIsbn);

pair<string, string> anon;				//保存两个string
pair<string, size_ t> word_ count;		//保存一个string和一个size_ t
pair<string, vector<int>> line;			//保存string和vector<int>

pair<string, string> author{"James", "Joyce"};

//打印结果
cout << w.first << "occurs" << w.second<< ( (w.second > 1)? ”time s: ”time" ) << endl ;

pair<string，int> process (vector<string> &V)
{
	//处理v
	if (!v.empty())
		return {v. back(), v.back().size()}; // 列表初始化
	else
		return pair<string， int>();			 //隐式构造返回值
}

if (!v.empty())
	return pair<string，int> (v.back()，v.back().size());
if (!v.empty())
	return make_ pair (V.back()，v.back().size());

//获得一个指向首元素的迭代器
auto map_it = word_count.cbegin() ;
//比较当前迭代器和尾后迭代器.
while (map_it != word_count.cend() ) {
	//解引用迭代器，打印关键字-值对
	cout << map_it->first << ”occurs” << map_it->second << " times" << endl;
	++map_it; // 递增迭代器，移动到下一个元素
}

//set容器
vector<int> ivec = {2,4,6,8,2,4,6,8};				// ivec有8个元素
set<int> set2										//空集合
set2.insert(ivec.cbegin()，ivec.cend());				//set2有4个元素
set2.insert({1,3,5,7,1,3,5,7});						// set2现在有8个元素
//insert可以接受一对迭代器，也可以接受一个初始化列表。

//map容器
//向word_count插入word的4种方法
word_count.insert ({word, 1}) ;
word_count.insert (make_pair(word, 1)) ;
word_count.insert (pair<string, size_t>(word, 1)) ;
word_count.insert (map<string，size_t>::value_type (word, 1));

//统计每个单词在输入中出现次数的一种更烦琐的方法
map<string，size_t> word_count; // 从string到size_t的空map.
string word;
while (cin >> word) {
	//插入一个元素，关键字等于word, 值为1;
	//若word已在word_ count中，insert什么也不做
	auto ret = word_count.insert ({word, 1}) ;
	if (!ret.second)				// word已在word_ count中
		++ret.first->second; 		//递增计数器
}

mul timap<string, string> authors;
//插入第一个元素，关键字为Barth， John
authors.insert ({"Barth，John", "Sot-Weed Factor"});
//正确:添加第二个元素，关键字也是Barth， John
authors.insert({"Barth, John", "Lost in the Funhouse"}) ;

//删除一个关键字，返回删除的元素数量
if (word_count.erase (removal_word) )
	cout << "ok:”<< removal_word << ”removed\n";
else cout << "oops: ”<< removal_ word << ”not found! \n";

auto cnt = authors.erase ("Barth，John") ;

map <string， size_t> word_count; / / empty map
//插入一个关键字为Anna的元素，关联值进行值初始化;然后将1赋予它
word_count ["Anna"] = 1;

string search_ item("Alain de Botton") ;		//要查找的作者
auto entries = authors. count (search_ item) ;	//元素的数量
auto iter = authors. find (search_ item) ;		//此作者的第一本书
//用一个循环查找此作者的所有著作
while (entries) {
	cout << iter->second << endl ;				//打印每个题目
	++iter;										//前进到下一本书
	--entries;									//记录已经打印了多少本书
}

// authors 和search_ item 的定义，与前面的程序一样
//beg和end表示对应此作者的元素的范围.
for (auto beg = authors. lower_bound (search_item) ,
		  end = authors.upper_bound (search_item) ;
		  beg != end; ++beg)
	cout << beg->second << endl; //打印每个题目

// authors 和search_item的定义， 与前面的程序一样
// pos保存迭代器对，表示与关键字匹配的元素范围
for (auto pos = authors.equal_range (search_item) ;
	 pos.first != pos.second; ++pos.first)
	cout << pos.first->second << endl; //打印每个题目

size_t hasher(const Sales_ data &sd)
{
	return hash<string>() (sd. isbn()) ;
}
bool eqOp(const Sales_data &lhs， const Sales_data &rhs)
{
	return lhs.isbn() == rhs.isbn() ;
}

using SD_multiset = unordered multiset<Sales_data,
					decltype(hasher)*, decltype(eqOp)*>;
//参数是桶大小、哈希函数指针和相等性判断运算符指针
SD_multiset bookstore(42, hasher, eqOp) ;

//使用FooHash生成哈希值; Foo必须有==运算符
unordered_set<Foo, decltype (FooHash)*> fooSet (10，FooHash);

string val = "a value"; //我们要查找的值
//此调用在list中查找string元素
auto result = find(lst. cbegin()，lst.cend()， val) ;
//类似的，由于指针就像内置数组上的迭代器一样， 我们可以用find在数组中查找值,这里使用到了begin和end:
int ia[] = {27， 210，12, 47， 109， 83};
int val = 83;
int* result = find (begin(ia), end(ia), val);
//还可以在子序列中查找，如从ia[1]开始，直至(但不包含) ia[4]的范围内查找元素
auto result = find(ia + 1，ia+4，val);

//对vec中的元素求和，和的初值是0
int sum = accumulate (vec. cbegin()，vec.cend() ，0);
//第三个参数类型决定了函数使用的加法运算符及返回值类型

//错误: const char*.上没有定义+运算符
string sum = accumulate (v.cbegin()，v.cend(), "") ;

// roster2中的元素数目应该至少与rosterl一样多
equal (roster1 .cbegin()，rosterl.cend() ，roster2. cbegin() ) ;

fill(vec.begin(), vec.end ( ),0);//将每个元素重置为0
//将容器的一个子序列设置为10
fill(vec.begin(), vec.begin () + vec.size ()/2，10);

vector<int> vec; //空vector
//使用vec，赋予它不同值
fill_n(vec.begin (), vec.size ( ),0);//将所有元素重置为0
//函数fill_n假定写入指定个元素是安全的。即，如下形式的调用
fill_n(dest, n, val);
//一定要保证写入后大小不能超过容器大小，因为它不会重新开辟空间
vector<int> vec; //空向量
//灾难:修改vec中的10个（不存在）元素fill_n (vec.begin (),10,0);

vector<int> vec; // 空向量
auto it = back_inserter(vec);//通过它赋值会将元素添加到vec中
*it = 42; // vec中现在有一个元素，值为42
//我们常常使用back_inserter来创建一个迭代器，作为算法的目的位置来使用。例如:
vector<int> vec; //空向量
//正确:back_inserter创建一个插入迭代器，可用来向vec添加元素
fill_n(back_inserter(vec)，10，0); //添加10个元素到vec

void elimDups (vector<string> &words)
{
	//按字典序排序words，以便查找重复单词
	sort (words .begin()，words.end() ) ;
	//unique 重排输入范围，使得每个单词只出现一次
	//排列在范围的前部，返回指向不重复区域之后一个位置的迭代器
	auto end_ _unique = unique (words .begin()，words.end()) ;
	//使用向量操作erase删除重复单词
	words. erase (end_ _unique, words.end()) ;
}

//比较函数，用来按长度排序单词
bool isShorter (const string &s1， const string &s2)
{
	return sl.size() < s2.size() ;
}
//按长度由短至长排序words
sort (words.begin(), words.end(), isShorter);

elimDups (words); // 将words按字典序重排，并消除重复单词
//按长度重新排序，长度相同的单词维持字典序
stable_ sort (words .begin()，words.end() ，isShorter) ;
for (const auto &s : words) // 无须拷贝字符串
	cout << s <<”"; //打印每个元素，以空格分隔
cout << endl;

void biggies (vector<string> &words, vector<string>::size_ type sz)
{
	elimDups (words); // 将words按字典序排序，删除重复单词.
	//按长度排序， 长度相同的单词维持字 典序
	stable_ sort (words .begin(), words.end(), isShorter) ;
	//获取一个迭代器，指向第一个满足size()>= sz的元素
	//计算满足size >= sz的元素的数目
	//打印长度大于等于给定值的单词，每个单词后面接一个空格
}

auto f = []{ return 42; };
cout << f() << endl; 		//打印42

[](const string &a, const string &b)
{return a.size()<b.size ();}

//按长度排序，长度相同的单词维持字典序
stable_sort (words.begin ( ), words.end () , 
             	[](const string &a,const string &b)
					{ return a.size () < b.size();});

[sz] (const string &a) { return a.size() >= SZ; }

//获取一个迭代器，指向第一个满足size () >= sz的元素
auto wc = find_if(words.begin(), words.end () ,
					[sz] (const string &a)
						{ return a.size() >=sz; });
auto count = words.end() - wc;  //它表示size >= sz 元素的数目

//打印长度大于等于给定值的单词，每个单词后面接一个空格
for_each(wc, words.end (), [] (const string &s ) { cout << s <<" "; });
cout << endl;

void biggies(vector<string> &words, vector<string>::size_type sz)
{
	elimDups (words);// 将words按字典序排序，删除重复单词
	//按长度排序，长度相同的单词维持字典序
	stable_sort (words.begin (), words.end(), [](const string &a, const string &b)
												{return a.size() < b.size();});
	//获取一个迭代器，指向第一个满足size () >= sz的元素
	auto wc = find_if (words.begin(), words.end (), [sz] (const string &a)
													{ return a.size () >=sz; });
	//计算满足size >= sz的元素的数目
	auto count = words.end() - wc;
	cout << count << " " << make_plural(count, "word", "s")
		 <<" of length " <<sz<<" or longer" << endl;
	//打印长度大于等于给定值的单词，每个单词后面接一个空格
	for_each (wc, words.end(), [] (const string &s) {cout << s << " ";});
	cout <<endl;
}

void fcn1 ()
size_t v1 =42;		//局部变量
//将v1拷贝到名为f的可调用对象
auto f =[v1] { return vl; };
v1 = 0;
auto j = f(); 		//j为42;f保存了我们创建它时v1的拷贝

void fcn2(){
size_t v1 = 42; 	//局部变量
//对象2包含v1的引用
auto f2 =[ &v1] { return vl; };
v1 = 0;
autoj = f2();		//j为0;f2保存v1的引用，而非拷贝

void biggies(vector<string> &words, vector<string>::size_type sz, 
             ostream &os= cout,char c = ' ')
{
//与之前例子一样的重排words的代码
//打印count的语句改为打印到os
	for_each (words.begin (), words.end ( ), [ &os,c] (const string &s){ os << s<< c; });
}

// sz为隐式捕获，值捕获方式
wc = find_if (words.begin(), words.end(), 
				[=](const string &s) {return s.size() >= sz; });

// os隐式捕获，引用捕获方式;c显式捕获，值捕获方式
for_each ( words.begin(), words.end(), [&, c](const string &s){ os<< s<< c; });
// os显式捕获，引用捕获方式;c隐式捕获，值捕获方式
for_each (words.begin(), words.end(), [=, &os](const string &s){ os << s << c; });

transform (vi.begin(), vi.end(), vi.begin(), 
			[](int i)->int { if (i < 0) return -i; else return i; });

*it = val;
//其效果与下面代码一样
it = c.insert(it, val) ; // it指向新加入的元素
++it; //递增it使它指向原来的元素

list<int> lst = {1,2,3,4 };
list<int> lst2,lst3; 		//空list
//拷贝完成之后，lst2包含4 3 2 1
copy(lst.cbegin (), lst.cend(), front_inserter (lst2 ) ) ;
//拷贝完成之后，lst3包含1 2 3 4
copy (lst.cbegin(), lst.cend( ), inserter(lst3,lst3.begin () ) );

sort (vec.begin(), vec.end()); //按“正常序”排序vec
//按逆序排序:将最小元素放在vec的末尾
sort (vec.rbegin () , vec.rend () );

//在一个逗号分隔的列表中查找第一个元素
auto comma = find (line.cbegin(), line.cend(), ',' );
cout << string (line.cbegin() , comma) << endl;
//在一个逗号分隔的列表中查找最后一个元素
auto rcomma = find(line.crbegin(), line.crend(), ',');
//错误:将逆序输出单词的字符
cout << string(line.crbegin() , rcomma) << endl;
//正确:得到一个正向迭代器，从逗号开始读取字符直到line末尾
cout << string(rcomma.base(), line.cend()) << endl;

unique (beg, end);					//使用==运算符比较元素
unique (beg, end,comp) ;			//使用comp比较元素

find (beg, end,val) ;					//查找输入范围中val第一次出现的位置
find_if (beg, end,pred);				//查找第一个令pred为真的元素

reverse(beg, end);					//反转输入范围中元素的顺序
reverse_copy(beg, end, dest);		//将元素按逆序拷贝到dest
//一些算法同时提供_copy和_if版本。这些版本接受一个目的位置迭代器和一个谓词;
//从v1中删除奇数元素
remove_if(v1.begin (), v1.end(), [](int i){ return i % 2;});
//将偶数元素从v1拷贝到v2;v1不变
remove_copy_if(vl.begin(), v1.end(), back_inserter(v2), [](int i){ return i % 2;});

list<sales_data>					//保存Sales_data对象的list
deque<double>						//保存double的deque

//假定noDefault是一个没有默认构造函数的类型
vector<noDefault> v1 (10, init);				//正确:提供了元素初始化器
vector<noDefault> v2(10) ;						//错误:必须提供一个元素初始化器

while (begin != end){
	*begin = val; 	//正确:范围非空，因此begin指向一个元素
	++begin;		//移动迭代器，获取下一个元素
}

// iter是通过list<string>定义的一个迭代器类型
list<string>::iterator iter;
// count是通过vector<int>定义的一个difference_type类型
vector<int>::difference_type count;

list<string> a ={ "Milton","Shakespeare","Austen" };
auto it1 = a.begin (); 	//list<string>::iterator
auto it2 = a.rbegin (); //list<string>::reverse_iterator
auto it3 = a.cbegin (); //list<string>::const_iterator
auto it4 = a.crbegin(); //list<string>::const_reverse_iterator

//显式指定类型
list<string> : :iterator it5 = a.begin () ;
list<string> : :const_iterator it6 = a.begin ();
//是iterator还是const_iterator依赖于a的类型
auto it7 = a.begin();			//仅当a是const时， it7是const_iterator
auto it8 = a.cbegin (); 		//it8是const_iterator

//每个容器有三个元素，用给定的初始化器进行初始化
list<string> authors = ( "Milton"，"Shakespeare"， "Austen"};
vector<const char*> articles = { "a", "an", "the" };

list<string> list2(authors) ;							//正确:类型匹配
deque<string> authList (authors); 						//错误:容器类型不匹配
vector<string> words(articles); 						//错误:容器类型必须匹配
//正确:可以将const char*元素转换为string
forward_list<string> words (articles.begin ( ), articles.end ( ) );

//拷贝元素，直到(但不包括)it指向的元素
deque<string> authList (authors.begin () , it);

//每个容器有三个元素，用给定的初始化器进行初始化
list<string> authors = {"Milton","Shakespeare"，"Austen"};
vector<const char*> articles = { "a", "an", "the" };

vector<int> ivec ( 10,-1);				// 10个int元素，每个都初始化为-1
list<string> svec (10，"hi! ");			// 10个strings;每个都初始化为"hi !"
forward_list<int> ivec (10) ;			// 10个元素，每个都初始化为0
deque<string> svec (10) ;				// 10个元素，每个都是空string

array<int, 42>						//类型为:保存42个int的数组
array<string,10>					//类型为:保存10个string的数组
array<int, 10>: :size_type i;		//数组类型包括元素类型和大小
array<int> : :size_type j;			//错误:array<int>不是一个类型

array<int, 10> ia1;									//10个默认初始化的int
array<int,10> ia2 = {0,1,2,3,4,5,6,7,8,9};			//列表初始化
array<int,10> ia3 = {42};							// ia3[0]为42，剩余元素为О

int digs [10]= {0,1,2,3,4,5,6,7,8,9};
int cpy [10] = digs;								//错误:内置数组不支持拷贝或赋值
array<int,10> digits = {0,1,2,3,4,5,6,7,8,9};
array<int，10> copy = digits; 						//正确:只要数组类型匹配即合法

c1 =c2;						//将c1的内容替换为c2中元素的拷贝
c1 ={ a,b,c}; 				//赋值后，c1大小为3

array<int,10> al = {0,1,2,3,4,5,6,7,8,9};
array<int,10> a2 = { 0 }; 			//所有元素值均为0
al = a2;							//替换a1中的元素
a2 = {0};							//错误:不能将一个花括号列表赋予数组

list<string> names;
vector<const char*>oldstyle;
names = oldstyle; 							//错误:容器类型不匹配
//正确:可以将const char*转换为string
names.assign (oldstyle.cbegin(), oldstyle.cend() );

//等价于slist1.clear ();
//后跟slist1.insert(slist1.begin (),10，"Hiya ! ");
list<string> slist1 (1);				// 1个元素，为空string
slist1.assign (10,"Hiya ! ");			// 10个元素，每个都是“Hiya !”

vector<string> svec1 (10); 		// 10个元素的vector
vector<string> svec2 (24); 		// 24个元素的vector
swap (svec1, svec2 );

vector<int> v1 = { 1，3，5，7,9，12 };
vector<int> v2 = { 1,3，9 };
vector<int> v3 = { 1,3，5,7 };
vector<int> v4 = { 1,3，5，7，9，12 };
vl < v2 			// true; v1和v2在元素[2]处不同: v1[2]小于等于v2[2]
vl < v3				// false;所有元素都相等，但v3中元素数目更少
vl == v4 			// true;每个元素都相等，且v1和v4大小相同
vl == v2 			// false; v2元素数目比v1少

//从标准输入读取数据，将每个单词放到容器末尾string word;
while (cin >> word)
	container.push back (word);

vector<string> v = { "quasi","simba","frollo", "scar"};		
//将v的最后两个元素添加到slist的开始位置
slist.insert(slist.begin (), v.end () - 2, v.end() ) ;
slist.insert (slist.end(),{ "these"，"words","will"，"go", "at" , "the", "end" ) );
//运行时错误:迭代器表示要拷贝的范围，不能指向与目的位置相同的容器
slist.insert(slist.begin (), slist.begin (), slist.end () ) ;

list<string> lst;
auto iter = lst.begin ();
while (cin >> word)
	iter = lst.insert (iter, word);			 //等价于调用push_front

//在c的末尾构造一个sales_data对象
//使用三个参数的sales_data构造函数
c.emplace_back ( "978-0590353403",25,15.99);
//错误:没有接受三个参数的push_back 版本
c.push_back ("978-0590353403",25,15.99);	
//正确:创建一个临时的Sales_data对象传递给push back
c.push_back(Sales_data("978-0590353403"，25,15.99));

// iter指向c中一个元素，其中保存了sales data元素
c.emplace_back(); //使用Sales_data的默认构造函数
c.emplace(iter,"999-999999999");//使用sales_data (string)
//使用sales_data的接受一个ISBN、一个 count和一个price的构造函数
c.emplace_front ( "978-0590353403"，25，15.99) ;

//在解引用一个迭代器或调用front或back之前检查是否有元素
if ( !c.empty()){
	// val和val2是c中第一个元素值的拷贝
	auto val = *c.begin () , val2 =c.front ();
	// val3和val4是c中最后一个元素值的拷贝
	auto last = c.end () ;
	auto val3 = *(--last); 				//不能递减forward_ list迭代器
	auto val4 = c.back ();				//forward_list不支持

vector<string> svec;					//空vector
cout << svec[0] ;						//运行时错误: svec中没有元素!
cout << svec.at(0) ;					//抛出一个out_ of_ range异常

while (!ilist. empty()) {
	process (ilist. front()) ; 		//对ilist的首元素进行一些处理
	ilist.pop_ front() ;			//完成处理后删除首元素.
}

forward_ list<int> flst = {0,1,2,3,4,5,6,7,8,9};
auto prev = flst.before_ begin() ;				//表示flst的“首前元素’
auto curr = flst.begin() ;						//表示flst中的第一个元素
while (curr != flst.end()) {					//仍有元素要处理
if(*curr % 2)									//若元素为奇数
	curr = flst.erase_ after (prev) ;			//删除它并移动curr
else {		
	prev = curr;								//移动迭代器curr,指向下	一个元素，prev指向
	++curr ;									// curr 之前的元素
}

list<int> ilist(10， 42) ;					// 10个int:每个的值都是42
ilist. resize(15) ;							//将5个值为0的元素添加到ilist的末尾.
ilist. resize(25，-1) ;						//将10个值为-1的元素添加到ilist的末尾
ilist. resize(5) ;							//从ilist末尾删除20个元素

//傻瓜循环，删除偶数元素，复制每个奇数元素
vector<int> vi = {0,1,2,3,4,5,6,7,8,9};
auto iter = vi.begin(); //调用begin而不是cbegin,因为我们要改变vi
while (iter != vi.end()) {
	if (*iter % 2) {
		iter = vi.insert(iter, *iter);	 		//复制当前元素
		iter += 2; //向前移动迭代器，跳过当前元素以及插入到它之前的元素
	} else
		iter = vi.erase (iter) ;				//删除偶数元素
		//不应向前移动迭代器，iter 指向我们删除的元素之后的元素
}

const char *cp = "Hello world!!! ";		//以空字符结束的数组
char noNull[]={'H’, 'i'};				//不是以空字符结束
string s1(cp);							// 拷贝cp中的字符直到遇到空字符;s1 == "Helloworld!!!"
string s2(noNull,2);					//从noNull拷贝两个字符;s2 == "Hi"
string s3 (noNull);						//未定义:noNull不是以空字符结束
string s4(cp + 6，5);					//从cp [ 6]开始拷贝5个字符;s4 =="world"
string s5(s1,6，5) ;						//从s1 [ 6]开始拷贝5个字符;s5 == "world"
string s6(s1,6);						//从s1[ 6]开始拷贝，直至s1末尾;s6== "world! ! !"
string s7(s1,6,20);						//正确，只拷贝到s1末尾;s7 == "world! ! ! "
string s8(s1,16);						//抛出一个out_of_range异常

string s("hello world");
string s2 = s.substr (0,5);			// s2 = hello
string s3 = s.substr (6);			// s3 = world
string s4 = s.substr (6,11);		// s3 = world
string s5 = s.substr (12);			//抛出一个out_of_range异常

s.insert(s.size(), 5，'!');				//在s末尾插入5个感叹号
s.erase(s.size()- 5，5);					//从s删除最后5个字符

const char *cp = "stately, plump Buck";
s.assign(cp,7);						// s == "Stately"
s.insert (s.size(), cp + 7); 		// s == "Stately, plump Buck"

string s = "some string", s2 = "some other string";
s.insert (0, s2); 				//在s中位置0之前插入s2的拷贝
//在s [0]之前插入s2中s2[0]开始的s2.size()个字符
s.insert(0,s2，0, s2.size ());

string s ("C++ Primer"),s2 = s;				//将s 和s2初始化为"C++ Primer"
s.insert (s.size()," 4th Ed.");				//s == "C++ Primer 4th Ed."
s2.append(" 4th Ed." );						//等价方法:将”4th Ed."追加到s2;s == s2

//将"4th"替换为"5th"的等价方法
s.erase (11，3);								// s == "C++ Primer Ed . "
s.insert (11，"5th" ) ;						// s == "C++ Primer 5th Ed . "
//从位置11开始，删除3个字符并插入"5th"
s2.replace(11,3,"5th");						//等价方法:s == s2

s.replace(11,3，"Fifth");					// s == "C++ Primer Fifth Ed."

string name ("AnnaBelle");
auto posl = name.find ( "Anna"); // pos1 ==o
string lowercase ( "annabelle" );
pos1 = lowercase.find ( "Anna"); // posl ==npos

string numbers ( "0123456789"), name ( "r2d2") ;
//返回1，即，name中第一个数字的下标
auto pos = name . find_first_of (numbers) ;
string dept ( "03714p3");				
//返回5——字符'p'的下标
auto pos = dept.find_ first_not_of (numbers) ;

string : : size_type pos = 0;
//每步循环查找name中下一个数
while ((pos = name.find_first_of (numbers, pos)) != string::npos) {
	cout <<"found number at index : " << pos <<" element is " <<name [pos] << endl;
	++pos; //移动到下一个字符
}

string river ( "Mississippi" );
auto first_pos = river.find ( "is"); //返回1
auto last_pos - river.rfind ( "is"); //返回4

int i = 42;
string s = to_string(i); 			//将整数i转换为字符表示形式
double d = stod (s) ;				//将字符串s转换为浮点数

//转换s中以数字开始的第一个子串，结果d = 3.14
d = stod(s2.substr(s2.find_first_of("+-.0123456789")));

deque<int> deq = {1,2,3,4};
stack<int> stk (deq); //从deq考贝元素到stk

//在vector上实现的空栈
stack<string, vector<string>> str_stk;
//str_stk2在vector上实现，初始化时保存svec的拷贝
stack<string, vector<string>> str_stk2 (svec) ;

stack<int> intstack; //空栈
//填满栈
for (size_t ix = 0; ix != 10; ++ix)
	intStack.push (ix);				// intStack保存0到9十个数
while ( !intstack.empty()) {		// intStack中有值就继续循环
	int value = intStack.top ( ) ;
	//使用栈顶值的代码
	intStack.pop() ;				 //弹出栈顶元素，继续循环
}

//重复读入数据直至到达文件末尾或某次输入的值等于sought
while (cin >> s &&s != sought)
	; //空语句

sales_data total ;								//保存当前求和结果的变量
if(read (cin, total)){							//读入第一笔交易
	sales_data trans;							//保存下一条交易数据的变量
	while(read (cin,trans)){					//读入剩余的交易
		if (total .isbn ( ) == trans.isbn ( ))	//检查 isbn
			total.combine (trans);				//更新变量total当前的值
        else {
			print (cout, total) << endl;		//输出结果
            total = trans;						//处理下一本书
		}
		print (cout, total) << endl ;			//输出最后一条交易
}
else {											//没有输入任何信息
	cerr <<"No data?! " << endl ;				//通知用户
}

struct sales_data {
	//新成员:关于sales_data对象的操作
	std: :string isbn ( ) const { return bookNo;}
	Sales_data& combine (const sales_data&);
	double avg_price ( ) const;
	//数据成员和2.6.1节（第64页）相比没有改变
	std::string bookNo;
	unsigned units_sold = 0;
	double revenue = 0.0;
};
// sales_data的非成员接口函数
sales_data add (const Sales_data&,const Sales_data&) ;
std::ostream &print(std: :ostream&,const sales_data&) ;
std::istream &read(std: :istream&,Sales_data&) ;