Cpp6 — 模板

列宁格勒的街头

已于 2024-03-02 17:45:35 修改

阅读量241

点赞数

分类专栏： C++ 文章标签： c++

于 2023-07-31 22:07:51 首次发布

本文链接：https://blog.csdn.net/weixin_60320290/article/details/132012399

版权

C++ 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

模板：这里有一个概念：泛型编程---针对广泛的类型去写代码编程。之前都是针对具体的类型进行编程。

模板分为函数模板和类模板。

函数模板

当我们想要使用一个swap可以用作多种类型时，可以使用模板。这样我们就可以不使用重载，不用多写一个函数。

template<>//模板参数（模板类型）--类似函数参数（参数对象）

template<typename T, class V>//typename/class是关键字，T是类型名，可以随便取，其代表一个模板类型（虚拟类型），即可以是任意类型。

模板不支持分离编译，也就是声明在.h，定义在.cpp，这样是不支持的。

template<class T>
void swap(T& x1,T& x2)
{
    T tmp = x1;
    x1 = x2;
    x2 = tmp;
}

int main()
{
    int a = 1, b = 2;
    swap(a,b);//可以
    double c = 1.1, d = 2.2;
    //编译器会通过实参推形参的类型T分别为int和double，这种方式是隐式实例化
    swap(c,d);//可以
    swap(a,c);//不可以
    return 0;
}

它们两调用的是同一个函数吗？

不是（可以看地址或汇编），它们只是类似，其实建立的栈帧、使用的指令都是不一样的。它们会在预处理阶段推演出对应代码需要的类型。

函数模板的实例化

要经历：1.模板参数推演2.推演参数实例化

在解决问题时，调用的并不是同一个函数，例如解决int类型交换、double类型交换，在底层看，两个函数的地址是不一样的。

其实标准库里有一个swap，我们可以直接使用

注意，异或针对整型可以，但是对于浮点型那些，并不好

注意如果传值传参，自定义类型是需要调用拷贝构造的。所以尽量用传引用传参。

传参之前（就会实例化，所以是在推演时报错的）

这样可以

163是T1为double，T2为int，此时发生转换，最后数据为double

164T1是int，T2为double，发生转换，最后数据位double

//推演矛盾
template<class T>

T Add(const T& left, const T& right)
{
    return left + right;
}


int main()
{
    Add(1, 2);//编译。编译器自动推演，也叫隐式实例化
    Add(1.1, 2);//报错，编译不通过，模板T不明确，传参之前的一步错了，因为传参是可以隐式类型转换的。是在推演实例化时出错的，因为不知道是该推演成double类型还是int类型
    Add((int)1.1, 2);//可以自己强制类型转换
    Add(1.1, (double)2);

    //显式实例化。不用你编译器推了，我直接指定了。
    Add<int>(1.1, 2);
    Add<double>(1.1, 2);

    return 0;
}
//上面这个问题也可以给两个模板参数



template<typename T1, typename T2>//class和typename混用也是可以的。虽然是int和double，类型不一样，但是计算时是会隐式类型转换的，加完之后虽然是double类型，但是返回值是int，所以会有一个警告
T1 Add(const T1& left, const T2& right)
{
    return left + right;
}








template<class T>
T* Func(int n)
{
    T* a = new T[n];
    return a;
}

//如果有这样一个函数，直接调用这个函数是调不成的，因为编译器无法推演出返回值，没办法指定返回值，参数是一个跟T没有关系的返回值，是一个其他类型，这种必须显示实例化才能调用
Func(10);//不行
Func<int>(10);



//下面这两个可不可以同时存在？可以，调用的时候怎么走呢？
// 专门处理int的加法函数
int Add(int left, int right) 
{
    return left + right; 
}
// 通用加法函数
template<class T>
T Add(T left, T right) 
{
    return left + right; 
}

void Test() 
{
    Add(1, 2);       // 与非模板函数匹配，编译器不需要特化 
    Add<int>(1, 2);  // 调用编译器特化的Add版本
}
//编译器编译的时候不会有那个函数模板，是先去找有没有参数类型匹配的函数，如果有，就会优先调用，如果没有，才去找函数模板去实例化一个int的。有现成的先用现成的






//那么如果是这样的呢？
template<class T>
T Add(T left, T right) 
{
    return left + right; 
}


template<class T1， class T2>
T1 Add(T1 left, T2 right) 
{
    return left + right; 
}

Add(1.1, 2.2);//是调用第一个还是第二个呢？调用第一个
Add(1.1, 2);//这个是去调第二个