c++ 模板函数_c++指定某个模板参数-优快云博客

在C++中，模板是一种强大的工具，允许编写通用的代码。模板函数（函数模板）是其中的一种形式，它允许我们编写一个通用的函数，可以处理多种类型的参数。
为了更好地理解模板函数的使用，需要掌握以下几个概念：显式实例化、特化以及它们与重载的区别。

1. 函数模板的显式实例化

1.1 显式实例化定义

显式实例化定义是指在代码中明确指定模板函数针对某种类型的实例化。它的语法如下：

template void fun<int>(int);  // 显式实例化定义
template void fun(double);    // 显式实例化定义（省略模板参数）

示例：

#include <iostream>

template <typename T>
void fun(T x) {
    std::cout << "Generic template: " << x << std::endl;
}

// 显式实例化定义
template void fun<int>(int);    // 针对 int 类型的显式实例化
template void fun<double>(double); // 针对 double 类型的显式实例化

int main() {
    fun(42);       // 使用显式实例化的 int 版本
    fun(3.14);     // 使用显式实例化的 double 版本
    return 0;
}

输出：

Generic template: 42
Generic template: 3.14

1.2 显式实例化声明

显式实例化声明用于告诉编译器，模板函数的某个实例化已经在其他地方定义，避免重复实例化。它的语法如下：

extern template void fun<int>(int);  // 显式实例化声明
extern template void fun(double);    // 显式实例化声明（省略模板参数）

示例：

// file1.cpp
#include <iostream>

template <typename T>
void fun(T x) {
    std::cout << "Generic template: " << x << std::endl;
}

// 显式实例化定义
template void fun<int>(int);

// file2.cpp
extern template void fun<int>(int);  // 显式实例化声明

int main() {
    fun(42);       // 使用显式实例化的 int 版本
    fun(3.14);     // 隐式实例化的 double 版本
    return 0;
}

注意：

显式实例化声明通常用于分离编译的场景，避免在多个编译单元中重复实例化相同的模板。

2. 函数模板的特化

2.1 完全特化

完全特化是指为模板函数针对特定类型提供一个特殊的实现。它的语法如下：

template<> void fun<int>(int);  // 完全特化
template<> void fun(double);    // 完全特化（省略模板参数）

示例：

#include <iostream>

template <typename T>
void fun(T x) {
    std::cout << "Generic template: " << x << std::endl;
}

// 完全特化
template<>
void fun<int>(int x) {
    std::cout << "Specialized template for int: " << x << std::endl;
}

int main() {
    fun(42);       // 使用特化的 int 版本
    fun(3.14);     // 使用通用的 double 版本
    return 0;
}

输出：

Specialized template for int: 42
Generic template: 3.14

2.2 特化与重载的区别

特化：特化是针对模板的某个特定类型提供一个特殊的实现，它不会引入新的名称。
重载：重载是定义一个新的函数，函数名相同但参数类型或数量不同。

示例：

#include <iostream>

template <typename T>
void fun(T x) {
    std::cout << "Generic template: " << x << std::endl;
}

// 特化
template<>
void fun<int>(int x) {
    std::cout << "Specialized template for int: " << x << std::endl;
}

// 重载
void fun(int x) {
    std::cout << "Overloaded function for int: " << x << std::endl;
}

int main() {
    fun(42);       // 调用重载函数，而不是特化版本
    fun(3.14);     // 调用通用模板
    return 0;
}

输出：

Overloaded function for int: 42
Generic template: 3.14

3. 注意事项

3.1 一处定义原则（ODR）

模板的显式实例化定义和特化必须遵守一处定义原则（ODR），即在整个程序中只能有一个定义。
显式实例化声明可以出现在多个编译单元中，但定义只能出现一次。

3.2 模板形参推导

在模板实例化和特化过程中，编译器会根据传入的实参推导模板参数。
如果推导失败（例如类型不匹配），编译器会报错。

示例：

#include <iostream>

template <typename T>
void fun(T x) {
    std::cout << "Generic template: " << x << std::endl;
}

int main() {
    fun(42);       // T 被推导为 int
    fun(3.14);     // T 被推导为 double
    fun("hello");  // T 被推导为 const char*
    return 0;
}