C++中的泛型

在C++中，泛型编程是指在编写代码时不指定具体类型，而是使用通用的类型，达到代码复用和灵活性的目的。通过泛型编程的方式，我们可以编写出通用的算法和数据结构，只需要指定具体类型即可使用。

泛型函数

通过使用模板函数，我们可以实现泛型函数。下面是一个例子：

template<typename T>
T getMax(T a, T b) {
    return (a > b) ? a : b;
}

该函数接受两个类型相同的参数，并返回其中的较大值。当我们调用该函数时，编译器会自动推导出模板参数的类型。

int a = 3, b = 4;
int maxInt = getMax(a, b); //maxInt = 4

double c = 3.14, d = 2.718;
double maxDouble = getMax(c, d); //maxDouble = 3.14

泛型类

通过使用模板类，我们可以实现泛型类。假设我们想要实现一个动态数组，可以存储任意类型的值。我们可以这样定义：

template<typename T>
class DynamicArray {
private:
    T* data; //存储数据的数组指针
    int size; //数组大小
public:
    DynamicArray() {
        data = nullptr;
        size = 0;
    }
    void pushBack(T value) {
        T* newData = new T[size + 1]; //新建数组
        for (int i = 0; i < size; i++) {
            newData[i] = data[i]; //复制原有数据
        }
        newData[size++] = value; //添加新数据
        delete[] data; //删除原有数组
        data = newData; //指向新数组
    }
    T operator[](int index) const {
        if (index < 0 || index >= size) {
            throw std::out_of_range("Index out of range.");
        }
        return data[index];
    }
    int getSize() const {
        return size;
    }
    ~DynamicArray() {
        delete[] data;
    }
};

在该类中，我们使用了模板参数T来表示数组中元素的类型。在类的成员函数中，T被用作类型的声明。当我们需要实现一个存储int类型的数组时，可以这样使用：

DynamicArray<int> array;
array.pushBack(1);
array.pushBack(2);
std::cout << array[0] << array[1] << std::endl; //输出1和2

同样，当我们需要实现一个存储double类型的数组时，可以这样使用：

DynamicArray<double> array;
array.pushBack(3.14);
array.pushBack(2.718);
std::cout << array[0] << array[1] << std::endl; //输出3.14和2.718

泛型算法

在C++标准库中，提供了很多通用的算法，这些算法都是泛型的，可以用于不同类型的数据。比如，std::sort()函数可以对不同类型的数组进行排序。

std::vector<int> intVec = { 5, 2, 1, 8, 3 };
std::sort(intVec.begin(), intVec.end()); //对int类型的数组进行排序

std::vector<std::string> strVec = { "apple", "orange", "banana", "pear" };
std::sort(strVec.begin(), strVec.end()); //对string类型的数组进行排序

我们还可以自己实现泛型算法。假设我们想要统计一个数组中某个元素出现的次数，可以实现以下代码：

template<typename T>
int count(T* array, int size, T value) {
    int count = 0;
    for (int i = 0; i < size; i++) {
        if (array[i] == value) {
            count++;
        }
    }
    return count;
}

该函数接受一个指向数组第一个元素的指针，数组大小以及要计数的元素，返回这个元素在数组中出现的次数。当我们需要统计一个int类型的数组中3出现的次数时，可以这样使用：

int array[] = { 1, 2, 3, 3, 4, 5 };
int count = count(array, 6, 3); //count = 2

同样，当我们需要统计一个char类型的数组中字符'a'出现的次数时，可以这样使用：

char array[] = { 'a', 'b', 'a', 'c', 'd', 'a' };
int count = count(array, 6, 'a'); //count = 3

总结

泛型编程是C++中非常重要的概念之一，通过使用模板函数、模板类和泛型算法，我们可以更加灵活和高效的编写代码。熟练掌握泛型编程可以让我们在日常编码中更加优雅地处理各种问题，提高代码的复用率和可维护性。