Effective C++ 07 模板与泛型编程

面向对象编程总是以显式接口和运行期多态解决问题。template 及泛型编程，与面向对象有本质上的不同。在此世界中显式接口和运行期多态仍然存在，但重要性降低。反倒是隐式接口和编译期多态移到前面了。参考下面例子：

templat
void doProcessing(T& w) {
	if (w.size() > 10 && w != someNastyWidget) {
		T temp(w);
		temp.normalize();
		temp.swap(s);
	}
}

• w 必须支持哪一种接口，是由 template 中执行于 w 身上的操作来决定。就本例来看 w 的类型 T 好像必须支持 size、normalize 和 swap 成员函数、copy 构造函数、不等式比较，这一组表达式便是 T 必须支持的一组隐式接口。
• 凡涉及 w 的任何函数调用，例如 operator> 和 operator!=，有可能造成 template 具现化，使这些调用得以成功。这样的具现行为发生在编译期。以不同的 template 参数具现化 function template 会导致调用不同的函数，这边是所谓编译器多态。

通常显式接口由函数的签名式（也就是函数名称、参数类型、返回类型）构成。例如：

class Widget {
public:
	Widget();
	virtual ~Widget();
	virtual std::size_t size() const;
	virtual void normalize();
	void swap(Widget& other);
};

其 public 接口由一个构造函数、一个析构函数、函数 size、normalize、swap 及其参数类型、返回类型、常量性构成。当然也包括编译器产生的 copy 构造函数和 copy assignment 操作符。另外也可以包括 typedef，以及 public 变量成员。

隐式接口就完全不同了。它并不基于函数签名式，而是由有效表达式组成。加诸于 template 参数身上的隐式接口，就像加诸于 class 对象身上的显式接口一样真实，而且二者都是在编译期完成检查。就像你无法以一种“与 class 提供的显式接口矛盾”的方式来使用对象（代码将无法通过编译），你也无法在 template 中使用“不支持 template 所要求的隐式接口”的对象（代码一样无法通过编译）。

请记住:

• class 和 template 都支持接口和多态。
• 对 class 而言接口时显式，以函数签名为中心。多态则是用过 virtual 函数发生于运行期。
• 对 template 参数而言，接口是隐式，奠基于有效表达式。多态则是通过 template 具现化和函数重载解析发生于编译期。

当我们声明 template 类型参数时，class 和 typename 的意义完全相同，即下面二者完全相同：

template class Widget;
template class Widget;

然而 C++ 并不总是把 class 和 typename 是为等价。有时候你一定得使用 typename。

template 内出现的名称如果相依于某个 template 参数，称其为从属名称。如果从属名称在 class 内成嵌套状，我们称它为嵌套从属名称。类似 T::const_iterator，实际上它还是个嵌套从属类型名称，也就是个嵌套从属名称并且指涉某类型。

嵌套从属名称可能会导致解析困难，举个例子：

template
void print2nd(const C& container) {
	C::const_iterator* x;
	...
}

看起来好像我们声明 x 为一个 local 变量，它是个指针，指向一个 C::const_iterator。但是如果 C::const_iterator 不是个类型呢？如果 C 有个 static 变量名称恰好被命名为 const_iterator，或如果 x 碰巧是一个 global 变量名称，那样的话上述代码就不是声明一个 local 变量，而是也给相乘动作： C::const_iterator 乘以 x。

C++ 有个规则可以解析此歧义状态：如果解析器在 template 中遭遇一个嵌套从属名称，它便假设者名称不是个类型，除非你告诉它是。所以缺省情况下嵌套从属名称不是类型。如果要告诉 C++ 说 C::const_iterator 是一个类型，只需要在它之前添加关键字 typename 即可：

template
void print2nd(const C& container) {
	typename C::const_iterator* x;
	...
}

一般性规则是：任何时候当你想要在 template 中指涉一个嵌套从属类型名称，就必须在紧临它的前一个位置放上关键字 typename，但是有一个例外：typename 不可以出现在 base class list 内的嵌套从属类型名称之前，也不可在 member initialization list（成员初始值列表）中作为 base class 修饰符。例如：

template
class Derived : public Base::Nested {  // base class list 中不允许 typename
public:
	explicit Derived(int x) 
		: Base::Nested(x) {  // 成员初始值列表中不允许 typename
			typename Base::Nested temp;  // 作为一个 base class 修饰符需加上 typename
		}
};
// typedef typename 是指涉嵌套从属类型名称的一个合理附带结果
template
void workWithIterator(IterT iter) {
	typedef typename std::iterator_traits::value_type vlue_type;
	value_type temp(*iter);
}

