c++ 模板详解

• 模板就是将类型进行参数化

函数模板

//函数模板的定义格式
template<class 形参名,class 形参名...>
返回值类型 函数名(参数列表){
    函数体;
}

• 模板形参不能为空，并且函数模板中每一个类型参数在函数参数表中至少使用一次，只有这样才能推断出具体的类型

template <class T>
T Add(T x1, T x2){
    return x1+x2;
}

int main(){
    cout<2,3)<<endl;//5
    cout<3.2,1.4)<<endl;//4.6
    return 0;
}

函数模板实例化

• 不能直接使用函数模板实现具体操作，必须对模板进行实例化，即将模板参数实例化，就是用具体的类型参数去替换函数模板中的模板参数，生成一个确定的具体类型的真正函数，才能实现运算操作

• 实例化方式

  • 隐式实例化：根据具体的函数调用形式，推演出模板参数类型
  • 显式实例化：通过显式声明形式指定模板参数类型

• 隐式实例化

  • 上述代码中调用Add(2,3)的过程

  • 编译器根据传入的实参2和3推断出模型形参类型是int

  • 会将函数模板实例化出一个int类型的函数

  • int Add(int x1,int x2){
        return x1+x2;
    }
    

  • 编译器生成具体类型函数的过程称为实例化，生成的函数称为模板函数

  • 生成int类型的函数后，再将2和3传入进行计算

  • 当调用Add(3.2,1.4)又会生成一个float的函数

  • 每次调用都会根据不同的类型实例化出不同类型的函数，所以最终可执行程序的大小和重载方式相比并不会减少，只是提高了程序员对代码的复用

  • 问题：隐式实例化不能为同一个模板形参指定两种不同的类型，例如Add(2,3.2)，此时编译器会报错，因为编译器不能推断出T的类型

• 显式实例化

  • cout<int>(2,3.2)<<endl;//5  cout << Add(2, static_cast(3.2)) << endl;最好的方式是进行一个显式转换
    cout<float>(3,2)<<endl;//5
    

• 函数模板也可以进行重载

template <class T>
T Add(T x1, T x2){
    return x1+x2;
}

template <class T>
T Add(T x1, T x2, T x3){
    return x1 + x2 + x3;
}

int main(){
    cout<2,3)<<endl;//5
    cout<3.2,1.4)<<endl;//4.6
    cout<int>(2,3.2)<<endl;//5  cout << Add(2, static_cast(3.2)) << endl;最好的方式是进行一个显式转换
    cout<float>(3,2)<<endl;//5
    cout<1,2,3)<<endl;//6
    return 0;
}

• 当模板函数和自己写的Add具有具体的int类型的函数而言，此时如果传入的参数是int则会调用具体化的int函数，即C++编译器优先考虑普通函数

类模板

//类模板定义格式
template <class 形参名, class 形参名>
class 类名{
    
}

• 由于类模板包含类型参数，因此也称为参数化类，如果说类是对象的抽象，对象是类的实例，则类模板是类的抽象，类是类模板的实例

template <class T1, class T2>
class Add{
private:
    T1 x1;
    T2 x2;
public:
    Add(T1 x1, T2 x2):x1(x1),x2(x2){}
    T1 get(){
        return x1 + x2;
    }
};

int main(){
    Add<double,int> a(1.2,2);
    cout<endl;//3.2
    return 0;
}

类模板实例化

• 使用类模板创建对象时，必须指明具体的数据类型，这和函数模板不一样，这是因为函数模板中一定会传递实参，可以根据实参推断出所有的数据类型，但是类模板中，构造函数时不一定会同时传递T1 T2,所以不一定会百分百推断出数据类型，因此需要显式传递
• 可以使用对象指针进行实例化Add *p1 = new Add(1.2,2);但是需要注意两边的模板参数需要相同

template <class T>
class A{
public:
    T Add(T t1, T t2){
        return t1 + t2;
    }
};

int main(){
    A<int> a;
    cout<1.2,2)<<endl;
}

• 在函数模板中，不能进行自动转换，这是因为函数模板中需要根据实参来推断数据类型，而在类模板中，因为已经显式指定了int,所以会创建一个int的类，然后可以自动转换

• 在类模板外定义成员函数,格式

template <模板形参表>
函数返回类型 类名<模板形参名>::函数名(参数列表){}

template <class T>
class A{
public:
    T Add(T t1, T t2){
        return t1 + t2;
    }
    T sub(T t1, T t2);
};

template<class T>
T A::sub(T t1, T t2) {
    
}

• 类模板在实例化时，带有模板形参的成员函数并不对着自动被实例化，只有当它被调用或取地址时才会被实例化。因为不被调用的时候，你根本不知道模板形参表中的数据类型是什么，想实例化就需要把所有的数据类型组合都实例化一遍，这显然是不可接受的

类模板与友元函数

非模板友元函数

• 在类模板中声明一个普通的友元函数，该函数时类模板所有实例的友元函数，可以访问全局对象，也可以使用全局指针访问非全局对象，可以创建自己的对象，也可以访问独立于对象模板的静态数据成员

#include 

using namespace std;

template <class T>
class A{
private:
    T x1,x2;
    static T x3;
public:
    A(T x1,T x2):x1(x1),x2(x2){}
    friend void func();
};
//这里进行特化赋值
template<>
int A<int>::x3 = 10;

