C++函数模板、特例化、非类型参数、类模板、allocator

函数模板

模板对类型能进行参数化成【模板参数】，输入的是类型，生成的是代码。使用的时候，每指定一份类型，模板就会根据类型生成一份新的代码（比如函数模板实例化生成的是【模板函数】），有利于减少代码量，通过较少的代码也能实现函数重载。

调用函数模板的时候，一般通过<>传入【模板参数】，也就是【类型参数】。编译器生成相应的函数代码之后，再通过（）传入实参。

模板的实参推演：调用模板的时候可以根据用户传入的实参的类型，推导出模板类型参数的具体类型。

以下是一个简单的 C++ 函数模板案例，用于交换两个值：

#include <iostream>
// 定义一个函数模板，用于交换两个值的内容
template <typename T>// T是一个模板参数，它表示一个占位符，一个模板参数意味着一个模板需要接收一个类型。如果有多个模板参数，则需要接收多种类型。
void swapValues(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
0}

int main() {
    int x = 5, y = 10;
    double m = 3.14, n = 6.28;
    
    std::cout << "Before swapping: x = " << x << ", y = " << y << std::endl;
    swapValues<int>(x, y);//在函数调用点，编译器根据用户指定的类型，从原模板实例化一份代码出来，如果已经实例化代码了，则无需该代码实例化。再根据这个实例化的代码，传值参数。
    std::cout << "After swapping: x = " << x << ", y = " << y << std::endl;

    std::cout << "Before swapping: m = " << m << ", n = " << n << std::endl;
    swapValues(m, n);//模板的实参推演
    std::cout << "After swapping: m = " << m << ", n = " << n << std::endl;

    return 0;
}

注意：模板一般在头文件中定义，在源文件中进行#include包含使用。尽量不要在一个cpp文件中定义，在另一个cpp文件中使用。

模板特例化

函数模板特例化允许我们为特定类型或特定类型组合提供自定义的实现，以满足特殊需求或处理特定情况。

函数模板特例化与函数模板同名，于此同时也能和同名普通函数共存。

函数模板的特例化例子如下，细节是另起一个同名模板，但是关键字的使用方法有差异。

#include <iostream>
#include <cstring> // For strlen and strcpy