请记住:

• 声明 template 参数时，前缀关键字 class 和 template 可互换。
• 请使用关键字 typename 标识嵌套丛书类型；但不得在 base class list（基类列表）或 member initialization list（成员初始化列表）内以它作为 base class 修饰符。

假设我们需要撰写一个程序，它能够传送信息到若干不同的公司去。信息要不译成密码，要不就是未经加工的文字。如果编译期间我们有足够信息来决定哪一个信息传至哪一家公司，就可以采用基于 template 的解法：

class CompanyA {
public:
    void sendCleartext(const std::string& msg);
    void sendEncrypted(const std::string& msg);
};
class CompanyB {
public:
    void sendCleartext(const std::string& msg);
    void sendEncrypted(const std::string& msg);
};
class MsgInfo { ... };  // 这个 class 用来保存信息，以备将来产生信息
template
class MsgSender {
public:
    ...  // 构造函数、析构函数等等
    void sendClear(const MsgInfo& info) {
        std::string msg;
        ... // 根据 info 产生信息
        Company c;
        c.sendCleartext(msg);
    }
    // 类似 sendClear，唯一不同是,这里调用 c.sendEncrypted
    void sendSecret(const MsgInfo& info) { ... }  
};

此时，假设我们有时候想要在每次送出信息时 log 某些信息。derived class 可轻易加上这样的生产力，那似乎是个合情合理的解法：

template
class LoggingMsgSender : public MsgSender {
public:
    void sendClearMsg(const MsgInfo& info) {
        // 将“传送前”的信息写至 log
        sendClear(info);  // 调用 base class 函数：这段代码无法通过编译
        // 将“传送后”的信息写至 log
    }
};

上述代码无法通过的原因在于，当编译器遭遇 class template LoggingMsgSender 定义式时，并不知道它继承什么样的 class。当然它继承的是 MsgSender，但其中的 Company 是个 template 参数，无法确切知道它是什么（直到 LoggingMsgSender 被具现化）。而如果不知道 Company 是什么，就无法知道 class MsgSender 是否有 sendClear 函数（因为 base class template 模板有可能被特例化）。

我们有三种方法解决上述问题。

第一是在 base class 函数调用动作之前加上 “this->”：

template
class LoggingMsgSender : public MsgSender {
public:
    void sendClearMsg(const MsgInfo& info) {
        // 将“传送前”的信息写至 log
        this->sendClear(info);  // 成立，假设 sendClear 将被继承。
        // 将“传送后”的信息写至 log
    }
};

第二是使用 using 声明式：

template
class LoggingMsgSender : public MsgSender {
public:
    using MsgSender::sendClear;  // 告诉编译器，请它假设 sendClear 位于 base class 内
    void sendClearMsg(const MsgInfo& info) {
        sendClear(info);  // 成立，假设 sendClear 将被继承
    }
};

这里的情况并不是 base class 名称被 derived class 名称覆盖，而是编译器不进入 base class 作用域内查找，于是我们通过 using 声明告诉它，请它这么做。

第三个做法是，明确指出被调用的函数位于 base class 内：

template
class LoggingMsgSender : public MsgSender {
public:
    void sendClearMsg(const MsgInfo& info) {
        MsgSender::sendClear(info);  // 成立，假设 sendClear 将被继承。
    }
};

这往往是最不让人满意的一个解法，因为如果被调用的是 virtual 函数，上述的明确资格修饰会关闭 virtual 绑定行为。

从名称可视点的角度出发，上述每一个做法都做的事情都相同：对编译器承诺 base class template 的任何特化版本都将支持一般（泛化）版本所提供的接口。

请记住:

• 可在 derived class templates 内通过 “this->” 指涉 base class templates 内的成员名称，或籍由一个明确写出的 “base class 资格修饰符” 完成。

template 是节省时间和避免代码重复的一个奇方妙法。不再需要键入多个类似的 classe，你只需键入一个 class template，留给编译器去具现化剩余你需要的相关 classe 和函数。class template 的成员函数只有在被使用时才被暗中具现化，只有在每一个函数都被使用时，你才会获得所有的函数。

