C++模板怎么使用函数模板与类模板语法-C++-PHP中文网

C++模板通过函数模板和类模板实现代码复用与类型安全，支持类型参数、非类型参数和模板模板参数，实例化在编译期进行，需注意定义可见性、代码膨胀、编译时间等问题。

c++模板怎么使用函数模板与类模板语法

C++模板这东西，说白了就是让你写代码的时候，能更通用、更灵活，不用为每一种数据类型都重写一套逻辑。它就像一个模具，你定义好形状，然后往里面灌不同的材料（数据类型），就能生产出针对不同类型的产品（函数或类）。核心思想就是代码复用和类型安全。它主要分两种：函数模板和类模板。

解决方案

要用C++模板，你得先理解它的基本语法和背后的“实例化”概念。

函数模板

想象一下，你写了一个函数，比如求两个数中的最大值，你可能想让它既能比较整数，又能比较浮点数，甚至自定义的类型。这时候，函数模板就派上用场了。

立即学习“C++免费学习笔记（深入）”；

语法是这样：

template <typename T> // 或者 template <class T>，在这里两者等价
T max(T a, T b) {
    return (a > b) ? a : b;
}

登录后复制

这里

登录后复制

就是一个类型参数，它代表一个占位符，编译器在实际使用时会根据你传入的参数类型来“推导”出

登录后复制

具体是什么。

比如，你这样用：

int i_max = max(10, 20); // 编译器推导出 T 是 int
double d_max = max(3.14, 2.71); // 编译器推导出 T 是 double
std::string s1 = "hello", s2 = "world";
std::string s_max = max(s1, s2); // 编译器推导出 T 是 std::string，需要 string 支持 > 运算符

登录后复制

编译器会根据你传入的参数类型，自动生成一个

max<int>(int, int)

登录后复制

、

max<double>(double, double)

登录后复制

或

max<std::string>(std::string, std::string)

登录后复制

的具体函数版本，这个过程就叫“模板实例化”。

你也可以显式地指定类型：

int i_max_explicit = max<int>(5, 8);

登录后复制

这在某些编译器无法推导出类型，或者你希望强制转换类型时很有用。

类模板

类模板则允许你定义一个通用的类结构，比如一个栈、一个队列或者一个链表，它们的操作逻辑与存储的数据类型无关。

语法是这样：

template <typename T>
class MyStack {
private:
    T* data;
    int top;
    int capacity;

public:
    MyStack(int cap = 100) : capacity(cap), top(-1) {
        data = new T[capacity];
    }
    ~MyStack() {
        delete[] data;
    }

    void push(T val) {
        if (top < capacity - 1) {
            data[++top] = val;
        }
        // else: handle stack full error
    }

    T pop() {
        if (top >= 0) {
            return data[top--];
        }
        // else: handle stack empty error
        return T(); // Return default-constructed T
    }

    bool isEmpty() const {
        return top == -1;
    }
};

登录后复制

注意，类模板的成员函数如果在类外部定义，也需要加上模板头：

template <typename T>
void MyStack<T>::push(T val) {
    if (top < capacity - 1) {
        data[++top] = val;
    }
}

登录后复制

使用类模板时，你必须显式地指定类型参数：

MyStack<int> intStack(50); // 创建一个存储 int 的栈
intStack.push(10);
int val = intStack.pop();

MyStack<std::string> stringStack; // 创建一个存储 std::string 的栈
stringStack.push("Hello");
stringStack.push("World");
std::string s_val = stringStack.pop();

登录后复制

同样，编译器会根据

MyStack<int>

登录后复制

和

MyStack<std::string>

登录后复制

生成具体的类定义。

启科网络PHP商城系统

启科网络商城系统由启科网络技术开发团队完全自主开发，使用国内最流行高效的PHP程序语言，并用小巧的MySql作为数据库服务器，并且使用Smarty引擎来分离网站程序与前端设计代码，让建立的网站可以自由制作个性化的页面。系统使用标签作为数据调用格式，网站前台开发人员只要简单学习系统标签功能和使用方法，将标签设置在制作的HTML模板中进行对网站数据、内容、信息等的调用，即可建设出美观、个性的网站。

