Class Templates
类别模板
就像上一章所说的 functions 那样，classes 也可以针对一或多个类型被参数化。用来管理「各种 不同类型的元素」的 container classes（容器类别）就是典型例子。运用 class templates 你可以实 作出可包容各种类型的 container class。本章将以一个 stack class 作为 class templates
/* The following code example is taken from the book * "C++ Templates - The Complete Guide" * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002 * * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002. * Permission to copy, use, modify, sell and distribute this software * is granted provided this copyright notice appears in all copies. * This software is provided "as is" without express or implied * warranty, and with no claim as to its suitability for any purpose. */ #include <vector> #include <stdexcept> template <typename T> class Stack { private: std::vector<T> elems; // elements public: void push(T const&); // push element void pop(); // pop element T top() const; // return top element bool empty() const { // return whether the stack is empty return elems.empty(); } }; template <typename T> void Stack<T>::push (T const& elem) { elems.push_back(elem); // append copy of passed elem } template<typename T> void Stack<T>::pop () { if (elems.empty()) { throw std::out_of_range("Stack<>::pop(): empty stack"); } elems.pop_back(); // remove last element } template <typename T> T Stack<T>::top () const { if (elems.empty()) { throw std::out_of_range("Stack<>::top(): empty stack"); } return elems.back(); // return copy of last element }
正如你所见，这个 class template 是以标准库的 class template vector<> 为基础实作出来的， 这样我们就可以不考虑内存管理、copy构造函数、assignment 运算符等等，从而得以把注意力放在这个 class template 的界面上。
3.1.1 Class Templates 的声明
声明class templates 的动作和声明function templates 类似：在声明语句之前加一条述句，以任意标识符声明类型参数（type parameters）。我们还是以T 作为标识符：
template <typename T> class Stack { ... };
相同的规则再次适用：关键词 class 可以代替关键词 typename：
template <class T> class Stack { ... };
在 class template 内部，T 就像其它任意类型一样，可用来声明成员变量（member variables）和成员函数（member functions）。本例之中T 用来声明vector<> 所容纳的元素类型、声明一个「接受 T const&」的 push()函数、以及声明一个「返回类型为 T」的 top()函数：
template <typename T> class Stack { private:
std::vector<T> elems; // 元素 public: Stack(); // 构造函数 void push(T const&); // push 元素 void pop(); // pop 元素 T top() const; // 传回最顶端的元素 };
这个 class 的类型为 Stack<T>，T 是一个 template parameter。现在，无论何时你以这个class声明变量或函数时，都应该写成 Stack<T>。例如，假设你要声明自己的 copy 构造函数和assignment 运算符，可以写为：
template <typename T> class Stack { ... Stack (Stack<T> const&); // copy 构造函数 Stack<T>& operator= (Stack<T> const&); // assignment 运算符 ... };
然而如果只是需要class名称而不是class类型时，只需写Stack 即可。构造函数和析构函数的声明就属于这种情况。
3.1.2 成员函数（ Member Functions）
作为了定义 class template 的成员函数，你必须指出它是个 function template，而且你必须使用 class template 的全称。因此 Stack<T> 的成员函数 push()看起来便像这样：
template <typename T> void Stack<T>::push (T const& elem) { elems.push_back(elem); // 将传入的元素 elem 附加于尾 }
这里调用了vector 的成员函数push_back()，把元素elem 追加到elems 尾端。注意，对一个vector进行 pop_back()，只是把最后一个元素移除，并不传回该元素。这种行为乃是基于异常安全性（exception safety）考虑。实现一个「移除最后元素并传回，而且完全顾及异常安全性」的 pop() 是不可能的（ 这个问题最早由 Tom Cargill 在[CargillExceptionSafety]中 讨论过），[SutterExceptional] 条款 10 也有讨论）。然而，如果抛开可能的危险，我们可以实作出一个「移除最后元素并传回」的pop()，但必须声明一个类型为 T 的区域变量：
template <typename T> T Stack<T>::pop () { if (elems.empty()) { throw std::out_of_range("Stack<>::pop: empty stack"); } T elem = elems.back(); // 保存最后元素的拷贝 elems.pop_back(); // 移除最后一个元素 return elem; // 传回先前保存的最后元素 }
当vector为空时，对它进行back()或pop_back()操作会导致未定义行为。所以我们必须在操作前先检查stack是否为空。如果stack为空，就抛出一个std::out_of_range 异常。top()之中也需进行相同检查；该函数传回 stack 的最后一个元素，但不移除之：
template <typename T> T Stack<T>::top () const { if (elems.empty()) { throw std::out_of_range("Stack<>::top: empty stack"); } return elems.back(); // 传回最后元素的拷贝 }
当然，你也可以把任何 class templates 的成员函数实作码写在 class 声明语句中，形成一个 inline函式。例如：
template <typename T> class Stack { ... void push(T const& elem) { elems.push_back(elem); // 将传入的元素 elem 附加于尾 } ... };
3.2 使用 Class Template Stack
/* The following code example is taken from the book * "C++ Templates - The Complete Guide" * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002 * * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002. * Permission to copy, use, modify, sell and distribute this software * is granted provided this copyright notice appears in all copies. * This software is provided "as is" without express or implied * warranty, and with no claim as to its suitability for any purpose. */ #include <iostream> #include <string> #include <cstdlib> #include "stack1.hpp" int main() { try { Stack<int> intStack; // stack of ints Stack<std::string> stringStack; // stack of strings // manipulate int stack intStack.push(7); std::cout << intStack.top() << std::endl; // manipulate string stack stringStack.push("hello"); std::cout << stringStack.top() << std::endl; stringStack.pop(); stringStack.pop(); } catch (std::exception const& ex) { std::cerr << "Exception: " << ex.what() << std::endl; return EXIT_FAILURE; // exit program with ERROR status } }
上例声明了 Stack<int>这样一个类型，表示在该 class template 中 T 被替换为 int。于是 intStack成为这样一个object：内部使用「可容纳int 数据做为元素」的vector，并将被调用之任何成员函数都「以int 类型进行实例化」。同样道理，Stack<std::string> 表示：stringStack 被创建为这样一个object：内部使用「可容纳string 数据做为元素」的vector，并将被调用之任何成员函数都「以std::string 类型进行实例化」。
注意，惟有被调用到的成员函数，才会被实例化（instantiated）。对class templates 而言，只有当某个成员函数被使用时，才会进行实例化。无疑地这么做可以节省时间和空间。另一个好处是，你甚至可以实例化一个class template，而具现类型并不需要完整支持「class template 内与该 类型有关的所有操作」—前提是那些操作并未真正被叫用。举个例子，考虑某个class，其某些成员函数使用operator< 对内部元素排序；只要避免调用这些函数，就可以以一个「并不支持 operator<」的类型来实例化这个 class template。
本例中的 default 构造函数、push()函数和 top()函数都同时被 int 和 string 类型加以实现（实例化）。然而 pop()只被 string 实例化（译注：因为 pop()只被 stringStack 调用）。如果 class template 拥有 static 成员，这些 static 成员会针对每一种被使用的类型完成实例化。
你可以像面对任何基本类型一样地使用一个实例化后的class template类型，前提是你的使用方式合法：
void foo (Stack<int> const& s) // 参数 s 是一个 int stack { Stack<int> istack[10]; // istack 是一个「含有 10 个 int stacks」的 array ... }
运用 typedef，你可以更方便地使用 class templates：
typedef Stack<int> IntStack; void foo (IntStack const& s) // 参数 s 是一个 int stack { IntStack istack[10]; // istack 是一个「含有 10 个 int stacks」的 array ... }
注意，在C++中，typedef 并不产生新类型，只是为既有类型产生一个别名（type alias）。因此
typedef Stack<int> IntStack; IntStack 和 Stack<int>拥有（代表）相同类型，可以互换使用，可以相互赋值（assigned）。 Template arguments 可以是任意类型，例如可以是「指向 float」的指针，或甚至是个 int stack： Stack<float*> floatPtrStack; // stack of float pointers Stack<Stack<int> > intStackStack; // stack of stack of ints 惟一的条件是：该类型必须支持所有「实际被调用到的操作」。 注意，你必须在相邻两个右角括号之间插入一些空白符号（像上面那样），否则就等于使用了 operator>>，那会导致语法错误： Stack<Stack<int>> intStackStack; // 错误：此处不允许使用 >>