学习 C++ / 第 11.7 课

函数模板实例化

23 分钟阅读

在上一课(11.6 -- 函数模板)中,我们介绍了函数模板,并将普通的 max() 函数转换为 max<T>。 函数模板:

C++
template <typename T>
T max(T x, T y)
{
    return (x < y) ? y : x;
}

本课重点介绍函数模板的使用方式。

使用函数模板

函数模板并不是真正的函数——它们的代码不会直接编译或执行。函数模板只有一个任务:生成函数(这些函数才会被编译和执行)。

要使用 max<T> 函数模板,可以按下面的语法调用:

max<actual_type>(arg1, arg2); // actual_type 是具体类型,例如 int 或 double

这看起来很像普通函数调用,主要区别是尖括号中增加了类型(称为模板实参),它指定了替代模板类型 T 的实际类型。

下面通过一个简单示例看看:

C++
#include <iostream>

template <typename T>
T max(T x, T y)
{
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max<int>(1, 2) << '\n'; // 实例化并调用函数 max<int>(int, int)

    return 0;
}

当编译器遇到函数调用 max<int>(1, 2) 时,会发现 max<int>(int, int) 的函数定义尚不存在。因此,编译器会隐式地从我们的 max<T> 模板生成它。 函数模板来创建它。

从函数模板(带有模板类型)创建具体类型函数的过程称为函数模板实例化(简称实例化)。因函数调用而实例化时,称为隐式实例化。从模板实例化出的函数在技术上称为特化,但日常也常称为函数实例。生成特化的模板称为主模板。函数实例在各方面都与普通函数一样。

术语

术语“特化”更多用于指显式特化,它允许我们显式定义特化,而不是让它从主模板隐式实例化。我们会在课程 26.3 -- 函数模板特化 中介绍显式特化。

函数实例化过程很简单:编译器基本上会复制主模板,并将模板类型(T)替换为指定的实际类型(int)。

因此调用 max<int>(1, 2) 时,实例化出的函数特化大致如下:

C++
template<> // 暂时忽略这一点
int max<int>(int x, int y) // 生成的函数 max<int>(int, int)
{
    return (x < y) ? y : x;
}

下面是同一个示例,展示所有实例化完成后编译器实际编译的内容:

C++
#include <iostream>

// 函数模板的声明(不再需要定义)
template <typename T> 
T max(T x, T y);

template<>
int max<int>(int x, int y) // 生成的函数 max<int>(int, int)
{
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max<int>(1, 2) << '\n'; // 实例化并调用函数 max<int>(int, int)

    return 0;
}

你可以自行编译并验证它能够正常工作。 在每个翻译单元中,函数模板只会在第一次发生函数调用时实例化。后续调用会直接使用已经实例化的函数。

反过来,如果没有调用函数模板,它就不会在该翻译单元中实例化。

再看一个示例:

C++
#include <iostream>

template <typename T>
T max(T x, T y) // max(T, T) 的函数模板
{
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max<int>(1, 2) << '\n';    // 实例化并调用函数 max<int>(int, int)
    std::cout << max<int>(4, 3) << '\n';    // 调用已经实例化的函数 max<int>(int, int)
    std::cout << max<double>(1, 2) << '\n'; // 实例化并调用函数 max<double>(double, double)

    return 0;
}

这与前面的示例类似,不过这次函数模板会生成两个函数:一个将 T 替换为 int,另一个将 T 替换为 double。完成所有实例化后,程序大致如下:

C++
#include <iostream>

// 函数模板的声明(不再需要定义)
template <typename T>
T max(T x, T y); 

template<>
int max<int>(int x, int y) // 生成的函数 max<int>(int, int)
{
    return (x < y) ? y : x;
}

template<>
double max<double>(double x, double y) // 生成的函数 max<double>(double, double)
{
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max<int>(1, 2) << '\n';    // 实例化并调用函数 max<int>(int, int)
    std::cout << max<int>(4, 3) << '\n';    // 调用已经实例化的函数 max<int>(int, int)
    std::cout << max<double>(1, 2) << '\n'; // 实例化并调用函数 max<double>(double, double)

    return 0;
}