有时候，使用 template 可能会导致代码膨胀：其二进制码带着重复（或几乎重复）的代码、数据。通过共性与变形分析，可以尽可能减轻。例如，你会抽出两个函数的共同部分，把它们放进第三个函数中，然后令原先两个函数调用这个新函数。编写 template 时，也是做相同的分析，以相同的方式避免重复，但其中有个窍门。在 non-template代码中，重复十分明确：你可以“看”到两个函数或两个 classe 之间有所重复。然而在 template 代码中，重复是隐晦的。参考下面例子：

template
class SquareMatrix {
public:
    ...
    void invert();  // 求逆矩阵
};

现在考虑下面操作：

SquareMatrix sml;
sm1.invert();  // 调用 SquareMatrix::invert
SquareMatrix sm2;
sm2.invert();  // 调用 SquareMatrix::invert

这次具现化两份 invert。这些函数并非完完全全相同，但除了常量 5 和 10，两个函数的其他部分完全相同。这是 template 引出代码膨胀的一个典型例子。

我们可以令 SquareMatrixBase 贮存一个指针，指向矩阵数值所在的内存。而只要它存储了那些东西，也就可能存储矩阵尺寸。成果看起来像这样：

template
class SquareMatrixBase {
protected:
    SquareMatrixBase(std::size_t n, T* pMem)  // 存储矩阵大小和一个指针，指向矩阵数值
    : size(n), pData(pMem) { }
    void setDataPtr(T* ptr) { pData = ptr; }  // 重新赋值给 pData
private:
    std::size_t size;  // 矩阵大小
    T* pData;  // 指针，指向矩阵内容
};

这允许 derived classe 决定内存分配方式。某些实现版本也许会决定将矩阵数据存储在 SquareMatrix 对象内部：

template
class SquareMatrix: private SquareMatrixBase {
public:
    SquareMatrix()  // 送出矩阵大小和数据指针给 base class
    : SquareMatrixBase(n, data) { }
private:
    T data[n * n];
};

不论数据存储于何处，从膨胀角度讨论，SquareMatrix 成员函数可以单纯地以 inline 方式调用 base class 版本，后者持有同型元素（不论矩阵大小）的所有矩阵共享。SquareMatrix 和 SquareMatrix 对象使用相同的 SquareMatrixBase 成员函数。

从另一个角度看，不同大小的矩阵中只拥有单一版本 invert，可减少执行文件大小，也就因此降低程序的 working set 大小，并强化指令高速缓冲区内的引用集中化。这些都可能是程序执行的更快速。
注: working set 是指对一个在虚内存环境下执行的进程而言，其所使用的那一组内存页。

这个条款只讨论由 non-type template parameters（非类型模板参数）带来的膨胀，其实 type parameters（类型参数）也会导致膨胀。例如在许多平台上 int 和 long 有相同的二进制表述，所以像 vector 和 vector 的成员函数有可能完全相同 —— 这正是膨胀的最佳定义。某些连接器会合并完全相同的函数实现码，有些不会，后者意味着某位 template 被具现化为 int 和 long 两个版本，并因此造成代码膨胀。

请记住:

• templates 生成多个 class 和多个函数，所以任何 template 代码都不该与某个造成膨胀的 template 参数产生相依关系。
• 因非类型模板参数而造成的代码膨胀，往往可以消除，做法是以函数参数或 class 成员变量替换 template 参数。
• 因类型参数而造成的代码膨胀，往往可降低，做法是让带有完全相同的二进制表述的具现类型共享实现码。

真实指针做得很好的一件事是，支持隐式转换。derived class 指针可以隐式转换为 base class 指针，“指向 non-const 对象”的指针可以转换为“指向 const 对象” 等等。下面是可能发生于三层继承体系的一些转换：

class Top { ... };
class Middle: public Top { ... };
class Bottom: public Middle { ... };
Top* pt1 = new Middle;  // 将 Middle* 转换为 Top*
Top* pt2 = new Bottom;  // 将 Bottom* 转换为 Top*
const Top* pct2 = pt1;  // 将 Top* 转换为 const Top*

但如果想在用户自定的智能指针中模拟上述转换，稍稍有点麻烦。我们希望以下代码通过编译：

template
class SmartPtr {
    public:  // 智能指针通常以内置指针完成初始化
    explicit SmartPtr(T* realPtr);
};
SmartPtr pt1 = SmartPtr(new Middle);
SmartPtr pt2 = SmartPtr(new Bottom);
SmartPtr pct2 = pt1;

