C++模板进阶

非类型模板参数

一、概念

在 C++ 模板机制中，模板参数分为类型模板参数和非类型模板参数。非类型模板参数（Non-type template parameters）允许使用除了类型之外的常量表达式作为模板的参数，例如整型常量、枚举值、指针（包括函数指针、对象指针等）、引用（左值引用）等，来在编译阶段确定模板实例化的一些特定属性。

二、语法形式

非类型模板参数的语法格式是在模板定义中，将相应的常量表达式放在模板参数列表里，形式如下：

template <typename T, int N>  // 这里的int N就是非类型模板参数，N需要是编译期可确定的整数常量
class MyClass {
    // 类的具体实现
};

在这个示例中，T 是类型模板参数，而 int N 就是非类型模板参数，它限定了 N 必须是在编译阶段就能确定值的整数类型的常量表达式。

三、使用示例

1. 数组大小指

可以利用非类型模板参数来指定数组的大小，示例如下：

#include <iostream>

template <typename T, int Size>
class ArrayWrapper {
public:
    T arr[Size];
    void print() {
        for (int i = 0; i < Size; ++i) {
            std::cout << arr[i] << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    ArrayWrapper<int, 5> myArr;  // 使用非类型模板参数指定数组大小为5
    for (int i = 0; i < 5; ++i) {
        myArr.arr[i] = i;
    }
    myArr.print();
    return 0;
}

在上述代码中：

• 定义了一个名为 ArrayWrapper 的类模板，它有一个类型模板参数 T 用于指定数组元素的类型，还有一个非类型模板参数 int Size 用于确定数组的大小，且这个大小在编译阶段就被确定下来了。
• 在 main 函数中，通过 ArrayWrapper<int, 5> 实例化了这个模板类，创建了一个元素类型为 int 、数组大小为 5 的对象 myArr，后续可以对这个对象进行操作，比如给数组元素赋值并打印输出。

2. 函数指针作为非类型模板参数

以下示例展示了如何将函数指针作为非类型模板参数传递，实现不同函数在编译阶段绑定到模板中：

#include <iostream>

// 两个普通函数示例
void func1(int num) {
    std::cout << "执行 func1，参数为: " << num << std::endl;
}

void func2(int num) {
    std::cout << "执行 func2，参数为: " << num << std::endl;
}

// 定义带有函数指针作为非类型模板参数的模板类
template <void (*FuncPtr)(int)>
class FunctionCaller {
public:
    static void call(int num) {
        FuncPtr(num);
    }
};

int main() {
    FunctionCaller<func1>::call(10);  // 调用绑定了func1的模板类的call函数
    FunctionCaller<func2>::call(20);  // 调用绑定了func2的模板类的call函数
    return 0;
}

在这个例子里：

• 首先定义了两个简单的函数 func1 和 func2，它们都接受一个整数参数并输出相应的执行信息。
• 接着定义了一个类模板 FunctionCaller，其非类型模板参数是一个指向接受整数参数、返回值为 void 的函数指针（void (*FuncPtr)(int) ）。
• 在类模板中，有一个静态成员函数 call，它通过这个函数指针来调用相应的函数。
• 在 main 函数中，通过 FunctionCaller<func1>::call(10) 和 FunctionCaller<func2>::call(20) 这样的方式，分别将 func1 和 func2 函数绑定到模板类的实例中并进行调用，编译器在编译阶段就能确定具体调用的是哪个函数了。

四、限制与特点

• 编译期确定值：非类型模板参数的值必须在编译阶段就能够确定，像变量（运行时才有值的）就不能作为非类型模板参数。例如，下面这种用法是错误的：

int num = 10;
template <int N = num>  // num是变量，编译阶段不能确定其值，不符合非类型模板参数要求
class ErrorClass {
    //...
};

• 类型匹配严格：传递给非类型模板参数的常量表达式类型要和模板定义中声明的参数类型严格匹配。例如，如果模板定义中声明的是非 const 类型的参数，那么传递 const 类型的常量表达式就可能会出现编译问题（取决于具体的编译器实现和上下文情况）。
• 增强代码复用性与灵活性：通过使用非类型模板参数，可以在不改变模板基本逻辑的情况下，根据不同的常量参数生成不同的模板实例，提高代码的复用程度，并且能在编译阶段进行一些特定的优化等操作，让代码更加灵活高效。

总之，非类型模板参数是 C++ 模板特性中一个很有用的部分，它在很多场景下能够帮助我们编写出更加灵活、高效且复用性强的代码。

 模板的特化

一、模板特化的概念

在 C++ 中，模板是一种强大的代码复用机制，它允许编写通用的代码，可以适用于不同类型的数据。然而，有时候对于特定的类型，通用模板的实现可能并不合适或者效率不高，这时候就可以使用模板特化（Template Specialization）。

模板特化是指针对特定的模板参数类型，为模板提供一个专门的、不同于通用模板实现的具体定义，这样在使用该特定类型实例化模板时，编译器就会采用特化版本的代码，而不是通用模板的代码。

二、函数模板特化

• 示例代码及解释：

#include <iostream>
#include <string>

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

// 针对 std::string 类型的函数模板特化
template <>
void print<std::string>(std::string value) {
    std::cout << "针对 string 类型的特化: " << value << std::endl;
}

int main() {
    int num = 10;
    std::string str = "Hello";
    print(num);  // 调用通用模板
    print(str);  // 调用针对 string 类型的特化模板
    return 0;
}

在上述代码中：

• 首先定义了一个通用的函数模板 print，它可以接受任意类型 T 的参数，并输出相应的信息。
• 接着通过 template <> 语法声明了针对 std::string 类型的特化版本。注意特化版本的函数声明中，模板参数类型要明确写在函数名后的尖括号中（如 print<std::string> ），并且函数参数的类型也要与特化的类型匹配。
• 在 main 函数中，分别用整数和字符串类型调用 print 函数，编译器会根据传入的实际参数类型来决定是调用通用模板还是特化模板。对于整数 num，调用通用模板；对于字符串 str，则调用针对 std::string 类型的特化模板。

三、类模板特化

• 示例代码及解释：

#include <iostream>
#include <string>

// 通用的类模板
template <typename T>
class MyClass {
public:
    void show() {
        std::cout << "通用类模板成员函数" << std::endl;
    }
};

// 针对 int 类型的类模板全特化
template <>
class MyClass<int> {
public:
    void show() {
        std::cout << "针对 int 类型的类模板全特化成员函数" << std::endl;
    }
};

// 主函数测试
int main() {
    MyClass<double> obj1;
    obj1.show();  // 调用通用类模板的成员函数

    MyClass<int> obj2;
    obj2.show();  // 调用针对 int 类型的类模板全特化的成员函数
    return 0;
}

在这个类模板相关的代码示例里：

• 先是定义了一个通用的类模板 MyClass，它包含了一个简单的成员函数 show，用于输出通用模板相关的提示信息。
• 然后使用 template <> 语法创建了针对 int 类型的全特化版本的 MyClass 类模板。在全特化版本中，重新定义了 show 成员函数，输出针对 int 类型特化的提示信息。
• 在 main 函数中，分别创建了 MyClass<double> 和 MyClass<int> 类型的对象，调用它们的 show 成员函数时，编译器会根据对象的具体模板参数类型来决定调用通用模板还是特化模板对应的成员函数。

四、类模板的部分特化

• 概念：与全特化不同，部分特化（Partial Specialization）是针对模板参数进行部分的限定，而不是像全特化那样完全指定具体的类型。通常用于在模板有多个参数时，对其中一部分参数进行特定情况的处理。
• 示例代码及解释：

#include <iostream>
#include <vector>

// 通用的类模板，有两个模板参数
template <typename T, typename U>
class MyTemplate {
public:
    void print() {
        std::cout << "通用类模板的 print 函数" << std::endl;
    }
};

// 部分特化，针对第二个模板参数为 std::vector 类型的情况
template <typename T>
class MyTemplate<T, std::vector<T>> {
public:
    void print() {
        std::cout << "类模板部分特化（第二个参数为 vector）的 print 函数" << std::endl;
    }
};

int main() {
    MyTemplate<int, double> obj1;
    obj1.print();  // 调用通用类模板的 print 函数

    MyTemplate<int, std::vector<int>> obj2;
    obj2.print();  // 调用类模板部分特化的 print 函数
    return 0;
}

在此示例中：

• 一开始定义了具有两个模板参数 T 和 U 的通用类模板 MyTemplate，它里面有一个 print 成员函数用于输出通用模板相关的标识语句。
• 之后定义了部分特化版本，针对第二个模板参数是 std::vector 类型（且第一个参数 T 保持为任意类型）的情况进行了特化，在这个部分特化的类中，重新实现了 print 成员函数，输出对应特化情况的标识语句。
• 在 main 函数中，分别创建不同类型组合的 MyTemplate 类对象并调用 print 成员函数，编译器会根据对象的模板参数是否符合部分特化的限定条件，来决定调用通用模板还是部分特化模板对应的函数。

总之，模板特化在 C++ 编程中是一个很重要的特性，它可以让我们根据具体的类型情况，对模板代码进行更精准、高效的实现，增强代码的灵活性和适应性。

 模板分离编译

一、什么是分离编译

在 C++ 编程中，分离编译（Separate Compilation）是一种常见的编译方式，它允许将程序的代码分散到多个源文件（.cpp 文件）和头文件（.h 或 .hpp 文件）中进行独立编译，最后再将各个编译单元生成的目标文件链接起来形成可执行程序。这样做的好处是便于代码的组织、维护以及团队协作开发等，不同的开发者可以并行地对不同的源文件进行开发和编译工作。

例如，一个大型项目可以有多个 .cpp 文件分别实现不同的功能模块，对应的 .h 文件用于声明这些模块中的函数、类等接口信息，编译器可以分别对这些源文件进行编译，之后再统一链接。

二、模板与分离编译的问题

对于普通的函数、类等代码，分离编译机制能够很好地运作。然而，模板却面临着特殊的情况，存在一些在分离编译下的问题。

模板在 C++ 中本质上是一种 “代码生成机制”，编译器需要根据模板被使用时的实际参数类型来生成对应的具体代码实例。在模板定义时，编译器并不知道会被用于哪些具体类型，所以只是记录下模板的定义框架，暂不生成具体的代码。

当采用分离编译时，如果模板的声明放在头文件（这是常见做法，方便其他源文件包含并使用模板相关内容），而模板的定义放在 .cpp 文件中，就会出现编译错误。例如：

my_template.h 头文件（模板声明部分）：

template <typename T>
class MyTemplateClass {
public:
    void func(T value);
};

 my_template.cpp 文件（模板定义部分）：

#include "my_template.h"
template <typename T>
void MyTemplateClass<T>::func(T value) {
    // 函数具体实现逻辑，比如简单的输出
    std::cout << value << std::endl;
}

main.cpp 文件（使用模板的地方）： 

#include "my_template.h"
#include <iostream>

int main() {
    MyTemplateClass<int> obj;
    obj.func(10);
    return 0;
}

在上述代码结构中，尝试对 main.cpp 文件进行编译时，编译器会报错，因为它在编译 main.cpp 这个单元时，虽然通过头文件知道了 MyTemplateClass 模板类及其 func 成员函数的声明，但在对应的 .cpp 文件中模板定义部分的代码并没有被实例化（编译器不会主动去查找并实例化那里的代码，因为它不知道具体哪些类型会使用该模板），所以找不到 MyTemplateClass<int>::func 的具体实现代码，导致链接错误。

三、解决模板分离编译问题的方法

1. 包含模板定义的头文件

最常见且简单的解决办法就是将模板的定义也放在头文件中，也就是把模板的声明和定义都放在一起，让编译器在包含头文件的每个编译单元中都能看到完整的模板信息，从而可以根据实际使用情况即时生成相应的代码实例。

修改后的代码如下：

my_template.h 头文件（模板声明与定义放在一起）：

#ifndef MY_TEMPLATE_H
#define MY_TEMPLATE_H

template <typename T>
class MyTemplateClass {
public:
    void func(T value) {
        std::cout << value << std::endl;
    }
};

#endif

main.cpp 文件（使用模板的地方）： 

#include "my_template.h"
#include <iostream>

int main() {
    MyTemplateClass<int> obj;
    obj.func(10);
    return 0;
}

这样，编译器在编译 main.cpp 文件时，通过包含 my_template.h 头文件，就能获取到完整的模板定义和声明，顺利生成 MyTemplateClass<int> 实例对应的代码，避免了链接错误。

2. 使用显式实例化声明（Explicit Instantiation Declaration）

可以在一个单独的编译单元（通常是 .cpp 文件）中使用显式实例化声明，告诉编译器针对某些特定类型提前生成模板的具体实例代码，然后在其他使用该模板的编译单元中，编译器就能找到对应的实例代码进行链接了。

示例如下：

my_template.h 头文件（模板声明部分）：

template <typename T>
class MyTemplateClass {
public:
    void func(T value);
};

my_template.cpp 文件（模板定义及显式实例化声明部分）： 

#include "my_template.h"
template <typename T>
void MyTemplateClass<T>::func(T value) {
    std::cout << value << std::endl;
}

// 显式实例化声明，针对 int 类型
template class MyTemplateClass<int>;

main.cpp 文件（使用模板的地方）： 

#include "my_template.h"
#include <iostream>

int main() {
    MyTemplateClass<int> obj;
    obj.func(10);
    return 0;
}

在 my_template.cpp 文件中，通过 template class MyTemplateClass<int>; 语句，明确指示编译器生成 MyTemplateClass 模板类针对 int 类型的实例代码，这样在编译 main.cpp 文件并链接时，就能找到对应的代码进行正确链接了。

不过这种方法需要手动对每个需要实例化的类型进行显式声明，如果模板要应用于很多不同类型，操作会相对繁琐一些。

总之，C++ 模板的分离编译需要特别注意处理方式，以确保编译器能够正确地生成和链接模板相关的代码，避免出现编译或链接错误，以上介绍的方法可以根据具体的编程场景和需求来选择使用。