还要注意:当我们实例化 max<double> 时, ,实例化函数的参数类型为 double。由于我们提供了 int 参数,这些参数会隐式转换为 double。

模板实参推导

大多数情况下,实例化所需的实际类型会与函数参数的类型一致。 例如:

C++
std::cout << max<int>(1, 2) << '\n'; // 指定要调用 max<int>

在这个函数调用中,我们指定将 T 替换为 int,同时传入的实参也是 int。

当实参类型与想要的实际类型匹配时,就不必指定实际类型,而可以使用模板实参推导,让编译器根据函数调用中的实参类型推导应使用的实际类型。

例如,与其这样调用函数:

C++
std::cout << max<int>(1, 2) << '\n'; // 指定要调用 max<int>

也可以改用以下写法之一:

C++
std::cout << max<>(1, 2) << '\n';
std::cout << max(1, 2) << '\n';

在这两种情况下,编译器都会发现我们没有提供实际类型,于是会根据函数实参推导出一种类型,使生成的 max() 函数中所有模板参数都与实参类型匹配。在本例中,编译器会推导出使用函数模板 max<T> 时, ,实际类型为 int ,从而实例化函数 max<int>(int, int),因此两个函数参数(int) 与所提供参数的类型(int).

两种情况的差异与编译器如何从一组重载函数中解析函数调用有关。在上面的情况(尖括号为空)中,编译器只会考虑 max<int>。 模板函数重载来决定调用哪个重载函数。在最后一种情况(没有尖括号)中,编译器会同时考虑 max<int> 模板函数重载和max 非模板函数重载。如果最后一种情况中模板函数和非模板函数同样可行,将优先选择非模板函数。

关键要点

普通函数调用语法会优先选择非模板函数,而不是同样可行的模板实例化函数。

例如:

C++
#include <iostream>

template <typename T>
T max(T x, T y)
{
    std::cout << "called max<int>(int, int)\n";
    return (x < y) ? y : x;
}

int max(int x, int y)
{
    std::cout << "called max(int, int)\n";
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max<int>(1, 2) << '\n'; // 调用 max<int>(int, int)
    std::cout << max<>(1, 2) << '\n';    // 推导为 max<int>(int, int)(不考虑非模板函数)
    std::cout << max(1, 2) << '\n';      // 调用 max(int, int)

    return 0;
}

注意下面情况的语法与普通函数调用完全相同!大多数情况下,我们会使用这种普通函数调用语法来调用从函数模板实例化出的函数。

原因有几个:

  • 这种写法更简洁。
  • 同时存在匹配的非模板函数和函数模板的情况很少。
  • 如果确实同时存在匹配的非模板函数和函数模板,通常更希望调用非模板函数。

最后一点可能不太明显。函数模板的实现必须适用于多种类型,因此必须保持通用。非模板函数只处理特定的类型组合,可以针对这些类型实现比函数模板版本更优化或更专门的代码。例如:

C++
#include <iostream>

// 此函数模板可以处理多种类型,因此实现是通用的
template <typename T>
void print(T x)
{
    std::cout << x; // 按 T 的通常方式输出
}

// 此函数只需考虑如何输出 bool,因此可以专门处理
// bool 的输出
void print(bool x)
{
    std::cout << std::boolalpha << x; // 将 bool 输出为 true 或 false,而不是 1 或 0
}

int main()
{
    print<bool>(true); // 调用 print<bool>(bool),输出 1
    std::cout << '\n';

    print<>(true);     // 推导为 print<bool>(bool)(不考虑非模板函数),输出 1
    std::cout << '\n';

    print(true);       // 调用 print(bool),输出 true
    std::cout << '\n';

    return 0;
}

最佳实践

调用函数模板实例化函数时,优先使用普通函数调用语法(除非需要优先选择函数模板版本而不是匹配的非模板函数)。