但是，同一个 template 的不同具现体之间并不存在什么与生俱来的固有关系，所以编译器视 SmartPtr 和 SmartPtr 为完全不同的 class。

就原理而言，此例中我们需要的构造函数数量没有止尽，因为一个 template 可被无限量具现化，已致生成无限量函数。因此，似乎我们需要的不是为 SmartPtr 写一个构造函数，而是为它写一个构造模板。这样的模板是所谓 member function templates，其作用是为 class 生成函数：

template
class SmartPtr {
public:
    template  // member template
    SmartPtr(const SmartPtr& other);  // 未来生成 copy 构造函数
};

template
class SmartPtr {
public:
    template
    SmartPtr(const SmartPtr& other)  // 以 other 的 heldPtr 初始化 this 的 heldPtr
    : heldPtr(other.get()) { ... }
    T* get() const { return heldPtr; }
private:
    T* heldPtr;  // 这个 SmartPtr 持有内置指针
};

template
class shared_ptr {
public:
    shared_ptr(shared_ptr const& r);  // copy 构造函数
    template 
    shared_ptr(shared_ptr const& r);  // 泛化 copy 构造函数
                
    shared_ptr& operator=(shared_ptr const& r);  // copy assignment
    template 
    shared_ptr& operator=(shared_ptr const& );  // 泛化 copy assignment
};

template
    class Rational {
    public:
        Rational(const T& numberator = 0, 
	        const T& denominator = 1);
        const T numerator() const;
        const T denominator() const;
};
template
const Rational operator*(const Rational& lhs, const Rational& rhs) { ... }

Rational oneHalf(1, 2);
Rational result = oneHalf * 2;  // 错误！无法通过编译

template
    class Rational {
    public:
	    // 声明
        friend
        const Rational operator*(const Rational& lhs, const Rational& rhs); 
};
// 定义
template
const Rational operator*(const Rational& lhs, const Rational& rhs) { ... }

template
    class Rational {
    public:
        friend
        const Rational operator*(const Rational& lhs, const Rational& rhs) {
            return Rational(lhs.numberator() * rhis.numberator(), lhs.denominator() * rhs.denominator());
        }
};

template
void advance(Iter& iter, DistT d);

template
void advance(Iter& iter, DistT d) {
	if (iter is a random access iteraotr) {
		iter += d;  // 针对 random access 迭代器使用迭代器算术运算
	}
	else {
		if (d >= 0) {
			while (d--) ++iter;
		}
		else {
			while (d++) --iter;
		}
	}
}

template
struct iterator_traits;

template <...>  // 省略
class deque {
public:
	class iterator {
	public:
		typedef random_access_iterator_tag iterator_category;
	};
};

template
struct iterator_traits {
	typedef typename IterT::iterator_category iterator_category;
};

template
struct iterator_traits {
	typedef random_access_iterator_tag iterator_category;
};

template
void advance(Iter& iter, DistT d) {
	if (typeid(typename std::iteraot_traits::iterator_category) == typeid(std::random_access_iterator_tag))
	...
}

template
void doAdvance(Iter& iter, DistT d，  // 这份实现用于 random access 迭代器
	std::random_access_iterator_tag) {
		iter += d;
	}

template
void doAdvance(Iter& iter, DistT d，  // 这份实现用于 bidirectional 迭代器
	std::bidirectional_iterator_tag) {
		if (d >= 0) {
			while (d--) ++iter;
		}
		else {
			while (d++) --iter;
		}
	}
...

template
void advance(Iter& iter, DistT d) {
	doAdvance(iter, d, 
		typename std::iterator_traits::iterator_category()
	);
}

template
void advance(Iter& iter, DistT d) {
	if (typeid(typename std::iteraot_traits::iterator_category) == typeid(std::random_access_iterator_tag)) {
		iter += d;  // 针对 random access 迭代器使用迭代器算术运算
	}
	else {
		if (d >= 0) {
			while (d--) ++iter;
		}
		else {
			while (d++) --iter;
		}
	}
}

std::list::iterator iter;
...
advance(iter, 10);  // 移动 iter 向前走 10 个元素；上述实现无法通过编译

template
struct Factorial {  // 一般情况
	enum { value = n * Factorial::value };
};

template<>
struct Factorial<0> {  // 特殊情况
	enum { value = 1 };
};