查看详情

C++模板的类型参数有哪些？

谈到模板参数，其实它远不止

typename T

登录后复制

那么简单，虽然那是我们最常用的形式。理解这些不同的参数类型，能让你在编写更复杂、更灵活的模板时游刃有余。

主要的模板参数类型有三种：

类型参数 (Type Parameters) 这是最常见的一种，用
```
typename
```
登录后复制
或
```
class
```
登录后复制
关键字声明。它们都表示一个占位符，代表一个具体的数据类型。
```
template <typename T, class U> // T 和 U 都是类型参数
void func(T arg1, U arg2) { /* ... */ }
```
登录后复制
在模板声明中，
```
typename
```
登录后复制
和
```
class
```
登录后复制
在表示类型参数时是等价的，你可以选择你喜欢的那个。不过，在某些特定上下文（比如依赖类型名）中，
```
typename
```
登录后复制
还有额外的作用，但那是另一个话题了。
非类型参数 (Non-type Parameters) 这种参数不是一个类型，而是一个编译期常量值。它可以是整数类型（
```
int
```
登录后复制
,
```
long
```
登录后复制
,
```
bool
```
登录后复制
等）、枚举类型、指针类型（包括函数指针）、左值引用类型，甚至是
```
std::nullptr_t
```
登录后复制
。
```
template <typename T, int N> // N 是一个非类型参数，代表一个整数常量
class Array {
private:
    T data[N]; // 数组大小在编译期确定
public:
    T& operator[](int index) { return data[index]; }
    int size() const { return N; }
};

Array<double, 10> doubleArray; // 创建一个包含10个double的数组
```
登录后复制
非类型参数在编译时就必须是已知的常量表达式，所以你不能用变量来作为非类型参数的值。它们在实现固定大小数组、位域等场景时非常有用。
模板模板参数 (Template Template Parameters) 这个听起来有点绕，但其实它就是一个模板作为另一个模板的参数。它通常用于当你需要一个模板类（比如一个容器）能够使用另一个模板类（比如一个分配器或者另一个容器）作为其内部组件时。
```
template <typename T, template <typename> class Container> // Container 是一个模板模板参数
class MyWrapper {
private:
    Container<T> c; // 内部使用传入的容器模板
public:
    void add(T val) { c.push_back(val); }
    // ...
};

// 使用 std::vector 作为内部容器
MyWrapper<int, std::vector> wrapperVec;
wrapperVec.add(10);

// 使用 std::list 作为内部容器
MyWrapper<double, std::list> wrapperList;
wrapperList.add(3.14);
```
登录后复制
这里的
```
template <typename> class Container
```
登录后复制
表示
```
Container
```
登录后复制
必须是一个接受一个类型参数的类模板。这种参数在设计通用库，比如适配器模式或策略模式时，提供了极大的灵活性。

理解这些不同类型的模板参数，是掌握C++模板高级用法的关键一步。它们让你的代码能够以惊人的方式进行泛化和抽象。

模板实例化是什么意思？它如何影响编译？

模板实例化是C++模板机制的核心，也是它在编译期发挥作用的关键。简单来说，模板实例化就是编译器根据你提供的具体类型或非类型参数，从模板定义中生成一个具体函数或类的过程。 模板本身并不是可以直接执行的代码，它更像是一张蓝图或者一个食谱。只有当你实际“使用”它时，编译器才会按照这张蓝图“建造”出实际的组件。

这个过程对编译有着非常直接且深远的影响：

