理解C++之类模板

在前面我们介绍了《C++之函数模板》

今天我们继续来介绍模板的另外一种形式：类模板。

与模板函数相似，类也可以被一种或多种类型参数化，标准库中的容器类就是一个具有这种特性的典型例子。

类模板的声明

我们通过一段例子代码了解一下类模板的声明：

// 类模板声明
template 
class MyClass{
public:
    T getT();
    void setT(T t);
private:
    T t;
};
// 类成员函数实现
template
T MyClass::getT() {
    return t;
}

template
void MyClass::setT(T t) {
    this->t = t;
}

int main(int argc, char* argv[]) {
    // 类模板使用
    MyClass myClass;
    myClass.setT(10);
    std::cout << "myClass:" << myClass.getT() << std::endl;
    return 0;
}

首先也是使用关键字template和关键字typename对类模板进行声明，当我们将一个类声明为类模板之后，模板参数T可以像其他任何类型一样，用于声明成员变量和成员函数。

类模板的成员函数

通过上面的实例代码，我们看到在类模板的声明内部函数时如果用到模板参数T，则不用再次使用template，但是当实现类模板的内部函数时，如果用到了模板参数T，则还需要在函数的上方使用template进行标记。

也即是说为了定义类模板的成员函数，你必须指定该成员函数是一个函数模板，而且你还需要使用这个类模板的完整类型限定符。

或许你觉得每次定义类模板的内部函数都要使用到模板声明，当内部函数较多时，则会产生非常多的不必要的声明，此时我们可以直接在类的内部声明加定义同时实现：

// 类模板声明
template 
class MyClass{
public:
    // 声明加定义
    T getT(){
        return t;
    }
    // 声明加定义
    void setT(T t){
        this->t = t;
    }
private:
    T t;
};

在类模板中只有那些被调用的成员函数，才会产生这些函数的实例化代码。对于类模板，成员函数只有在被使用的时候才会被实例化。显然，这样可以节省空间和时间；另一个好处是：对于那些“未能提供所有成员函数中所有操作的”类型，你也可以使用该类型来实例化类模板，只要对那些“未能提供某些操作的”成员函数，模板内部不使用即可。

类模板的特例化

同模板函数的特化一样，你可以用模板实参来特化类模板，和函数模板的重载类似，通过特化类模板，我们可以优化基于某种特定类型的实现。

在类模板的特化过程中有两个步骤：

在类的起始处声明一个template<>，接下来声明用来特化类模板的类型。这个类型被用作模板实参，且必须在类名的后面直接指定。
进行类模板的特化时，每个成员函数都必须重新定义为普通函数，原来模板函数中的每个T也相应地被进行特化的类型取代。

下面是一个模板类特化的例子：

// 类模板声明
template 
class MyClass{
public:
    // 声明加定义
    T getT(){
        return t;
    }
    // 声明加定义
    void setT(T t){
        this->t = t;
    }
private:
    T t;
};

// 类模板声明
template <>
class MyClass{
public:
    // 声明加定义
    std::string getT(){
        return t;
    }
    // 声明加定义
    void setT(std::string t){
        std::cout << "调用特化类模板 setT" << std::endl;
        this->t = t;
    }
private:
    std::string t;
};

int main(int argc, char* argv[]) {
    // 类模板使用
    MyClass myClass;
    myClass.setT("hello word");
    std::cout << "myClass:" << myClass.getT() << std::endl;
    return 0;
}

模板源码组织模式

模板源码的组织模式有好多种，这里只介绍两种常用的:分别是包含模式和关键字export的分离模式。

包含模式可以说是最常用也是最推荐的一种模式。这种模式就是将模板类的声明和定义都放在同一个文件中，这个文件一般是扩展名为.hpp的文件。

下面是一个类模板声明定义和使用分开在不同文件的例子：

MyClass.hpp
#include 
#include 
// 类模板声明
template 
class MyClass{
public:
    // 声明
    T getT();

    void setT(T t);
private:
    T t;
};

template
T MyClass::getT() {
    return t;
}

template
void MyClass::setT(T t) {
    this->t = t;
}

在main函数中使用模板main.cpp:

main.cpp

#include 
#include 
#include "MyClass.hpp"
int main(int argc, char* argv[]) {
    // 类模板使用
    MyClass myClass;
    myClass.setT("hello word");
    std::cout << "myClass:" << myClass.getT() << std::endl;
    return 0;
}

很明显，包含模式因为包含了类模板的定义实现，因而明显增加了包含头文件.hpp的开销，这会导致大大增加了编译复杂程序所耗费的时间。然而随着现代的机器性能提升，这里带来的编译开销基本可以忽略不计，因此这种模式成为了使用最多的模式。

下面我们再来看看关键字export的分离模式。

关键字export的功能使用是非常简单的：在一个文件里面定义模板，并在模板的定义和（非定义的）声明的前面加上关键字export。

还是以上面的代码为例：

(1) MyClass.h

#include 
#include 
// 类模板声明
export template 
class MyClass{
public:
    // 声明
    T getT();

    void setT(T t);
private:
    T t;
};

(2) MyClass.cpp

#include "MyClass.h"

export template
T MyClass::getT() {
    return t;
}

export template
void MyClass::setT(T t) {
    this->t = t;
}

以上代码能否编译通过取决于你的编译器，大部分是无法编译通过的，这代码和包含模式对比起来是不是有一种脱裤子放屁的感觉？

看起来关键字export的分离模式更加符合C++源码组织习惯，为什么这种写法再C++的模板没有流行起来呢？这是因为在C++标准推出几年之后，也就只有极少的公司真正提供了对export关键字的支持。于是，export这个特性未能像其他C++特性那样广为流传，这就使得程序员在很多编译器下都不能正常使用export的分离模式。

新闻名称：理解C++之类模板
转载来于：http://www.csdahua.cn/qtweb/news12/413512.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：快上网

成都快上网为您推荐相关内容