《C++标准程序库》学习笔记 -- 第二章

由于是开篇，本文所讲都很基础，但这些基础内容对后面的学习是非常重要的。

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;

这意味着如果你不采用return语句离开main()，实际上就表示成功退出（传回任何一个非0值都代表某种失败）。处于这个原因，本范例在main()尾端都没有return语句。有些编译器可能会对此发出警告，那正是标准制定前的黑暗日子。

3 总结

第一篇到此结束，关于复杂度的问题我在此省略，相信读者能理解。