按需生成代码 (On-Demand Code Generation) 当你定义一个函数模板
```
template <typename T> T max(T a, T b)
```
登录后复制
时，编译器并不会立即生成
```
max<int>
```
登录后复制
、
```
max<double>
```
登录后复制
等所有可能的版本。它会等到你在代码中真正调用
```
max(10, 20)
```
登录后复制
(即
```
max<int>
```
登录后复制
) 或者
```
max(3.14, 2.71)
```
登录后复制
(即
```
max<double>
```
登录后复制
) 时，才会分别生成
```
max<int>
```
登录后复制
和
```
max<double>
```
登录后复制
的具体代码。类模板也是如此。定义
```
template <typename T> class MyStack
```
登录后复制
时，没有实际的代码生成。只有当你写
```
MyStack<int> intStack;
```
登录后复制
时，编译器才会生成
```
MyStack<int>
```
登录后复制
类的具体定义，包括其成员函数。这种按需生成的方式，避免了生成大量不必要的代码，从而节省了编译时间和最终可执行文件的大小。
编译期错误检测 (Compile-Time Error Detection) 模板实例化发生在编译期。这意味着所有与模板参数相关的类型检查、函数调用合法性检查等，都会在编译阶段完成。如果你的模板代码对某个特定类型不适用（比如，你尝试对一个不支持
```
>
```
登录后复制
运算符的自定义类使用
```
max
```
登录后复制
函数），编译器会在实例化时立即报错，而不是等到运行时才发现问题。这大大提高了代码的健壮性和调试效率。
代码膨胀 (Code Bloat) 虽然按需生成代码听起来很高效，但它也有一个潜在的副作用：代码膨胀。如果你的模板被实例化了很多次，每次使用不同的类型，那么编译器就会生成很多份几乎相同的代码（只是类型不同）。例如，如果你用
```
max<int>
```
登录后复制
、
```
max<double>
```
登录后复制
、
```
max<float>
```
登录后复制
、
```
max<long>
```
登录后复制
等等，就会有多个
```
max
```
登录后复制
函数的独立副本存在于最终的可执行文件中。对于小型函数，这可能影响不大，但对于大型类模板，如果实例化次数过多，可能会显著增加可执行文件的大小，甚至影响指令缓存的效率。这是模板编程中需要权衡的一个点。
模板定义必须可见 (Definition Must Be Visible) 由于模板实例化是在编译期进行的，编译器需要知道模板的完整定义才能生成具体的代码。这意味着，与普通函数或类的声明/定义分离不同，模板的定义（包括函数模板和类模板的成员函数定义）通常必须放在头文件中，或者在使用它的翻译单元（.cpp文件）中。如果只在头文件中放声明，而在 .cpp 文件中放定义，链接器会因为找不到具体的实例化代码而报错（通常是“未定义引用”错误）。这是初学者使用模板时最常遇到的坑之一。
元编程的基础 (Basis for Metaprogramming) 模板实例化机制也是C++模板元编程（Template Metaprogramming, TMP）的基础。TMP利用编译期的模板实例化和特化规则，执行复杂的计算和类型转换，甚至生成代码。它将计算从运行时提前到编译时，从而提高运行时性能，但代价是增加编译时间复杂度和代码的可读性。

理解模板实例化，能帮助你更好地把握模板的性能特征、调试策略以及在项目结构中的组织方式。它既是C++强大泛型能力的基石，也是其复杂性的一部分。

C++模板编程中常见的陷阱或注意事项？

模板虽然强大，但用起来也有些门道，一不小心就可能踩坑。作为过来人，我总结了一些常见的“坑”和需要注意的地方，希望能帮你避开它们。

