C++入门——11模板进阶

1.模板参数

在 C++ 中，模板参数可以分为两大类：类型模板参数和非类型模板参数。了解这些模板参数的分类及其用法有助于编写更灵活和可复用的模板代码。

1.1. 类型模板参数（Type Template Parameters）

类型模板参数用于指定模板中的类型。通常用于类模板或函数模板中，以实现对多种类型的支持。

template <typename T>  // 或者 template <class T>
class MyClass {
    T value;
public:
    MyClass(T v) : value(v) {}
    T getValue() const { return value; }
};

template <typename T>
T add(T a, T b) {
    return a + b;
}


MyClass<int> intObject(5);         // 使用 int 类型实例化模板
MyClass<double> doubleObject(3.14); // 使用 double 类型实例化模板

int result = add(10, 20);  // 使用 int 类型实例化函数模板
double result = add(2.5, 3.5);  // 使用 double 类型实例化函数模板

1.2. 非类型模板参数（Non-Type Template Parameters）

非类型模板参数用于指定模板中的值或常量。这些参数在编译时确定，并且可以是整型、指针、引用、或枚举类型。

template <int N>
class Array {
    int arr[N];
public:
    Array() {
        for (int i = 0; i < N; ++i) {
            arr[i] = i;
        }
    }
    int getValue(int index) const { return arr[index]; }
};

template <typename T, int size>
void printArray(T (&arr)[size]) {
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}


Array<5> myArray;  // 使用 5 作为非类型模板参数实例化 Array 类
std::cout << myArray.getValue(3) << std::endl;

int arr[] = {1, 2, 3, 4, 5};
printArray(arr);  // size 为非类型模板参数，自动推导为 5

1.3非类型模板参数的限制

• 非类型模板参数必须是编译时常量。
• 它们可以是整型、枚举、指针、引用，但不能是浮点数或类类型。

2.模板的特化

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，比如：

template<class T>
bool IsEqual(const T& left, const T& right)
{
    return left == right;
}


// 函数模板的特化 （针对某些类型的特殊化处理）
//bool IsEqual(const char* const & left,const char* const & right)
bool IsEqual(const char* left, const char* right)
{
    return strcmp(left, right) == 0;
}

int main()
{
    cout << IsEqual(1, 2) << endl;
    char p1[] = "hello";
    char p2[] = "hello";
    cout << IsEqual(p1, p2) << endl;;
    return 0;
}

在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

2.1函数模板特化

函数模板的特化步骤：

1.  必须要先有一个基础的函数模板
2.  关键字template后面接一对空的尖括号<>
3.  函数名后跟一对尖括号，尖括号中指定需要特化的类型，为了实现简单通常都是将该函数直接给出。
4.  函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误

#include <iostream>

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


/*
template <int>
void print(int value) {
    std::cout << "Generic template: " << value << std::endl;
}
*/


// 为了实现简单通常都是将该函数直接给出
void print(int value) {
    std::cout << "Specialized template for int: " << value << std::endl;
}


int main() {
    print(3.14);  // 输出: Generic template: 3.14
    print(10);    // 输出: Specialized template for int: 10

    return 0;
}

2.2 类模板特化

2.2.1类模板全特化

全特化即是将模板参数列表中所有的参数都确定化。

template<class T1, class T2>
class Data
{
public:    
    Data() {cout<<"Data<T1, T2>" <<endl;}
private:
    T1 _d1;
    T2 _d2;
};

template<>
class Data<int, char>
{
public:
    Data() {cout<<"Data<int, char>" <<endl;}
private:
    int _d1;
    char _d2;
};

void TestVector()
{
    Data<int, int> d1;
    Data<int, char> d2;
}

2.2.1类模板偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。

• 部分特化:将模板参数类表中的一部分参数特化。

template<class T1, class T2>
class Data
{
public:
    Data() {cout<<"Data<T1, T2>" <<endl;}
private:
    T1 _d1;
    T2 _d2;
};

// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
    Data() {cout<<"Data<T1, int>" <<endl;}
private:
    T1 _d1;
    int _d2;
};

• 参数更进一步的限制:偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
    Data() {cout<<"Data<T1*, T2*>" <<endl;}
private:
    T1 _d1;
    T2 _d2;
};

//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:
    Data(const T1& d1, const T2& d2)
        : _d1(d1)
        , _d2(d2)
    {
        cout<<"Data<T1&, T2&>" <<endl;
    }
private:
    const T1 & _d1;
    const T2 & _d2;
};

void test2 ()
{
    Data<double , int> d1; // 调用特化的int版本
    Data<int , double> d2; // 调用基础的模板
    Data<int *, int*> d3; // 调用特化的指针版本
    Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}

3.模板分离编译

模板分离编译是指将模板的声明和定义分开，在不同的文件中进行编写和编译。这在 C++ 中是一个复杂且不常见的操作，因为模板在编译时需要知道所有的定义才能进行实例化。模板分离编译有几种常见的方法，每种方法都有其特点和适用场景。

3.1. 将模板的声明与定义放在同一个头文件

