C++ 编程基础（8）模版 | 8.2、函数模版

原创已于 2025-02-17 15:43:13 修改 · 636 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #java #jvm

于 2024-11-18 10:55:25 首次发布

C++ 编程基础专栏收录该内容

28 篇文章

订阅专栏

文章目录

一、函数模版

前言：

C++ 函数模板是一种强大的特性，它允许程序员编写与类型无关的代码。通过使用模板，函数或类可以处理不同的数据类型，而无需重复编写代码。这种机制提高了代码的可重用性和灵活性。本文将详细介绍C++中的函数模板，包括其定义、使用、实例化以及模板的特化。

一、函数模版

1、声明与定义

函数模板的定义以 template 关键字开头，后面跟着一个模板参数列表（用尖括号 < > 包围）。模板参数列表中的参数可以是类型参数，也可以是非类型参数（如整数常量）。以下是一个简单的函数模板示例，用于计算两个值的最大值：

#include <iostream>

// 定义一个函数模板
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    int intVal1 = 5, intVal2 = 10;
    double doubleVal1 = 5.5, doubleVal2 = 4.4;

    std::cout << "Max of int values: " << max(intVal1, intVal2) << std::endl;
    std::cout << "Max of double values: " << max(doubleVal1, doubleVal2) << std::endl;

    return 0;
}

2、模版参数

除了类型参数（typename 或 class 关键字定义），C++ 函数模板还支持非类型参数。非类型参数通常在模板参数列表中定义，可以包括以下几种形式：

整型常量：如int N
枚举常量：如enum E { A, B } e
指针或引用：如int* ptr或const char& c
模板类型：如typename T::value_type

以下是一个简单的示例，展示如何使用非类型参数来创建一个通用的幂运算函数：

#include <iostream>

// 带有非类型参数的模板函数
template <typename T, int N>
T power(T a) {
    T result = 1;
    for (int i = 0; i < N; ++i) {
        result *= a;
    }
    return result;
}

int main() {
    std::cout << "2^3 = " << power<int, 3>(2) << std::endl;      // 输出: 2^3 = 8
    std::cout << "4^2 = " << power<double, 2>(4) << std::endl;   // 输出: 4^2 = 16.0
    return 0;
}

3、模板的实例化

在代码中包含模板本身并不会生成函数定义，它只是一个用于生成函数定义的方案。当编译器遇到一个函数模板调用时，它会尝试根据提供的参数类型实例化模板。如果成功，编译器会生成相应的函数代码。这个过程称为模板实例化。常见的三种实例化方法分别是：隐式实例化，显示实例化和模版的特化。

3.1、隐式实例化

隐式实例化是指在调用函数模板时，如果没有找到匹配的函数或函数模板，编译器会自动根据传入的参数类型来实例化模板。这种方式不需要程序员显式地指定模板参数，编译器会根据参数自动推导出模板参数的类型。例如：

#include <iostream>

// 通用模板函数
template <typename T>
void print(T value) {
    std::cout << "Value: " << value << std::endl;
}

int main() {
    print(42);          // 隐式实例化为 print<int>(42)
    print(3.14);        // 隐式实例化为 print<double>(3.14)
    print("Hello");     // 隐式实例化为 print<const char*>("Hello")
    return 0;
}

3.2、显示实例化

使用template关键字通过显示声明的方式告诉编译器需要对某个特定类型进行实例化。例如：

#include <iostream>

// 通用模板函数
template <typename T>
void print(T value) {
    std::cout << "Value: " << value << std::endl;
}

// 显式实例化声明
template void print<int>(int);
template void print<double>(double);
template void print<const char*>(const char*);

int main() {
    print(42);          // 使用已实例化的 print<int>(42)
    print(3.14);        // 使用已实例化的 print<double>(3.14)
    print("Hello");     // 使用已实例化的 print<const char*>("Hello")
    return 0;
}

4、模版的特化

有时，对于某些特定类型，可能需要为模板函数提供特定的实现。模版特化的定义应以template<>开头，并且指定具体的类型，例如：

#include <iostream>

// 通用模板定义
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// 特化模板，针对 std::string 类型
template <>
std::string max<std::string>(const std::string &a, const std::string &b) {
    return (a.length() > b.length()) ? a : b;
}

int main() {
    int intVal1 = 5, intVal2 = 10;
    std::string str1 = "apple", str2 = "banana";

    std::cout << "Max of int values: " << max(intVal1, intVal2) << std::endl;
    std::cout << "Longer string: " << max(str1, str2) << std::endl;

    return 0;
}

5、显式指定模板参数类型进行函数调用

在调用模板函数时使用 <> 明确指定模板参数类型，是在调用环节让编译器知晓此次调用要使用的具体模板参数类型。编译器会依据这个指定的类型来实例化模板函数，进而完成函数调用，例如：

#include <iostream>

// 模板函数定义
template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    // 显式指定模板参数类型为 int 进行函数调用
    int result = add<int>(3, 5);
    std::cout << "3 + 5 = " << result << std::endl;
    return 0;
}