// 通用模板函数
template <typename T>
void swapValues(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

// 模板特化，用于交换 const char* 类型的指针
template <>
void swapValues<const char*>(const char* &a, const char* &b) {
    // 计算字符串的长度
    size_t lengthA = std::strlen(a);
    size_t lengthB = std::strlen(b);

    // 创建临时缓冲区，用于交换字符串的内容
    char* temp = new char[lengthA + 1]; // +1 是为了容纳字符串末尾的空字符 '\0'

    // 拷贝字符串内容到临时缓冲区
    std::strcpy(temp, a);
    
    // 交换字符串指针
    delete[] a; // 释放原来指针 a 指向的内存
    a = new char[lengthB + 1]; // 为 a 分配新的内存空间
    std::strcpy(const_cast<char*>(a), b); // 使用 const_cast 将 const char* 转换为 char*，然后拷贝字符串内容到 a

    delete[] b; // 释放原来指针 b 指向的内存
    b = new char[lengthA + 1]; // 为 b 分配新的内存空间
    std::strcpy(const_cast<char*>(b), temp); // 使用 const_cast 将 const char* 转换为 char*，然后拷贝字符串内容到 b
    
    // 释放临时缓冲区
    delete[] temp;
}

int main() {
    const char* str1 = "Hello";
    const char* str2 = "World";

    std::cout << "Before swapping: str1 = " << str1 << ", str2 = " << str2 << std::endl;
    swapValues(str1, str2);
    std::cout << "After swapping: str1 = " << str1 << ", str2 = " << str2 << std::endl;

    return 0;

函数模板的非类型参数

模板的非类型参数，必须是整数类型（整数或者地址/引用都可以）。只能使用，不能修改。

实际上就相当于传入了一个参数。

#include <iostream>

// 函数模板，使用非类型参数来传递一个整数常量
template <int N>
void printNumber() {
    std::cout << "The number is: " << N << std::endl;
}

int main() {
    // 使用函数模板，并传递常量值作为非类型参数
    printNumber<5>(); // 输出: The number is: 5
    printNumber<10>(); // 输出: The number is: 10

    return 0;
}

类模板

类模板的规则其实与函数模板一样，都是通过传入类型参数生成模板类代码之后再调用。

使用类模板的时候，模板名+类型参数列表才构成了模板名称。但是我们一般在构造和析构函数名的后面不加模板参数列表（比如<T>），其它出现模板名的地方都加上参数类型列表。

本人习惯先用简单的类型参数实现一个类，然后再把这个类改成类模板，

以下是一个使用整数类型的顺序栈（SeqStack）类的示例实现：

#include <iostream>
#include <vector>

class SeqStack {
private:
    std::vector<int> elements;  // 用于存储栈元素的容器

public:
    void push(const int& element) {
        elements.push_back(element);
    }

    void pop() {
        if (!elements.empty()) {
            elements.pop_back();
        }
    }

    int& top() {
        return elements.back();
    }

    bool empty() const {
        return elements.empty();
    }
};

int main() {
    SeqStack stack;

    stack.push(10);
    stack.push(20);
    stack.push(30);

    std::cout << "Top element: " << stack.top() << std::endl;

    stack.pop();

    std::cout << "Top element after pop: " << stack.top() << std::endl;

    if (stack.empty()) {
        std::cout << "Stack is empty." << std::endl;
    } else {
        std::cout << "Stack is not empty." << std::endl;
    }

    return 0;
}

要将这个类改为类模板，需要进行以下修改：

在类定义前声明类模板，指定类型参数。例如，将类名改为 template <typename T> class SeqStack。

在类内部的成员函数和成员变量声明中，使用类型参数 T 代替具体的类型。例如，将 std::vector<int> 改为 std::vector<T>。其次在类内部使用类名的地方加上<T>（比如赋值函数的返回类型，拷贝构造函数和赋值函数的参数类型）。

在类外部定义成员函数时，也需要将函数模板化，并指定类型参数 T。例如，将 void push(const int& element) 改为 template <typename T> void SeqStack<T>::push(const T& element)。

修改后的代码示例如下：

#include <iostream>
#include <vector>

template <typename T>
class SeqStack {
private:
    std::vector<T> elements;  // 用于存储栈元素的容器

public:
    void push(const T& element) {
        elements.push_back(element);
    }

    void pop() {
        if (!elements.empty()) {
            elements.pop_back();
        }
    }

    T& top() {
        return elements.back();
    }

    bool empty() const {
        return elements.empty();
    }
};

int main() {
    SeqStack<int> stack;

    stack.push(10);
    stack.push(20);
    stack.push(30);

    std::cout << "Top element: " << stack.top() << std::endl;

    stack.pop();

    std::cout << "Top element after pop: " << stack.top() << std::endl;

    if (stack.empty()) {
        std::cout << "Stack is empty." << std::endl;
    } else {
        std::cout << "Stack is not empty." << std::endl;
    }

return 0;

allocator

我们调用类模板，传入自定的类型参数，如果模板里new了这个类型参数的数组。因为new的时候会初始化一个对象，所以会调用构造函数，数组大小为1000就创建了1000个类型对象并且调用了1000次该类型的构造函数，析构的时候就调用了1000次析构函数析构该数组。

为了避免这种问题，我们在构造函数里需要把内存开辟和对象构造分开。析构数组的时候需要只用析构容器有效的元素，然后释放数组的堆内存。删除数组元素的时候调用了对象的析构函数，释放元素对象占用的外部资源，而不是仅仅通过移动头尾指针表示删除了元素。

可以借用allocator来解决上述问题。Allocator做了四件事，内存开辟/内存释放，对象构造/对象析构。

C++中allocator的用法：

#include <iostream>
#include <memory> // For std::allocator

int main() {
    // 使用std::allocator分配和释放int类型的内存
    std::allocator<int> allocator;

    // 分配单个int对象的内存
    int* p = allocator.allocate(1);

    // 在分配的内存中构造对象
    allocator.construct(p, 42);

    // 使用分配的对象
    std::cout << *p << std::endl;

    // 销毁对象
    allocator.destroy(p);

	//释放数组内存
    allocator.deallocate(p, 1);

    return 0;
}

C++的容器模板都会把空间配置器写入模板代码中，防止重复开销。