1 C++标准
C++的标准化是一个漫长的过程。为何要标准化？作为一个语言，如果不设立相应的标准规格那是万万不能的。世界上有很多C++程序员，他们都有各自的编程风格，如果不做统一的话，那么这门语言将会演变出相当多个版本，这也会让C++进入分崩离析的状态，其中的一个严重后果就是兼容性问题，因而，标准化是必不可少的，标准规格的建立，是C++的一个重要里程碑。
标准程序库是C++标准规格的一部分，提供一系列核心组件，用以支持I/O、字符串（string）、容器（数据结构）、算法（排序、搜索、合并等等）、数值计算、国别（例如不同字符集，character set）等主题。
2 C++语言特性
C++语言核心和C++程序库是同时被标准化的。C++每5年会有一个新版本。如果你没有紧跟其发展，可能会对某些新的语言特性大感惊讶。接下来的几个小节，将描述与C++标准程序库有关的几个最重要的语言特性。
2.1 template（模板）
程序库中几乎所有东西都被设计为template形式。不支持template，就不能使用标准程序库。
所谓template，是针对“一个或多个尚未明确的类型”所撰写的函数或类别。使用templete时，可以显式地或隐式地将类型当做参数来传递。下面的一个典型例子，传回两数中的较大数：
template <class T> const T& max( const T& a, const T& b) { return a < b ? b : a; }
在这里，第一行将T定义为任意数据类型，在函数被调用时由调用者指定。任何合法标示符都可以拿来做参数名，但通常以T表示，这差不多成了一个“准”标准。这个类别用关键字class引导，但类型本身不一定得是class-------任何数据类型只要提供template定义式内所用到的操作，都可适用于此template。
遵循同样原则，你可以将class参数化，并以任意类型作为实际参数。这一点对容器类别非常有用。你可以实现出“有能力操控任意类型元素”的容器。C++标准程序库提供了许多模板容器类。
欲实现C++标准程序库的完整功能，编译器不仅要提供一般的template支持，还需要很多新的template标准特性，以下分别探讨。
2.1.1 Nontype Templates参数（非类型模板参数）
类型（type）可以作为模板（template）参数，非类型（nontype）也可以作为模板（template）参数。因而后者可被看为前者的一部分。例如，可以把标准类型bitset<>的bits数量以template参数指定。以下定义了两个由bits构成的容器，分别为32个bits空间和50个bits空间：
bitset<32> flags32; //32个bits空间的bitset bitset<50> flags50; //50个bits空间的bitset
这些bitsets由于使用不同的template参数，所以有不同的类型，不能互相复制（assign）或比较（除非提供了相应的类型转换机制）。
2.1.2 Default Template Parameters（缺省模板参数）
template classes可以缺省参数。例如一下声明，允许你使用一个或两个template参数来声明MyClass对象：
template <class T, class container = vector<T> > //注意两个>之间必须有一个空格，如果没写空格“>>”会被解读为移位运算子，导致语法错误。 class MyClass;
如果只传给它一个参数，那么缺省参数可作为第二个参数使用：
//以下两条语句等价 MyClass<int> x1; MyClass<int, vector<int> > x1;
注意：template缺省参数可根据前一个（或前一些）参数定义。
2.1.3 关键字typename
关键字typename被用来作为类型之前的标识符号。考虑下面例子：
template <class T> class MyClass { typename T::SubType* ptr; //To do something... };
这里，typename指出SubType是class T中定义的一个类型，因此ptr是一个指向T::SubType类型的指针。如果没有关键字typename，Subtype会被当成一个static成员，于是：
T::Subtype * ptr 会被解释为类型T内的数值Subtype与ptr的乘积。
Subtype成为一个类型的条件是，任何一个用来取代T的类型，其内都必须提供一个内部类型（inner type）Subtype的定义。例如，将类型Q当做template参数：
MyClass<Q> x;
必要条件是类型Q有如下的内部类型定义：
class Q { typedef int SubType; //To do something... };
注意，如果要把一个template中的某个标识符号指定为一种型别，就算意图显而易见，关键字typename也不可或缺，因此C++的一般规则是，除了以typename修饰之外，template内的任何标识符号都被视为一个值（value）而非一个类型。
typename还可以在template声明中用来替换关键字class:
template <typename T> class MyClass;
2.1.4 Member Template（成员模板）
类成员函数可以是个template（模板），但是这样的成员模板既不能是virtual，也不能缺省参数。例如：
class MyClass { //To do something... template<class T> void f(T); //To do something... };
在这里，MyClass::f() 声明了一个成员函数集，适用任何类型参数。只要某个类型提供有f()用到的所有操作，它就可以被当做参数传递进去。这个特性通常用来为模板类中的成员提供自动类型转换。例如以下定义式中，assign()的参数x，其类型必须和调用端所提供的对象的类型完全吻合。
template <class T> class MyClass { private: T value; public: void assign(const MyClass<T>& x) { //x必须和*this有同样的T value = x.value; } //To do something... };
即使两个类型之间可以自动转换，如果我们对assign()使用不同的template类型，也会出错：
void f() { MyClass<double> d; MyClass<int> i; d.assign(d); //OK a.assign(i); //错误，i是MyClass<int>，但这里需要MyClass<double> }
如果C++允许我们为成员函数提供不同的template类型，就可以放宽“必须精确吻合”这条规则：只要类型可被赋值，就可以被当做上述成员模板函数的参数。
template <class T> class MyClass { private: T value; public: template <class X> //成员模板 void assign(const MyClass<X>& x) { //允许不同的模板类型 value.x.getValue(); } T getValue() const { return value; } //To do something... }; void f() { MyClass<double> d; MyClass<int> i; d.assign(d); //OK a.assign(i); //OK，int对于double是可赋值的。 }
请注意，现在，assign()的参数x和*this的类型并不相同，所以你不能够直接存取MyClass<>的private成员和protected成员，取而代之的是，此例中你必须使用类似getValue()之类的东西。
模板构造函数（templeta constructor）是成员模板的一种特殊形式，它通常用于“在复制对象时实现隐式类型转换”。注意，模板构造函数并不遮蔽隐式的复制构造函数。如果类型完全吻合，隐式复制构造函数就会被产生出来并被调用。举个例子：
template <class T> class MyClass { public: //带隐式类型转换的复制构造函数并不遮蔽隐式的复制构造函数 template <class U> MyClass(const &MyClass<U>& x); }; void f() { MyClass<double> xd; MyClass<double> xd2(xd); //调用内建复制构造函数（隐式） MyClass<int> xi(xd); //调用模板构造函数 //To do something... }
在这里，xd2和xd的类型完全一致，所以它被内建的复制构造函数初始化，xi和xd的类型不同，所以它使用模板构造韩式进行初始化。因此，撰写模板复制构造函数时，如果default辅助构造函数不符合你的要求，别忘了自己提供一个复制构造函数。
2.1.5 嵌套模板类
嵌套类本身也可以是个template:
template <class T> class MyClass { //To do something... template <class T2> //嵌套类 class NestedClass; //... };
2.2 基本类型的显式初始化
如果采用不含参数的、明确的构造函数调用语法，基本类型会被初始化为零：
int i1; //未定义的值 int i2 = int(); //初始化为0
这个特性可以确保我们在撰写template程序代码时，任何型别都有一个确切的初值。例如下面的这个函数中，x保证被初始化为零。
template <class T> void f() { T x = T(); //... }
2.3 异常处理
通过异常处理，C++标准程序库可以在不污染函数接口（亦即参数和返回值）的情况下处理异常。要注意的是这种概念叫做“异常处理”，而不是“错误处理”，两者未必相同。举个例子，许多时候用户的无效输入并非一种异常；这时候最好是在区域范围内采用一般的错误处理技术来处理。
C++标准库提供了一些通用的异常处理特性，例如标准异常类别（standard exception classes）和auto_ptr类别。
2.4 Namespaces（命名空间）
越来越多的软件由程序库、模块和组件拼凑而成。各种不同事物的结合，可能导致一场名称大冲突。Namespaces正是用来解决此问题的。
namespaces将不同的标识符号集合在一个具名作用域（names scope）内。如果你在namespace之内定义所有标识符号，则namespace本身就成了唯一可能与其他全局符号冲突的标识符号。你必须在标识符号前加上namespace名字，才能援引namespace内的符号，这和class处理方式雷同。namespace的名字和标识符号之间以::分割开来（这个符号及其意义和class与其成员之间的联系有点类似）。
//在命名空间josuttis中定义标识符号 namespace josuttis { class File; void myGlobalFunc(); //... } //使用命名空间中的标识符 josuttis::File obj; josuttis::myGlobalFunc();
不同于class的是，namespace是开放的，你可以在不同模块中定义和扩展namespace。因此你可以使用namespace来定义模块、程序库或组件，甚至在多个文件之间完成。namespace定义的是逻辑模块，而非实质模块。请注意，在UML及其他建模表示法中，模块又被成为package。
如果某个函数的一个或多个参数类型，定义于函数所处的namespace中，那么你可以不必为该函数指定namespace。这个规则成为Koenig lookup。例如：
//在命名空间josuttis中定义标识符号 namespace josuttis { class File; void myGlobalFunc(File& ); //... } //使用命名空间中的标识符 josuttis::File obj; myGlobalFunc(obj);
通过using声明（using declaration），我们可以避免一再写出冗长的namespace名称，例如一下声明：
using josuttis::File; //using declaration
会使File成为当前作用域内代表josuttis::File的一个同义字。
Using directive会使namespace内的所有名字曝光，它等于将这些名字声明于namespace之外。但这么一来，名称冲突问题可能死灰复燃。例如：
using namespace josuttis; //using directive
会使File和myGlobalFunc()在当前作用域内完全曝光。如果全局范围内已存在同名的File和myGlobalFunc()，而且使用者不加任何资格饰词地使用这两个名字，编译器将东西难辨。
注意，如果场合（contex）不甚清楚（例如不清楚是在头文件、模块里还是在程序库里），你不应该使用using directive。这个指令可能会改变namespace的作用域，从而使程序代码被包含或使用于另一模块中，导致意外的行为发生。事实上在头文件中使用using directive相当不明智。
C++标准程序库在namespace std中定义了它的所有标识符号。
2.5 Bool类型
为了支持布尔值（真假），C++增加了bool类型。Bool可增加程序可读性，并允许你对bool值实现重载动作。两个常数true和false同时亦被引入C++。此外C++还提供bool值与整数值之间的自动转换。0值相当于false，非0值相当于true。
2.6 关键字explicit
通过关键字explicit的作用，我们可以禁止“单参数构造函数”被用于自动类型转换。典型的例子便是群集类型。你可以将初始长度作为参数传给构造函数，例如你可以声明一个构造函数，以stack的初始大小为参数：
class Stack { explicit Stack(int size); //用初始大小size构造Stack //... };
在这里，explicit的应用非常重要。如果没有explicit，这个构造函数有能力将一个Int自动转型为Stack。一旦发生这种情况，你甚至可以给Stack指派一个整数值而不会引起任何问题：
Stack s; s = 40; //糟糕，创建了一个有40个元素的Stack，并把它赋值给了s
自动类型转换动作会把40转换为有40个元素的Stack，并指派给s，这几乎肯定不是我们所要的结果。如果我们将构造函数声明为explicit，上述赋值操作就会导致编译错误（那很好）。
注意，explicit同样也能阻绝“以赋值语法进行带有转型操作的初始化”：
Stack s1(40); //OK Stack s2 = 40; //Error
这是因为一下两组操作：
X x; Y y(x); //显式转换
和
X x; Y y = x; //隐式转换
存在一个小差异。前者透过显式转换，根据类型X产生了一个类型Y的新对象；后者通过隐式转换，产生了一类型Y的新对象。
2.7 新的类型转换操作符
为了让你对“参数的显式类型转换”了解更加透彻，C++引入一下4个新的操作符：
2.7.1 static_cast
将一个值以符合逻辑的形式转换。这可看做是“利用原值重建一个新对象，并在设立初值时使用类型转换”。唯有当上述的类型转换有所定义，真个转换才会成功。所谓“有所定义”，可以是语言内建规则，也可以是程序员自定的转换动作。例如：
float x; cout << static_cast<int>(x); //打印int型的x f(static_cast<string>("hello")); //调用f()，参数为string类型，而不是char*
2.7.2 dynamic_cast
将多态类型向下转型为其实际静态类型。这是唯一在执行期进行检验的转型动作。你可以用它来检验多个多态对象的类型，例如：
class Car; //抽象的基类，至少用于一个虚函数 class Cabriolet : public Car { //... }; class Limousine : public Car { //... }; void f(Car* cp) { Cabriolet* p = dynamic_cast<Cabriolet*>(cp); if(p == NULL) { //... } }
在这个例子中，面对实际静态类型为Cabriolet的对象，f()有特殊应对行为。当参数是个reference，而且类型转换失败时，dynamic_cast会丢出一个bad_cast异常。注意，从设计者角度而言，你应该在运用多态技术的程序中，避免这种“程序行为取决于具体类型”的写法。
2.7.3 const_cast
设定或去除类型的常数性，亦可去除volatile饰词。除此之外不允许任何转换。
2.7.4 reinterpret_cast
此操作符的行为由实际编译器定义。可能重新解释bits意义，但也不一定如此，使用此一转型动作通常带来不可移植性。
这些操作符取代了以往小圆括号所代表的旧式转型，能够清楚阐明转型的目的。小圆括号转型可替换dynamic_cast之外的其他三种转型，也因此当你运用它时，你无法明确显示使用它的确切理由。这些新式转型操作给了编译器更多信息，让编译器清楚知道转型的理由，并在转型失败时释出一份错误报告。
注意，这些操作符只接受一个参数。试看下面例子：
static_cast<Fraction>(15, 100) //糟糕，创建了Fraction(100)
在这个例子中你得不到你想要的结果。它只用一个数值100，将Fraction暂时对象设定初值，而非设定分子15、分母100。逗号在这里并不起分隔作用，而是形成一个comma操作符，将两个表达式组合为一个表达式，并传回第二个表达式作为最终结果。将15和100“转换”为分数的正确做法是：
Fraction(15, 100);
2.8 常数静态成员的初始化
如今，我们终于能够在class声明中对“整数型常数静态成员”直接赋予初值。初始化后，这个常数便可用于class之中，例如：
class MyClass { static const int num = 100; int elems[num]; };
注意，你还必须为class之中声明的常数静态成员，定义一个空间：
const int MyClass::num; //不用初始化
2.9 main()的定义式
在C++中有一个重要而又常被误解的问题，那就是正确而可移植的main()的唯一写法。根据C++标准，只有两种main()是可移植的：
int main() { //... }
和
int main(int argc, char* argv[]) { //... }
这里argv（命令行参数数组）也可以定义为char**。请注意，由于不允许“不言而喻”的返回类型int，所以返回类型必须明白写为int。你可以使用return语句来结束main()，但不必一定如此。这一点和C不同，换句话说，C++在main()的末尾定义了一个隐式地：
return 0;