（六）C++的函数模板与类模板

在C++中，模板（Templates）是一种强大的泛型编程工具，它允许程序员编写可重用的代码，而无需为每种数据类型编写重复的代码。模板分为函数模板（Function Templates）和类模板（Class Templates），它们分别用于生成函数和类的通用版本。以下是对函数模板和类模板的详细介绍，包括其定义、语法、实现方式、示例以及注意事项。

一.函数模板

函数模板是定义一组函数的蓝图或公式，这些函数在逻辑上执行相同的操作，但可以处理不同类型的数据。编译器根据函数调用时提供的参数类型，自动生成相应的函数实例。

语法

template <typename T>
ReturnType functionName(parameters) {
    // 函数实现
}

template <typename T>：声明一个模板参数T，typename也可以用class代替。
ReturnType：函数的返回类型，可以依赖于模板参数T。
functionName：函数名称。
parameters：函数参数，可以是类型T或依赖于T的类型。

实现方式
函数模板通过编译器在编译时根据调用参数的类型生成具体的函数实例。

示例:

#include <iostream>
#include <string>

// 函数模板定义
template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    int sum1 = add(3, 4); // T 被推导为 int
    double sum2 = add(2.5, 3.6); // T 被推导为 double
    std::string sum3 = add(std::string("Hello, "), std::string("World!")); // T 被推导为 std::string

    std::cout << "Sum1: " << sum1 << std::endl; // 输出: Sum1: 7
    std::cout << "Sum2: " << sum2 << std::endl; // 输出: Sum2: 6.1
    std::cout << "Sum3: " << sum3 << std::endl; // 输出: Sum3: Hello, World!
    return 0;
}

注意事项
类型推导：编译器根据函数调用时的参数类型自动推导模板参数类型。
显式指定类型：可以使用显式指定类型的方式调用函数模板，例如：add(3, 4)。
多个模板参数：函数模板可以有多个模板参数

template <typename T, typename U>
void print(T a, U b) {
    std::cout << a << ", " << b << std::endl;
}

二.类模板（Class Templates）

类模板是定义一组类的蓝图或公式，这些类在逻辑上具有相同的结构，但可以处理不同类型的数据。编译器根据类实例化时提供的类型参数，自动生成相应的类实例。

语法

template <typename T>
class ClassName {
    // 类成员
};

template <typename T>：声明一个模板参数T，typename也可以用class代替。
ClassName：类的名称。
类成员：类的成员变量和成员函数可以依赖于模板参数T。

实现方式
类模板通过编译器在编译时根据实例化时提供的类型参数生成具体的类实例

示例:

#include <iostream>
#include <vector>
#include <stdexcept>

// 类模板定义
template <typename T>
class Stack {
private:
    std::vector<T> elements;
public:
    void push(const T& elem) {
        elements.push_back(elem);
    }

    void pop() {
        if(elements.empty()) {
            throw std::out_of_range("Stack<>::pop(): empty stack");
        }
        elements.pop_back();
    }

    T top() const {
        if(elements.empty()) {
            throw std::out_of_range("Stack<>::top(): empty stack");
        }
        return elements.back();
    }

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

int main() {
    Stack<int> intStack;
    intStack.push(10);
    intStack.push(20);
    std::cout << "Top element: " << intStack.top() << std::endl; // 输出: Top element: 20

    Stack<std::string> stringStack;
    stringStack.push("Hello");
    stringStack.push("World");
    std::cout << "Top element: " << stringStack.top() << std::endl; // 输出: Top element: World

    return 0;
}

注意事项
类型参数：类模板可以有多个类型参数

template <typename T, typename U>
class Pair {
private:
    T first;
    U second;
public:
    Pair(T f, U s) : first(f), second(s) {}
    void display() const {
        std::cout << first << ", " << second << std::endl;
    }
};

默认模板参数：C++11及更高版本支持为模板参数提供默认值：

template <typename T = int>
class MyClass {
    // ...
};

模板的优势
代码重用：通过模板，可以编写通用的代码，减少重复，提高代码的可维护性。
类型安全：模板在编译时进行类型检查，确保类型安全。
灵活性：模板可以处理不同类型的数据，提供高度的灵活性。

三.String类

在C++中，String类用于处理字符串操作。虽然C++标准库提供了强大的std::string类，但在某些情况下，程序员可能需要自定义一个String类，以满足特定的需求或用于学习目的。以下是对自定义String类的详细介绍，包括其定义、成员函数、运算符重载、内存管理以及与std::string的比较。

自定义String类通常是一个封装了C风格字符串（char*）的类，提供对字符串的各种操作接口。通过封装，可以更好地管理字符串的生命周期，避免内存泄漏和悬挂指针等问题。

基本实现

#include <iostream>
#include <cstring>

class String {
private:
    char* data; // 指向字符串的指针
public:
    // 默认构造函数
    String() : data(new char[1]) {
        data[0] = '\0';
    }

    // 带参数的构造函数
    String(const char* str) {
        if(str) {
            data = new char[strlen(str) + 1];
            strcpy(data, str);
        }
        else {
            data = new char[1];
            data[0] = '\0';
        }
    }

    // 复制构造函数（深拷贝）
    String(const String& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }

    // 赋值运算符重载（深拷贝）
    String& operator=(const String& other) {
        if(this == &other)
            return *this;
        delete[] data;
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
        return *this;
    }

    // 析构函数
    ~String() {
        delete[] data;
    }

    // 获取字符串长度
    size_t length() const {
        return strlen(data);
    }

    // 打印字符串
    void display() const {
        std::cout << data << std::endl;
    }

    // 字符串连接
    String operator+(const String& other) const {
        size_t len1 = strlen(data);
        size_t len2 = strlen(other.data);
        char* temp = new char[len1 + len2 + 1];
        strcpy(temp, data);
        strcat(temp, other.data);
        String result(temp);
        delete[] temp;
        return result;
    }

    // 获取C风格字符串
    const char* c_str() const {
        return data;
    }
};