template<>
double A<double>::x3 = 100;


void func(){
    cout<int>::x3<<endl;//10
    cout<double>::x3<<endl;//100
    A<char> a('A','a');
    cout<" "<endl;//A a
}

int main(){
    func();
    return 0;
}

• 如果func()中有一个特定类型的参数，则只能访问特定类型的数据

#include 

using namespace std;

template <class T>
class A{
private:
    T x1,x2;
    static T x3;
public:
    A(T x1,T x2):x1(x1),x2(x2){}
    friend void func(A a1);
};
//这里进行特化赋值
template<>
int A<int>::x3 = 10;

template<>
double A<double>::x3 = 100;


void func(A<int> b){
    cout<int>::x3<<endl;//10
//    cout<::x3<
    A<char> a('A','a');//可以正常创建别的类型的对象，因为这个创建是在任何地方都可以
//    cout<
}

int main(){
    func(A<int>(1,2));
    return 0;
}

约束模板友元函数

• 这样的友元函数本身就是一个函数模板，但其实例化类型取决于类被实例化时的类型（被约束），每个类的实例化都会产生一个与之匹配的具体化的友元函数

#include 

using namespace std;

template <class T>
void func(T x1, T x2);

template <class T>
class A{
private:
    T x1,x2;
public:
    A(T x1, T x2):x1(x1),x2(x2){}
    friend void func(T x1,T x2);//这里也可以写成friend void func<>(T x1, T x2);因为可以推断出T的类型来
};

template <class T>
void func(T x1,T x2){
    A a1(x1,x2);
    cout<" "<endl;
    cout<<sizeof(A)<<endl;
}

int main(){
    func(1,2);//1 2      8
    func<double>(1,2);// 1 2     16

}

非约束模板友元函数

• 在类内部声明友元函数模板，友元函数的模板形参与类模板的形参没有关系，此时友元函数为类模板的非约束模板友元函数

#include 

using namespace std;

template <class T>
void func(T x1, T x2);

template <class T>
class A{
private:
    T x1,x2;
public:
    A(T x1, T x2):x1(x1),x2(x2){}

    template
    friend void func(U u, V v);
};

template <class U, class V>
void func(U u, V v){
    cout<endl;
    cout<endl;
}

int main(){
    A<int> a1(1,2);
    A<double> a2(2.3,4.5);
    func(a1,a2);//1  2.3
}

模板的特化

• 模板特化：在原模板类的基础上，针对特殊类型所进行的特殊化的实现，分为函数模板特化和类模板特化

类模板特化

• 类模板的特化分为全特化和偏特化
  • 全特化：对类模板参数列表的类型全部都确定
  • 偏特化：对类模板的参数列表中的部分参数进行确定化。分为部分特化和参数进一步限制

#include 

using namespace std;


template <class A, class B>
class C{
public:
    C(){
        cout<<"template class C"<<endl;
    }
};

//全特化
template <>
class C<int,double>{
public:
    C(){
        cout<<"template<> class C"<<endl;
    }
};

//偏特化
template <class A>
class C<A,int>{
public:
    C(){
        cout<<"template class C"<<endl;
    }
};

//偏特化不一定指的是特化部分参数，而是对模板类型的进一步限制
template <class A, class B>
class C<A*,B*>{
public:
    C(){
        cout<<"template class C"<<endl;
    }
};

int main(){
    C<int,int> c1;//template class C
    C<double,double> c2;//template class C
    C<int,double> c3;//template<> class C
    C<int*,double> c4;//template class C
    C<int*,double*> c5;//template class C
}

函数模板特化

• 函数模板只支持全特化，不支持偏特化

#include 

using namespace std;

template <class T1,class T2>
int compare(const T1& v1, const T2& v2){
    cout<<"template "<<endl;
    return 0;
}

template <>
int compare<int,int>(const int& v1, const int& v2){
    cout<<"template<>"<<endl;
    return 0;
}

//不支持偏特化
//template 
//int compare(const T1& v1, const int& v2){
//    cout<<"template"<
//    return 0;
//}

int main(){
    compare(1,1);//template<>
    compare(1.2,2.3);//template 
}

• 但是函数偏特化的功能也不是不能实现，并且有两种方式进行实现

//方式1
//将第二个参数为int的情况排除掉
//然后再写一个专门的一个参数的模板，这样可以实现函数模板的功能
#include 
#include 

template 
typename std::enable_ifstd::is_sameint>::value>::type f(A a, B b) {
    std::cout << "template " << std::endl;
}

template 
void f(A a, int b) {
    std::cout << "template " << std::endl;
}

int main() {
    f(10, 5);  // template 
    f(10, 5.5);  // template 
    return 0;
}

//方式2
//使用结构体进行封装
#include 

using namespace std;

template<class A,class B>
struct C{
    C(A a,B b){}
    void operator()() {
        std::cout << "template" << std::endl;
    }
};
template 
struct C<A,int>{
    C(A a,int b){}
    void operator()() {
        std::cout << "template " << std::endl;
    }
};

int main(){
    C<int,int>(10,5)();//template 
    C<int,double>(10,5.5)();//template
    return 0;
}