首页 > 代码库 > templates(2.1)

templates(2.1)

2024-07-03 20:54:19   224人阅读

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; // 错误：此处不允许使用 >>

 

在以下述句之后：

 

 


联系
我们