带非模板参数的函数模板

函数模板可以同时包含模板参数和非模板参数。类型模板参数可以匹配任意类型,非模板参数则像普通函数的参数一样工作。

例如:

C++
// T 是类型模板参数
// double 是非模板参数
// 这些参数不会使用,因此不必提供名称
template <typename T>
int someFcn(T, double)
{
    return 5;
}

int main()
{
    someFcn(1, 3.4); // 匹配 someFcn(int, double)
    someFcn(1, 3.4f); // 匹配 someFcn(int, double),float 提升为 double
    someFcn(1.2, 3.4); // 匹配 someFcn(double, double)
    someFcn(1.2f, 3.4); // 匹配 someFcn(float, double)
    someFcn(1.2f, 3.4f); // 匹配 someFcn(float, double),float 提升为 double

    return 0;
}

这个函数模板的第一个参数是模板参数,但第二个参数固定为 double 类型。请注意,返回类型也可以是任意类型。本例中,函数始终返回 int 值。

实例化的函数不一定总能通过编译

请看下面的程序:

C++
#include <iostream>

template <typename T>
T addOne(T x)
{
    return x + 1;
}

int main()
{
    std::cout << addOne(1) << '\n';
    std::cout << addOne(2.3) << '\n';

    return 0;
}

编译器实际上会编译并执行以下代码:

C++
#include <iostream>

template <typename T>
T addOne(T x);

template<>
int addOne<int>(int x)
{
    return x + 1;
}

template<>
double addOne<double>(double x)
{
    return x + 1;
}

int main()
{
    std::cout << addOne(1) << '\n';   // 调用 addOne<int>(int)
    std::cout << addOne(2.3) << '\n'; // 调用 addOne<double>(double)

    return 0;
}

这会产生以下结果:

2
3.3

但如果尝试下面这样的写法呢?

C++
#include <iostream>
#include <string>

template <typename T>
T addOne(T x)
{
    return x + 1;
}

int main()
{
    std::string hello { "Hello, world!" };
    std::cout << addOne(hello) << '\n';

    return 0;
}

编译器解析 addOne(hello) 时,找不到匹配 addOne(std::string) 的非模板函数,但会找到 addOne(T) 函数模板,并判断可以从它生成 addOne(std::string) 函数。因此,编译器会生成并编译以下代码:

C++
#include <iostream>
#include <string>

template <typename T>
T addOne(T x);

template<>
std::string addOne<std::string>(std::string x)
{
    return x + 1;
}

int main()
{
    std::string hello{ "Hello, world!" };
    std::cout << addOne(hello) << '\n';

    return 0;
}

不过,这会产生编译错误,因为当 x 是 std::string 时,x + 1 没有意义。显然,解决方法是不要用 std::string 类型的实参调用 addOne()。

实例化的函数在语义上不一定总有意义

只要语法上成立,编译器就能成功编译实例化的函数模板。但编译器无法检查这个函数在语义上是否真正合理。

例如:

C++
#include <iostream>

template <typename T>
T addOne(T x)
{
    return x + 1;
}

int main()
{
    std::cout << addOne("Hello, world!") << '\n';

    return 0;
}

在这个示例中,我们对 C 风格字符串字面量调用 addOne()。这在语义上究竟意味着什么?谁也说不清!

可能令人惊讶的是,由于 C++ 在语法上允许将整数值加到字符串字面量上(我们会在课程 17.9 -- 指针算术与下标访问 中介绍),上面的示例可以编译,并产生以下结果:

ello, world!

警告

只要语法有效,编译器就会实例化并编译那些语义上没有意义的函数模板。你有责任确保调用函数模板时使用的实参在语义上合理。

进阶读者

可以告诉编译器禁止函数模板使用某些实参进行实例化。方法是使用函数模板特化,为特定模板实参集合提供重载,并结合 = delete 告诉编译器,任何对该函数的使用都应产生编译错误。

