C++ 模版初阶

目录

泛型编程​编辑

函数模版

1.概念

2.格式

3.函数模版实例化

3.模版参数匹配原则

类模版

---

泛型编程

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

函数模版

1.概念

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

2.格式

template<typename T1, typename T2,......,typename Tn>

返回值类型 函数名(参数列表){}

 template<typename T>
 //template<class T>等价
 ​
 void Swap( T& left, T& right)
 {
  T temp = left;
  left = right;
  right = temp;
 }
 int main()
 {
     int a = 1, b = 2;
     Swap(a, b);
     double c = 1.1, d = 2.2;
     Swap(c, d);
     int* p1 = &a, *p2 = &b;
     Swap(p1, p2);
 ​
     return 0;
 }

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器

Swap(a,b)与Swap(c,d)的地址不同，

说明：编译器生成不同的适用类型，自动识别套用模版。不是调用同一个

C++ 中 swap不用自己写，套用库中的函数

 //直接使用库中的函数
 int main()
 {
     int a = 1, b = 2;
     int* p1 = &a, *p2 = &b;
     swap(a, b);
     swap(p1,p2);
     return 0;
 }
 ​

 ​

3.函数模版实例化

1. 隐式实例化：让编译器根据实参推演模板参数的实际类型
    

    template<class T>
    T Add(const T& left, const T& right)
    {
     return left + right;
    }
    int main()
    {
        int a = 0, b = 1;
        double c = 1.1, d = 2.2;
        Add(a, b);
        Add(c, d);
        //两种：1. 用户自己来强制转化 2. 使用显式实例化
        cout << Add(a, (int)c) << endl;
        cout << Add((double)b, d) << endl;
        //显示实例化
        cout << Add<int>(a, c) << endl;
        cout << Add<double>(b,d) << endl;
    Add(a, (int)d);

2. 显示实例化的使用：在函数名后的<>中指定模板参数的实际类型

 template<class T>
 T* func(int a) {
     T* a = (T*)operator new (sizeof(T));
     new(p)T(a);
     return p;
 }
 class A {
 public:
     A(int a=0)
         :_a(a){}
 private:
     int _a;
 };
 int mian()
 {
     //无法根据返回类型推断类型
     //func(1);
     int* ret = func<int>(1);
     A* ret2 = func<A>(1);
     return 0;
 }

3.模版参数匹配原则

1. 都有的情况，优先匹配普通函数+参数匹配(成品+口味对)

2. 没有普通函数，优先匹配参数匹配+函数匹配(半成品+口味对)

3. 只有一个，类型转换一下也行，也可以匹配调用(口味不对，将就一下也行)

类模版

模版不建议声明和定义分离到.h 和 .cpp中，会出现链接错误，要分离也要分离在.h中

 //类模版
 template<class T>
 class Stack
     //class默认是私有
     //public公有 private私有 protected保护  
 {
 public:
         Stack(int n = 4) {
         _array = (T*)malloc(sizeof(T) * n);
         if (nullptr == _array) {
             perror("malloc fail ");
             return;
         }
         _capacity = n;
         _top = 0;
     }
 private:
     int* _array;
     size_t _capacity;
     size_t _top;
 };
 int main()
 {
     //显示实例化
     Stack<int> st1;
     Stack<double> st2;
     return 0;
 }

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。