这是最常见的做法，将模板的声明和定义都放在同一个头文件中，所有需要使用模板的源文件都可以通过包含该头文件来实例化模板。

// MyTemplate.hpp
#ifndef MY_TEMPLATE_H
#define MY_TEMPLATE_H

template <typename T>
class MyTemplate {
public:
    MyTemplate(T val);
    T getValue() const;

private:
    T value;
};

template <typename T>
MyTemplate<T>::MyTemplate(T val) : value(val) {}

template <typename T>
T MyTemplate<T>::getValue() const {
    return value;
}

#endif // MY_TEMPLATE_H

在这个例子中，模板的声明和定义都在 MyTemplate.h 文件中。每个包含这个头文件的源文件都可以直接使用模板。

3.2. 在头文件中声明模板，在实现文件中定义

这种方法将模板的声明放在头文件中，将定义放在 .cpp 文件中，然后在头文件中通过 #include 包含实现文件。

// MyTemplate.h
#ifndef MY_TEMPLATE_H
#define MY_TEMPLATE_H

template <typename T>
class MyTemplate {
public:
    MyTemplate(T val);
    T getValue() const;

private:
    T value;
};

#include "MyTemplate.cpp"  // 包含实现文件

#endif // MY_TEMPLATE_H

// MyTemplate.cpp
#include "MyTemplate.h"

template <typename T>
MyTemplate<T>::MyTemplate(T val) : value(val) {}

template <typename T>
T MyTemplate<T>::getValue() const {
    return value;
}

 

这种方法虽然看似将定义放在了 .cpp 文件中，但由于在头文件中包含了 .cpp 文件，编译器在每次包含头文件时仍然会看到完整的模板定义，因此这并不是真正的分离编译。

3.3. 显式实例化

要实现真正的分离编译，可以使用显式实例化。即在 .cpp 文件中显式地实例化模板的某些特定类型。

// MyTemplate.h
#ifndef MY_TEMPLATE_H
#define MY_TEMPLATE_H

template <typename T>
class MyTemplate {
public:
    MyTemplate(T val);
    T getValue() const;

private:
    T value;
};

// 声明将进行显式实例化
extern template class MyTemplate<int>;

#endif // MY_TEMPLATE_H

// MyTemplate.cpp
#include "MyTemplate.h"

template <typename T>
MyTemplate<T>::MyTemplate(T val) : value(val) {}

template <typename T>
T MyTemplate<T>::getValue() const {
    return value;
}

// 对int类型进行显式实例化
template class MyTemplate<int>;

在这个例子中，MyTemplate<int> 的实例化只会在 MyTemplate.cpp 中进行，因此其他文件只需要包含头文件即可使用 MyTemplate<int>，而无需看到模板的完整定义。这种方法减少了重复编译，提高了编译效率。

3.4. 将定义放在实现文件中

另一种方法是将模板的定义完全放在 .cpp 文件中，但这种方法需要在 .cpp 文件中显式地实例化所有需要使用的模板类型。

// MyTemplate.h
#ifndef MY_TEMPLATE_H
#define MY_TEMPLATE_H

template <typename T>
class MyTemplate {
public:
    MyTemplate(T val);
    T getValue() const;

private:
    T value;
};

#endif // MY_TEMPLATE_H

// MyTemplate.cpp
#include "MyTemplate.h"

template <typename T>
MyTemplate<T>::MyTemplate(T val) : value(val) {}

template <typename T>
T MyTemplate<T>::getValue() const {
    return value;
}

// 显式实例化需要的类型
template class MyTemplate<int>;
template class MyTemplate<double>;

在这种方法中，只有在 MyTemplate.cpp 文件中显式实例化的模板类型才能被使用。

4.模板优缺点

4.1优点

1. 代码重用：模板允许你编写一次代码，并在不同的数据类型上进行实例化，从而提高了代码的重用性和维护性。

2. 类型安全：模板在编译时进行类型检查，可以防止许多类型相关的错误，从而提高了程序的安全性。

3. 性能优化：由于模板的实例化是在编译时完成的，编译器可以进行更多的优化（如内联），从而提高运行时性能。

4. 泛型编程：模板支持泛型编程，允许你编写可以适用于不同类型的算法和数据结构，使得程序更加灵活和可扩展。

5. 简化代码：通过使用模板，你可以避免编写大量重复的代码，简化了代码结构。

4.2缺点

1. 编译时间增加：模板的实例化可能会导致编译时间显著增加，因为编译器需要为每个不同的模板实例生成代码。

2. 代码膨胀：模板的实例化可能会导致代码膨胀，因为每个不同的模板实例会生成独立的代码。如果模板实例化过多，可能会增加二进制文件的体积。

3. 错误信息难以理解：模板的错误信息通常比较复杂且难以理解，这可能使得调试和错误排查变得更加困难。

4. 运行时开销：虽然模板本身在编译时进行优化，但在某些情况下，模板使用不当可能会导致运行时开销，如内存占用或不必要的类型转换。

5. 代码复杂性：过度使用模板可能会导致代码变得复杂和难以阅读，尤其是当模板嵌套或结合使用时。