C++
#include <iostream>
#include <string>

template <typename T>
T addOne(T x)
{
    return x + 1;
}

// 使用函数模板特化,告诉编译器 addOne(const char*) 应产生编译错误
// const char* 可以匹配字符串字面量
template <>
const char* addOne(const char* x) = delete;

int main()
{
    std::cout << addOne("Hello, world!") << '\n'; // 编译错误

    return 0;
}

函数模板特化见课程 26.3 -- 函数模板特化。

带非模板参数默认实参的函数模板

和普通函数一样,函数模板也可以为非模板参数提供默认实参。从模板实例化出的每个函数都会使用相同的默认实参。

例如:

C++
#include <iostream>

template <typename T>
void print(T val, int times=1)
{
    while (times--)
    {
        std::cout << val;        
    }
}

int main()
{
    print(5);      // 输出 5 一次
    print('a', 3); // 输出 'a' 三次

    return 0;
}

输出结果:

5aaa

警惕带可修改静态局部变量的函数模板

在课程 7.11 -- 静态局部变量 中,我们讨论过静态局部变量,即具有静态存储期的局部变量(在整个程序生命周期内持续存在)。

在函数模板中使用静态局部变量时,从该模板实例化出的每个函数都会拥有独立的静态局部变量版本。如果静态局部变量是 const,这通常不是问题;但如果它会被修改,结果可能与预期不同。

例如:

C++
#include <iostream>

// 这是一个会修改静态局部变量的函数模板
template <typename T>
void printIDAndValue(T value)
{
    static int id{ 0 };
    std::cout << ++id << ") " << value << '\n';
}

int main()
{
    printIDAndValue(12);
    printIDAndValue(13);

    printIDAndValue(14.5);

    return 0;
}

运行结果为:

1) 12
2) 13
1) 14.5

你可能预期最后一行输出 3) 14.5。 但编译器实际编译和执行的是:

C++
#include <iostream>

template <typename T>
void printIDAndValue(T value);

template <>
void printIDAndValue<int>(int value)
{
    static int id{ 0 };
    std::cout << ++id << ") " << value << '\n';
}

template <>
void printIDAndValue<double>(double value)
{
    static int id{ 0 };
    std::cout << ++id << ") " << value << '\n';
}

int main()
{
    printIDAndValue(12);   // 调用 printIDAndValue<int>()
    printIDAndValue(13);   // 调用 printIDAndValue<int>()

    printIDAndValue(14.5); // 调用 printIDAndValue<double>()

    return 0;
}

请注意, printIDAndValue<int> 和 printIDAndValue<double> 各自拥有独立的静态局部变量 id,而不是共享同一个变量。

泛型编程

由于模板类型可以替换为任意实际类型,有时也称为泛型类型。由于模板可以独立于具体类型编写,使用模板编程有时称为泛型编程。C++ 通常非常重视类型和类型检查,而泛型编程让我们能够专注于算法逻辑和数据结构设计,而不必过多关注类型信息。

总结

习惯编写函数模板后,你会发现它们并不比编写具体类型的函数花费更多时间。函数模板可以减少需要编写和维护的代码量,从而显著降低维护成本和错误。

函数模板确实有一些缺点,也不能不提。首先,对于每组独特的实参类型,编译器都会创建并编译一个函数。因此,函数模板虽然书写紧凑,却可能展开成大量代码,导致代码膨胀和编译变慢。更大的缺点是,它们往往产生看起来极其复杂、几乎无法阅读的错误消息,比普通函数的错误消息难以理解得多。这些消息可能令人畏惧,但理解其含义后,通常就能比较直接地解决它们指出的问题。

与模板为编程工具箱带来的能力和安全性相比,这些缺点相当有限,因此在需要类型灵活性的地方可以放心使用模板!一个经验法则是先创建普通函数,发现需要支持不同参数类型的重载时,再将它转换为函数模板。

最佳实践

需要支持多种类型时,使用函数模板编写泛型代码。

最后更新