if(cin)
	// 有效状态

while(cin >> word)
	// 读操作成功

istream::iostate old_state = cin.rdstate();
cin.clear();
process_input();	// 使用 cin
cin.clear(old_state);	// 恢复到原来的状态.

is.setstate(ifstream::badbit | ifstream::failbit);		// 同时打开了 badbit和failbit

cout << unitbuf << "first" << " second" << nounitbuf;
// 等价于
cout << "first" << flush << "second" << flush;

cin.tie(cout);		// 缺省
ostream *old_tie = cin.tie();	// 得到现在绑定的输出对象指针
cin.tie(0);  // 取消绑定
cin.tie(&cerr);		
// ...
cin.tie(0);
cin.tie(old_tie);

ifstream input;
vector<string>::const_iterator it = files.begin();
while(it != files.end())
{
	input.open(it->c_str());
	if(!input)
		break;
	while(input >> s)
		process(s);
	input.close();
	input.clear();	// 如果不调用该函数, 则输入流的 eofbit 始终被设置.
	++it;
}

int val1 = 512, val2 = 1024;
ostringstream format_message;
format_message << "Val1: " << val1 << "\n"
	<< "val2: " << val2 << "\n";
istringstream input_string(format_message.str());
string dump;
input_string >> dump >> val1 >> dump >> val2;
cout << val1 << " " << val2 << endl;

class Sales_item{
	friend std::istream& operator>>
		(std::istream&, Sales_item&);
	friend std::ostream& operator<<
		(std::ostream&, const Sales_item&);
public:
	Sales_item& operator+=(const Sales_item&);
}
// 可以通过 Sales_item类的成员函数 operator+= 实现加法, 所以不将 operator+ 函数设置为友元
Sales_item operator+(const Sales_item&, const Sales_item);

// 假设 item1 和 item2 是 Sales_item对象, 则下面两个表达式等价
cout << item1 + item2 << endl;
cout << operator+(item1 + item2) <<endl;
// 下面也等价
item1 += item2;
item1.operator+=(item2);

ostream&
operator<<(ostream& os, const ClassType &object)
{
	// ... 其他操作
	// 输出
	os << // ...
	return os;
}

const Sales_item& s;
// ...
s.avg_price();		// avg_price() 是 Sales_item类的const成员函数.

int& Foo::operator[] (const size_t index)
{
	return data[index];
}
const int& Foo::operator[] (const size_t index) const
{
	return data[index];
}

bool GT6(const string& s)
{
	return s.size() > 6;
}
vector<string>::size_type wc = count_if(words.begin(), words.end(), GT6);
// 上面算法的缺点就是如果要计算大于7, 8或者其他数字的单词数目, 就要重新定义函数. 使用函数对象就没有这么麻烦, 例如
class GT_cls
{
public:
	GT_cls(size_t val = 0) : bound(val) {}
	bool operator()(const string& s)
	{
		return s.size() > bound;
	}
private:
	std::string::size_type bound;
};
vector<string>::size_type wc = count_if(words.begin(), words.end(), GT_cls(6));

plus<int> intAdd;
negate<int> intNegate;
int sum = intAdd(10, 30);
sum = intAdd(19, intNegate(10));

// 所小于等于10的元素个数
count_if(vec.begin(), vec.end(), bind2nd(less_equal<int>(), 10));
not1(count_if(vec.begin(), vec.end(), bind2nd(less_equal<int>(), 10)));

class SmallInt {
public:
	SmallInt(int i = 0) : val(i)
	{
		if(i < 0 || i > 255)
		{
			throw std::out_of_range("Bad Smallint initializer");
		}
	}
	operator int() const { return val; }
private:
	std::size_t val;
};

class SmallInt{
	SmallInt(int = 0);
	operator int() const;
	friend SmallInt operator+(const SmallInt&, const SmallInt&); 
};

SmallInt s1, s2;
SmallInt s3 = s1 + s2;
int i = s3 + 0;		// 这一句产生了二义性. 是用 SmallInt operator+() 版本, 还是用 int内置的 operator+().

string null_book = "9-999-99999-9";	// 复制初始化, 首先调用接受C风格字符串的string构造函数创建临时对象, 而后用该对象调用复制构造函数
    string dots(10, '.');				// 直接初始化
    string empty_copy = string();		// 复制初始化, 默认构造函数创建了临时对象, 而后调用复制构造函数
    string empty_direct;				// 直接初始化, 默认构造函数

vector<string> svec(5);	// 首先使用默认构造函数创建临时对象, 而后用该临时对象调用复制构造函数复制到svec的每个元素中.

Sales_item primer_eds[] = { string("0-201-16487-6"),
    string("0-201-54848-8"),
    string("0-201-82470-1"),
    Sales_item
    };

class Sales_item {
    // 其他数据成员和构造函数
    private:
    std::string isbn;
    int units_sold;
    double revenue;
    };
    // 则编译器合成的复制构造函数如下
    Sales_item::Sales_item(const Sales_item &orig) :
    isbn(orig.isbn),
    units_sold(orig.units_sold),
    revenue(orig.revenue) {}

class Sales_item{
    public:
    // 其他成员
    // 等同合成赋值操作符
    Sales_item& operator=(const Sales_item &);
    };

Sales_item& Sales_item::operator=(const Sales_item &rhs)
    {
    isbn = rhs.isbn;
    units_sold = rhs.units_sold;
    revenus = rhs.revenus;
    return *this;
    }

{
    Sales_item *p = new Sales_item[10];
    vector<Sales_item> vec(p, p+10);
    // ...
    delete [] p;	// 删除数组元素
    }	// vector 容量到了作用域范围之外, 开始撤销其内的元素.