当前位置：首页 > news >正文

C++ 泛型编程，函数模版和类模版

news 2025/9/15 21:26:55

1.泛型编程

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础

就比如说活字印刷术，就是提供一个模具，然后根据模具来印刷出不同的字。

泛型编程跟着类似，提供一个模版，根据这个模版由编译器自动生成不同的函数或者类

2.函数模版

2.1为什么要有函数模版

在c语言中，我们想交换两个整数、交换两个浮点数、交换自定义类型类型，我们必须自己手动写n个函数！！！并且每个函数的函数名都不一样！！！

void SwapInt(int& a,int& b)
{int c = a;a = b;b = c;
}
void SwapDouble(double& a, double& b)
{double c = a;a = b;b = c;
}int main()
{int a1 = 1, b1 = 2;SwapInt(a1, b1);cout << a1 << " " << b1 << endl;double a2 = 1.1, b2 = 2.2;SwapDouble(a2, b2);cout << a2 << " " << b2 << endl;return 0;
}

有没有一种方法能使我们不用再写很多个函数，只用写一个函数(模版)，就能完成各个类型的交换呢？这时候函数模版就登场了

2.2怎么使用函数模版

模版格式：

template<class T1,class T2,class T3...>

返回值函数名(函数参数){ 函数体 }

template<class T>
void Swap(T &a ,T &b)
{T c = a;a = b;b = c;
}
int main()
{int a1 = 1, b1 = 2;Swap(a1, b1);cout << a1 << " " << b1 << endl;double a2 = 1.1, b2 = 2.2;Swap(a2, b2);cout << a2 << " " << b2 << endl;return 0;
}

2.3函数模版的实例化

这里我们提供的swap是仅仅只是一个函数模版而已，并不是真正的函数，用不同类型的参数使用函数模板时，需要由编译器自动生成一个相应的函数，这就叫做函数模版的实例化！！！

模版的实例化分为显示实例化和隐式实例化

2.3.1隐式实例化

由编译器识别实参类型，推导出模版参数的类型

template<class T>
void Swap(T &a ,T &b)
{T c = a;a = b;b = c;
}
int main()
{int a1 = 1, b1 = 2;Swap(a1, b1);double a2 = 1.1, b2 = 2.2;Swap(a2, b2);return 0;
}

由传进来的参数推导出T的类型，这种就叫做隐式实例化

2.3.2显示实例化

在函数名后的<>中指定所传的具体类型

template<class T>
void Swap(T &a ,T &b)
{T c = a;a = b;b = c;
}
int main()
{int a1 = 1, b1 = 2;Swap<int>(a1, b1);double a2 = 1.1, b2 = 2.2;Swap<double>(a2, b2);return 0;
}

3.类模版

3.1为什么需要有类模版

当我们需要两个栈，一个栈存int类型，一个存double类型时，我们又只能自己写两个不同的类，这两个类类名不同，但是类中除了类型，其他的都是一样的!!!

class StackInt
{
public:StackInt(int capacity = 4){_a = new int[capacity];_top = 0;_capacity = capacity;}~StackInt(){delete[] _a;_a = nullptr;_top = _capacity = 0;}
private:int* _a;int _top;int _capacity;
};
class StackDouble
{
public:StackDouble(int capacity = 4){_a = new double[capacity];_top = 0;_capacity = capacity;}~StackDouble(){delete[] _a;_a = nullptr;_top = _capacity = 0;}
private:double* _a;int _top;int _capacity;
};int main()
{StackInt st1;StackDouble st2;return 0;
}

这时候就需要用到我们的类模版来解决这个问题了.

3.2怎么使用类模版

模版格式：

template<class T1,class T2,class T3...>

class 类名 { 成员函数和成员变量 }；

template<class T>
class Stack
{
public:Stack(int capacity = 4){_a = new T[capacity];_top = 0;_capacity = capacity;}~Stack(){delete[] _a;_a = nullptr;_top = _capacity = 0;}
private:T* _a;int _top;int _capacity;
};int main()
{Stack<int> st1;Stack<double> st2;return 0;
}