@TOC

1. 泛型编程

#include<iostream>
using namespace std;
void swap(int& a, int& b)
{
    int tmp = 0;
    tmp = a;
    a = b;
    b = tmp;
}
void swap(double& a, double& b)
{
    double tmp = 0;
    tmp = a;
    a = b;
    b = tmp;
}
int main()
{
    int a = 1;
    int b = 2;
    swap(a, b);
    double a1 = 1.0;
    double b1 = 2.0;
    swap(a1, b1);
    return 0;
}
  • 正常来说，关于不同类型的变量进行交流，需求完成不同的swap函数，这样完成有些太繁琐了
  • 为了处理类似函数的不同调用问题，C++提出泛型编程，编写与类型无关的通用代码，完成代码复用 即模板
  • 模板首要分为函数模板和类模板

2.函数模板

1.模板格局

template<typename T1, typename T2,……,typename Tn> 返回值类型 函数名(参数列表){} typename是用来界说模板参数关键字，也能够运用class，两者目前是没区别的，可是由于STL大部分用的class，所以主张运用class

2.模板原理


//泛型编程----模板
template <class T>
void swap(T& a, T& b)
{
    T tmp = a;
    a = b;
    b = tmp;
}
int main()
{
    int a = 1;
    int b = 2;
    swap(a, b);
    double a1 = 1.0;
    double b1 = 2.0;
    swap(a1, b1);
    return 0;
}
  • 想要运用swap函数交流不同类型，直接调用模板就能够了
  • 那int类型交流与double类型交流，运用是同一个swap函数吗？
【C++】模板初阶
【C++】模板初阶
  • 经过查看反汇编发现，两者调用的不是一个swap函数

【C++】模板初阶

  • 实践上调用的并不是这个模板，而是经过这个模板实例化生成的代码

3.函数模板的实例化

用不同类型的参数运用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

1.隐式实例化

实参传给形参，主动推演模板类型

template <class T>
T add(T& pa, T& pb)
{
    return pa + pb;
}
int main()
{
    int a = 1;
    int b = 2;
    double p1 = 1.0;
    double p2 = 2.0;
    //同类型进行能够正常运转
    add(a, b);//主动推演类型为int
    add(p1, p2);//主动推演类型为double
    //-----------
    addd(a, p1);//a与p1是不同类型，会报错
    return 0;
}
  • 不同类型去模板推演会出现歧义，a传过去将T推演成int，而p1传过去把T推演成double，T无法确定推演int仍是double

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.1, d2 = 20.1;
    Add(a1, a2);
    Add(d1, d2);
    cout << Add<int>(a1, d1) << endl;//显现实例化
}
  • 指定T的类型为int ，d1由于是double类型，所以在传参时会产生隐式类型转化变成int

4.模板参数的匹配准则

1.非模板和模板函数共存时

template<class T>//模板
T Add(const T& left, const T& right)
{
    return left + right;
}
int Add(const int& left, const int& right)//自己写的
{
    return left + right;
}
int main()
{
    int a1 = 10, a2 = 20;
    Add(a1, a2);
 //Add<int>(a1,a2);//显现实例化
}
  • 自己写的和模板是能够同时存在的，经过调试能够发现调用的是自己写的那个
  • 因为调用自己写的本钱更低一些，运用模板还需求实例化生成代码，而自己写的直接能够运用

2.编译器会选取相对而言最为匹配的一个进行调用

template<class T1,class T2>
T1 Add(T1 left, T2 right)
{
    return left + right;
}
template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}
int Add(const int& left, const int& right)
{
    return left + right;
}
int main()
{
    int a1 = 10;
    double a2 = 20.2;
    Add<int>(a1, a2);
}
  • 在上述的两个模板和自己完成的函数中，编译器会选取相对而言最为匹配的一个进行调用, 即调用template<class T1,class T2>这个模板来完成

3.类模板

1.界说格局

template<class T1, class T2, …, class Tn> class 类模板名 { // 类内成员界说 };

2.有typedef的存在为什么还有类模板？


typedef int STdatatype;
class stack
{
private:
    STdatatype* _a;
    size_t top;
    size_t capacity;
};
int main()
{
    stack s1;//想要S1存储int
    stack s2;//想要S2存储double
    return 0;
}
  • 假如想要改动栈贮存的类型能够挑选改动typedf界说的类型
  • 可是若想要两个栈分别贮存不同的数据类型typedef做不到
  • 两份类的代码几乎是共同的，但若想到达意图就需求再复制一份出来，就有些太繁琐了
template <class T>
class stack
{
public:
    stack(int capacity=4)
    {
        _a = new T[capacity];
        _top = 0;
        _capacity = capacity;
    }
    ~stack()
    {
        delete[]_a;
        _capacity = _top = 0;
    }
private:
    T* _a;
    size_t top;
    size_t capacity;
};
int main()
{
    stack <int>s1;//想要S1存储int
    stack <double>s2;//想要S2存储double
    return 0;
}
  • 类模板只能显现实例化，这样就能够到达s1存储int,S2存储double

3.类模板的实例化

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

// Vector类名，Vector才是类型 Vector s1; Vector s2;

4.声明和界说别离

template<class T>
class Vector
{
public:
    Vector(size_t capacity = 10)
        : _pData(new T[capacity])
        , _size(0)
        , _capacity(capacity)
    {}
    ~Vector();//析构函数类中的声明
private:
    T* _pData;
    size_t _size;
    size_t _capacity;
};
template <class T>//析构函数在类外面界说 要加上模板
Vector<T>::~Vector()
{
    detele[]_pData;
    _pData = nullptr;
    _size = _capacity = 0;
}
int main()
{
    Vector<int> v;
    return 0;
}
  • 以析构函数为例，在类里面声明，在类外面界说
  • 关于模板，vector是类名，但不是类型，加上实例化的模板参数后才是类型，如vector
  • 析构函数在类外面界说 ,需求运用类型 vector < T>，而T作为模板需求调用template < class T >