【C++ 编程语言学习 4】C++模板

C++ 模板

两种C++程序设计泛型：

• 按照面向过程式范型把程序划分成不同的函数；
• 按照面向对象式范型把代码和数据组织成各种各样的类并建立类之间的继承关系。

模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。

基本的模板语法：

• 在泛型编程技术力，我们仍然需呀编写自己的函数和类，但不必限定它们所使用的数据类型；
• 只需要使用一个占位符（通常用字母T来表示），然后用这个占位符来编写函数；
• 当程序需要这段代码是，你提供数据类型，编译器将根据你的模板即时生产实用的代码；
• 简单的说，编译器把模板里的每一个T替换为所提供的数据类型。

模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。

每个容器都有一个单一的定义，比如 向量，我们可以定义许多不同类型的向量，比如 vector <int> 或 vector <string>。

可以使用模板来定义函数和类，接下来让我们一起来看看如何使用。

函数模板

模板函数定义的一般形式如下所示：

template <class type> 
ret-type func-name(parameter list)
{
   // 函数的主体
}

在这里，type 是函数所使用的数据类型的占位符名称。这个名称可以在函数定义中使用。

下面是函数模板的实例，返回两个数中的最大值：

#include<iostream>
#include<string>

template<class T>
void swap(T &a,T &b)
{
	T temp=a;
	a=b;
	b=temp;
}
int main()
{
	int i1=100;
	int i2=200;
	std::cout<<"交换前，i1="<<i1<<",i2="<<i2<<"\n";
	swap(i1,i2);
	std::cout<<"交换后，i1="<<i1<<",i1="<<i2<<"\n";
	std::string s1="小甲鱼";
	std::string s2="小金鱼";
	std::cout<<"交换前，s1="<<s1<<",s2="<<s2<<"\n";
	swap(s1,s2);//函数重载
	std::cout<<"交换后，s1="<<s1<<",s1="<<s2<<"\n";
	getchar();
	return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

 

注意

• 在创建模板时，还可以用template<typename T>来代替template<class T>，它们的含义是一样一样的；
• 注意template<class T>中的class并不意味这T只能是一个类；
• 不要把函数模板分成原型和实现两个部分，如果编译器看不到模板的完整代码，它就无法正确地生产代码。
• 为了明确地表明swap()是一个函数模板，还可以使用swap<int>(i1,i2)语法来调用这个函数，这将明确地告诉编译器它应该使用哪一种类型；
• 如果某个函数对所有数据类型都将进行同样的处理，就应该把它编写为一个模板；
• 如果某个函数对不同的数据类型进行不同的处理，就应该对它进行重载；

类模板

正如我们定义函数模板一样，我们也可以定义类模板。泛型类声明的一般形式如下所示：

template <class type>
class class-name 
{
.
.
.
}

在这里，type 是占位符类型名称，可以在类被实例化的时候进行指定。您可以使用一个逗号分隔的列表来定义多个泛型数据类型。

下面的实例定义了类 Stack<>，并实现了泛型方法来对元素进行入栈出栈操作：

栈的概念

• 栈是实际编程过程中一种非常有用的数据结构，它是一种数据存储机制；
• 栈只提供两个函数：一个用来把数据压入栈的顶部，另一个用来从栈取出顶部元素（先进后出）

#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>
 
using namespace std;
 
template <class T>
class Stack { 
  private: 
    vector<T> elems;     // 元素 
 
  public: 
    void push(T const&);  // 入栈
    void pop();               // 出栈
    T top() const;            // 返回栈顶元素
    bool empty() const{       // 如果为空则返回真。
        return elems.empty(); 
    } 
}; 
 
template <class T>
void Stack<T>::push (T const& elem) //Stack后的<T>不要忘了！！
{ 
    // 追加传入元素的副本
    elems.push_back(elem);    
} 
 
template <class T>
void Stack<T>::pop () 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::pop(): empty stack"); 
    }
    // 删除最后一个元素
    elems.pop_back();         
} 
 
template <class T>
T Stack<T>::top () const 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::top(): empty stack"); 
    }
    // 返回最后一个元素的副本 
    return elems.back();      
} 
 
int main() 
{ 
    try { 
        Stack<int>         intStack;  //类声明： int 类型的栈 
        Stack<string> stringStack;    //类声明：string 类型的栈 
 
        // 操作 int 类型的栈 
        intStack.push(7); 
        cout << intStack.top() <<endl; 
 
        // 操作 string 类型的栈 
        stringStack.push("hello"); 
        cout << stringStack.top() << std::endl; 
        stringStack.pop(); 
        stringStack.pop(); 
    } 
    catch (exception const& ex) { 
        cerr << "Exception: " << ex.what() <<endl; 
        return -1;
    } 
}

当上面的代码被编译和执行时，它会产生下列结果：

7
hello
Exception: Stack<>::pop(): empty stack