定义必须在头文件中 (或在使用前可见) 这是最常见也最让人迷惑的陷阱。不同于普通函数或类，模板的定义（包括函数模板和类模板的成员函数定义）通常不能放在单独的
```
.cpp
```
登录后复制
文件中，而必须放在头文件中，或者在使用它的
```
.cpp
```
登录后复制
文件中（不推荐）。 原因： 编译器在实例化模板时，需要看到模板的完整定义才能生成代码。如果定义在另一个编译单元的
```
.cpp
```
登录后复制
文件中，当前编译单元在编译时看不到定义，链接时又找不到具体的实例化代码，就会报“未定义引用”（undefined reference）错误。 解决： 把模板的定义直接写在头文件中。虽然这可能让头文件看起来很“重”，但这是C++模板的惯例。
```
typename
```
登录后复制
的双重含义与依赖类型名
```
typename
```
登录后复制
关键字在模板中除了声明类型参数外，还有一个非常重要的作用：指明一个依赖于模板参数的名称是类型。
```
template <typename T>
class MyClass {
    typename T::iterator it; // 这里的 'typename' 是必需的！
    // ...
};
```
登录后复制
如果没有
```
typename
```
登录后复制
，编译器会认为
```
T::iterator
```
登录后复制
是一个静态成员变量而不是一个类型。这是因为在模板被实例化之前，编译器无法确定
```
T::iterator
```
登录后复制
到底是什么（它可能是类型，也可能是变量）。加上
```
typename
```
登录后复制
就明确告诉编译器：“嘿，这个
```
T::iterator
```
登录后复制
肯定是个类型！” 这个错误往往很难理解，因为报错信息可能比较晦涩。
模板参数推导失败或歧义 函数模板的参数推导非常方便，但也可能失败或产生歧义。
```
template <typename T>
T sum(T a, T b) { return a + b; }

int main() {
    // sum(1, 2.5); // 错误！无法推导出 T 是 int 还是 double
    sum<double>(1, 2.5); // OK，显式指定 T
    return 0;
}
```
登录后复制
当参数类型不一致时，编译器不知道该把
```
T
```
登录后复制
推导成哪种类型。这种情况下，你需要显式地指定模板参数，或者提供一个非模板的重载函数来处理这种情况。

非类型模板参数的限制 非类型模板参数必须是编译期常量表达式。你不能传递运行时变量作为非类型参数。

template <int N>
class FixedArray { /* ... */ };

int size = 10;
// FixedArray<size> arr; // 错误！'size' 不是编译期常量
const int compile_time_size = 10;
FixedArray<compile_time_size> arr; // OK

登录后复制

模板代码膨胀 (Code Bloat) 前面提过，模板的每次实例化都会生成一份独立的代码。如果你的模板被不同类型实例化了成百上千次，最终的可执行文件可能会非常大。 解决： 考虑将模板的通用逻辑抽取到非模板基类中，或者使用类型擦除（type erasure）技术，例如
```
std::function
```
登录后复制
或
```
std::any
```
登录后复制
的实现原理，来减少模板实例化带来的代码重复。但这些通常会带来运行时开销。

友元声明与模板 在类模板中声明友元函数或友元类时，需要特别注意语法，因为友元本身也可能依赖于模板参数。

template <typename T>
class MyClass {
    template <typename U>
    friend void print(const MyClass<U>& obj); // 友元函数模板
    // friend void print(const MyClass<T>& obj); // 友元函数，绑定到当前 MyClass<T> 实例
};

登录后复制

这块细节比较多，容易写错。

模板特化与偏特化 当你需要为特定类型提供不同于通用模板的实现时，会用到模板特化（完全特化）或偏特化（部分特化）。
```
// 通用模板
template <typename T>
void process(T val) { /* ... */ }

// 完全特化：针对 int 类型
template <>
void process<int>(int val) { /* ... */ }

// 偏特化：针对指针类型
template <typename T>
void process<T*>(T* val) { /* ... */ }
```
登录后复制
特化规则比较复杂，特别是当有多个偏特化版本时，编译器会根据最匹配的规则来选择。这有时会导致意想不到的行为。
编译时间长 大量使用模板，特别是复杂的模板元编程，会显著增加编译时间。这是因为编译器在实例化和解析模板时需要做大量的工作。 解决： 尽量减少不必要的模板实例化，使用预编译头文件（PCH），或者在可能的情况下，用运行时多态代替编译期多态（模板是编译期多态）。