C++泛型编程与模板初探

       在C++编程中，模板是一个非常强大且灵活的工具。通过模板，我们可以编写与类型无关的通用代码，提高代码的复用性和可维护性。本文将从初学者的角度详细介绍函数模板和类模板，帮助你更好地理解和使用模板编程。

1. 为什么需要模板？

       在编写程序时，我们常常需要处理不同类型的数据。如果我们每种类型都写一个函数，不仅繁琐，而且容易出错。模板可以帮助我们避免这些问题。

       举个例子，假设我们要写一个交换两个变量值的函数。对于不同的数据类型，我们可以写多个重载函数：

void Swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

void Swap(double& a, double& b) {
    double temp = a;
    a = b;
    b = temp;
}

void Swap(char& a, char& b) {
    char temp = a;
    a = b;
    b = temp;
}

       这样做的缺点是，每增加一种数据类型，我们都需要写一个新的函数。而且，如果函数逻辑发生变化，我们需要修改多个地方。这时，模板就派上用场了。

2. 泛型编程

       泛型编程是一种编写与类型无关的通用代码的方法。通过使用模板，可以避免编写重复的代码，并且可以轻松地扩展代码以支持新类型。

例如，我们要实现一个交换函数：

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}

void Swap(double& left, double& right)
{
    double temp = left;
    left = right;
    right = temp;
}

void Swap(char& left, char& right)
{
    char temp = left;
    left = right;
    right = temp;
}

       上述代码虽然可以实现交换功能，但每增加一种新类型，都需要新增一个对应的函数，这样既繁琐又容易出错。使用函数模板可以解决这一问题。

3. 函数模板

      函数模板代表了一个函数家族，与类型无关，在使用时被参数化，根据实参类型产生特定类型版本的函数。

3.1 函数模板概念

      函数模板是编译器用来生成具体类型函数的模具。它不是一个函数，而是在编译时根据实参类型生成特定类型的函数。

template<typename T>
void Swap(T& left, T& right)
{
    T temp = left;
    left = right;
    right = temp;
}

3.2 函数模板实例化

       使用不同类型的参数调用函数模板时，编译器会根据实参类型生成对应类型的函数，这个过程称为模板实例化。模板实例化分为隐式实例化和显式实例化。

隐式实例化：

template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}

int main()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    Add(a1, a2);
    Add(d1, d2);
    return 0;
}

显式实例化：

int main(void)
{
    int a = 10;
    double b = 20.0;
    Add<int>(a, b);
    return 0;
}

3.3 模板参数的匹配原则

1. 一个非模板函数和一个同名的函数模板可以同时存在，并且函数模板可以被实例化为这个非模板函数。
2. 如果其他条件都相同，在调用时会优先调用非模板函数，而不会从模板产生一个实例。
3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

   int Add(int left, int right)
   {
       return left + right;
   }
   
   template<class T>
   T Add(T left, T right)
   {
       return left + right;
   }
   
   void Test()
   {
       Add(1, 2);       // 与非模板函数匹配，编译器不需要特化
       Add<int>(1, 2);  // 调用编译器特化的Add版本
   }
   

4. 类模板

      类模板是用来生成一系列类的模具。类模板实例化时，编译器根据提供的模板参数生成特定类型的类。

4.1 类模板的定义格式

template<class T1, class T2, ..., class Tn>
class 类模板名
{
    // 类内成员定义
};

4.2 类模板的实例化

       类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中。

template<typename T>
class Stack
{
public:
    Stack(size_t capacity = 4)
    {
        _array = new T[capacity];
        _capacity = capacity;
        _size = 0;
    }
    void Push(const T& data);

private:
    T* _array;
    size_t _capacity;
    size_t _size;
};

template<class T>
void Stack<T>::Push(const T& data)
{
    _array[_size] = data;
    ++_size;
}

int main()
{
    Stack<int> st1;    // int
    Stack<double> st2; // double
    return 0;
}

       通过函数模板和类模板，泛型编程使得代码更加灵活、可复用，并且大大减少了重复代码的编写，提高了代码的可维护性。在实际编程中，掌握并灵活运用模板技术，将会使开发工作事半功倍。