广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > 其他教程 >一篇文章带你了解C++模板编程详解
  • 1008

0
分享到

一篇文章带你了解C++模板编程详解

2024-04-02 19:04:59 1008人浏览 薄情痞子
摘要

目录模板初阶泛型编程函数模板函数模板概念函数模板格式函数模板的原理函数模板的实例化模板参数的匹配原则类模板类模板的定义格式类模板的实例化总结模板初阶 泛型编程 在计算机程序设计领域

模板初阶

泛型编程

在计算机程序设计领域，为了避免因数据类型的不同，而被迫重复编写大量相同业务逻辑的代码，人们发展的泛型及泛型编程技术。什么是泛型呢？实质上就是不使用具体数据类型（例如 int、double、float 等），而是使用一种通用类型来进行程序设计的方法，该方法可以大规模的减少程序代码的编写量，让程序员可以集中精力用于业务逻辑的实现。泛型也是一种数据类型，只不过它是一种用来代替所有类型的“通用类型”

我们通常如何实现一个通用的交换函数呢？


void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}
void Swap(double& left, double& right)
{
    double temp = left;
    left = right;
    right = temp;
}
void Swap(char& left, char& right)
{
    char temp = left;
    left = right;
    right = temp;
}
......

Swap函数能实现各种类型的变量交换，但是只要类型不同就需要重新写一个

使用函数重载虽然可以实现，但是有一下几个不好的地方：

  • 重载的函数仅仅只是类型不同，代码的复用率比较低，只要有新类型出现时，就需要增加对应的函数
  • 代码的可维护性比较低，一个出错可能所有的重载均出错，那能否告诉编译器一个模版，让编译器根据不同的类型利用该模版来生成代码呢？

可以的，c++语法中有了模板：

函数模板

函数模板概念

所谓函数模板，实际上是建立一个通用函数，它所用到的数据的类型（包括返回值类型、形参类型、局部变量类型）可以不具体指定，而是用一个虚拟的类型来代替（实际上是用一个标识符来占位），等发生函数调用时再根据传入的实参来逆推出真正的类型。 这个通用函数就称为 函数模板（Function Template） 。函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

函数模板格式

template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表){}


template<typename T>
//或者 template<class T>
void Swap(T& x1, T& x2)
{
    T temp = left;
    left = right;
    right = temp;
}

T1，T2等等是什么类型现在也不确定，一会用的时候才能确定

注意：

typename是用来定义模板参数关键字，也可以使用class

函数模板的原理

函数模板本身并不是函数，是编译器根据调用的参数类型产生特定具体类型函数的模具，所以其实模板就是将本来应该我们做的重复的事情交给了编译器，我们看下面的例子：


template<class T>
void Swap(T& x, T& y)
{
	T temp = x;
	x = y;
	y = temp;
}
int main()
{
	int a = 1;
	int b = 2;
	Swap(a, b);
	char A = 'a';
	char B = 'b';
	Swap(A,B);
	return 0;
}

image-20211024163521112

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然
后产生一份专门处理int类型的代码，对于字符类型也是如此。

然而当我们在写了函数时，不会进入模板函数里，没有写具体的函数时，就会进入模板函数里，我们看下面的例子：


void Swap(int& x, int& y)
{
	int temp = x;
	x = y;
	y = temp;
}
template<class T>
void Swap(T& x, T& y)
{
	T temp = x;
	x = y;
	y = temp;
}
int main()
{
	int a = 1;
	int b = 2;
	Swap(a, b);
	char A = 'a';
	char B = 'b';
	Swap(A,B);
	return 0;
}

我们进行调式：

模板

我们可以看到int类型的交换函数我们写了，调用时调用的是我们写的，而char类型的我们没写，就用了模板。

那么这里调用的是模板函数吗？

不是的，实际上这里会有两个过程

1、模板推演，推演T的具体类型是什么

2、推演出T的具体类型后实例化生成具体的函数

上面的代码实例化生成了下面的函数：


void Swap(char& x, char& y)
{
	char temp = x;
	x = y;
	y = temp;
}

真正调用的还是两个函数，但是其中的一个函数不是我们自己写的，而是我们给了编译器一个模板，然后编译器进行推演在编译之前实例化生成三个对应的函数，模板是给编译器用的，编译器充当了写函数的工具：

image-20211024161726234

可以看到这里是调用了Swap<char>函数

在C++当中，其实内置类型也可以像自定义类型那样这样初始化：


int a(1);
int(2);//匿名

image-20211024162224522


void Swap(T& x1, T& x2)
{
    T temp(x1);
    x1 = x2;
    x2 = x1;
}

所以模板还可以这样写，可以使内置类型和自定义类型兼容：


void Swap(T& x1, T& x2)
{
    T temp(x1);
    x1 = x2;
    x2 = x1;
}

我们来具体看一看函数模板的实例化：

函数模板的实例化

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

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


template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    Add(a1, a2);
    Add(d1, d2);
// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
    Add(a1, d2);
    return 0;
}

该语句是不能够通过编译的，因为在编译期间，当编译器看到该实例化时，用a1去推T是int，而用d2去推是double，但是模板参数列表里只有一个T，编译器不能明确该T是int还是double，T是不明确的，所以编译器会报错

那么怎么处理呢？

解决方式：

1、调用者自己强制转换


//实参去推演形参的类型
Add(a1, (int)d2);
Add((double)a1,d2);

这里可以将d2先强制类型转换，然后再进行推演；或者将a1先强制类型转换再进行推演

2、使用显式实例化


//实参不需要去推演形参的类型，显式实例化指定T的类型
Add<int>(a1, d2);
Add<double>(a1,d2);

这种方式是显式实例化指定T的类型

显式实例化在哪种场景可用呢？看下面的这种场景：


class A
{
    A(int a=0):_a(a)
    {}
private:
    int _a;
};
template<class T>
T func(int x)
{
    T a(x);
    return a;
}
int main()
{
    func<A>(1);
    func<int>(2);
    return 0;
}

有些函数模板里面参数中没用模板参数，函数体内才有用到模板参数，此时就无法通过参数去推演T的类型，这时只能显示实例化

上面我们提了一点模板参数的匹配原则，下面我们具体看看模板参数的匹配原则：

模板参数的匹配原则

 一个非模板函数可以和一个同名的函数模板同时存在，此时如果调用地方参数与非模板函数完全匹配，则会调用非模板函数


int Add(int left, int right)
{
	return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
	return left + right;
}
int main()
{
    Add(1,2);//调用自己的函数
    return 0;
}

Add(1,2)参数是int类型，而我们有现成的int参数的Add函数，所以有现成的就用现成的，编译器也会偷懒

那么如果我们想让这里调用必须用模板呢？显式实例化：


Add<int>(1,2);

这样编译器就强制会用模板去实例化函数

一个非模板函数可以和一个同名的函数模板同时存在，此时如果调用地方参数与非模板函数不完全匹配，则会优先使用模板实例化函数


int Add(int left, int right)
{
	return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
	return left + right;
}
int main()
{
    Add(1.1,2.2);//使用模板实例化函数
    return 0;
}

模板匹配原则总结：

有现成完全匹配的，那就直接调用，没有现成调用的，实例化模板生成，如果有需要转换类型才能匹配的函数(也就是不完全匹配)，那么它会优先选择去实例化模板生成。

优先级：

完全匹配>模板>转换类型匹配

类模板

类模板的定义格式


template<class T1, class T2, ..., class Tn>
class 类模板名
{
	//类内成员定义
};

我们来看一个类模板的使用场景：


typedef int STDateType;
class Stack
{
private:
    STDateType* _a;
    int _top;
    int _capacity;
};
int main()
{
    Stack st1;
    Stack st2;
    return 0;
}

这是我们定义的栈数据结构，我们创建了两个栈对象，但是现在st1和st2的存储数据的类型都是int，要是想转换数据类型呢？


typedef double STDateType;

我们这样就转换了，但是我们要是想st1为int，st2为double呢：


Stack st1;//int
Stack st2;//double

此时需要写多个类，名字还得不一样，如下：


typedef int STDateType1;
typedef double STDateType2;
class IntStack
{
private:
    STDateType1* _a;
    int _top;
    int _capacity;
};
class DoubleStack
{
private:
    STDateType2* _a;
    int _top;
    int _capacity;
};

这样太麻烦了，那么什么办法可以解决呢？类模板可以解决：


//类模板
template<class T>
class Stack
{
private:
    T* _a;
    int _top;
    int _capaticy;
};
int main()
{
    //类模板的使用都是显式实例化
    Stack<double> st1;
    Stack<int> st2;
    return 0;
}

注意：Stack不是具体的类，是编译器根据被实例化的类型生成具体类的模具

类模板的实例化


//类模板
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;
    }
    void Push(const T& x)
    {
        //...
    }
private:
    T* _a;
    int _top;
    int _capaticy;
};
int main()
{
    //类模板的使用都是显式实例化
    Stack<double> st1;
    Stack<int> st2;
    return 0;
}

注意：类模板的使用都是显式实例化

假设我们想类里面声明和类外面定义成员函数呢？


//类模板
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;
    }
    //假设我们想类里面声明和定义分离呢？
    void Push(const T& x);
private:
    T* _a;
    int _top;
    int _capaticy;
};
//在类外面定义
template<class T>
void Stack<T>::Push(const T& x);
{
    //...
}
int main()
{
    //类模板的使用都是显式实例化
    Stack<Treenode*> st1;
    Stack<int> st2;
    return 0;
}


//在类外面定义
template<class T>
void Stack<T>::Push(const T& x);
{
    //...
}

在类外面定义我们必须要加模板的关键字，以及需要在实现的函数前面表明域Stack<T>。普通类，类名就是类型，对于类模板，类名不是类型，类型是Stack<T>，需要写指定

注意：

模板不支持把声明写到.h，定义写到.cpp，这种声明和定义分开实现的方式，会出现链接错误

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注编程网的更多内容!

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 一篇文章带你了解C++模板编程详解

本文链接: https://www.lsjlt.com/news/156175.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • 一篇文章带你了解C++模板编程详解
    目录模板初阶泛型编程函数模板函数模板概念函数模板格式函数模板的原理函数模板的实例化模板参数的匹配原则类模板类模板的定义格式类模板的实例化总结模板初阶 泛型编程 在计算机程序设计领域...
    99+
    2022-11-12
  • 一篇文章带你了解C++智能指针详解
    目录为什么要有智能指针？智能指针的使用及原理RALLshared_ptr的使用注意事项创建多个 shared_ptr 不能拥有同一个对象shared_ptr 的销毁shared_pt...
    99+
    2022-11-12
  • 一篇文章带你了解JAVA结构化编程详情
    目录1.什么是结构化编程2.为什么要使用结构化编程?3.三大结构A. 循环结构一行代码:B. 分支结构C.重复结构4.函数（在JAVA中叫方法）总结1.什么是结构化编程 编...
    99+
    2022-11-12
  • 一篇文章带你了解C++面向对象编程--继承
    目录C++ 面向对象编程 —— 继承总结C++ 面向对象编程 —— 继承 "Shape" 基类 class Shape { public: Shape() { // 构造函数...
    99+
    2022-11-12
  • 一篇文章带你了解C++(STL基础、Vector)
    目录STL基本概念STL六大组件STL中容器、算法、迭代器容器算法迭代器初识Vector容器Vector三大遍历算法Vector存放其他数据类型 Vector容器嵌套总结S...
    99+
    2022-11-12
  • 一篇文章带你了解C++的KMP算法
    目录KMP算法步骤1：先计算子串中的前后缀数组NextC++代码：步骤2：查找子串在母串中出现的位置。总结KMP算法 KMP算法作用：字符串匹配 例如母串S = “aaagoogle...
    99+
    2022-11-12
  • 一篇文章带你了解C++中的异常
    目录异常抛出异常基本操作自定义的异常类栈解旋异常接口声明异常变量的生命周期异常的多态c++的标准异常库编写自己的异常类总结异常 在c语言中，对错误的处理总是两种方法： 1，使用整型的...
    99+
    2022-11-13
  • 一篇文章带你了解JVM内存模型
    目录1. JVM介绍 1.1 什么是JVM？1.2 JVM的优点 1.2.1 一次编写，到处运行。1.2.2 自动内存管理，垃圾回收机制。1.2.3 数组下标越界...
    99+
    2022-11-12
  • 一篇文章带你详细了解JavaScript数组
    目录一、数组的作用：二、数组的定义：1.通过构造函数创建数组2.通过字面量的方式创建数组三、数组元素四、数组长度五、数组索引（下标）六、数组注意的问题1.数组中存储的数据可以是不一样...
    99+
    2022-11-12
  • 一篇文章带你了解C/C++的回调函数
    目录函数指针概念先来看一个Hello World程序然后，采用函数调用的形式来实现用函数指针的方式来实现函数指针数组回调函数概念标准Hello World程序将它修改成函数回调样式修...
    99+
    2022-11-13
  • 一篇文章带你了解C语言操作符
    目录一、操作符分类 二、算术操作符三、移位操作符1、左移操作符 2、右移操作符2.1算术移位 2.2逻辑移位 四、位操作符 1、按位...
    99+
    2022-11-12
  • 一篇文章带你了解c++运算符重载
    目录友元函数重载：复合赋值Operator pairings自增自减运算符的重载c++20，spaceship operator总结友元函数 一种全局函数，可以在类里声明，其他地方定...
    99+
    2022-11-12
  • 一篇文章带你了解初始Spring
    目录为什么要使用SpringSpring概述Spring容器使用流程1.启动容器2.完成bean的初始化3.注册bean到容器中4.装配bean的属性bean的注册bean属性注入总...
    99+
    2022-11-12
  • 一篇文章带你了解Java SpringBoot Nacos
    目录1、什么是Nacos 1.1与eureka对比1.2与zookeeper对比1.3与springcloud config 对比 2、Spring Cloud Alibaba 套件...
    99+
    2022-11-12
  • 一篇文章带你了解Java Stream流
    目录一、Stream流引入现有一个需求：1.用常规方法解决需求2.用Stream流操作集合，获取流，过滤操作，打印输出二、Stream流的格式三、获取流四、Stream流的常用方法方...
    99+
    2022-11-12
  • 一篇文章带你了解JavaScript-对象
    目录创建对象对象直接量通过new创建对象原型Object.create（）属性的查询和设置继承属性访问错误删除属性检测属性序列化对象总结创建对象 对象直接量 对象直接量是由若干名/值...
    99+
    2022-11-12
  • 一篇文章带你了解JavaScript-语句
    目录表达式语句复合语句和空语句复合语句空语句声明语句varfunction条件语句ifif/elseelse ifswitch循环whiledo/whileforfor/in跳转标签...
    99+
    2022-11-12
  • 一篇文章带你了解XGBoost算法
    目录1. 什么是XGBoost1.1 XGBoost树的定义1.2 正则项：树的复杂度1.3 树该怎么长1.4 如何停止树的循环生成2. XGBoost与GBDT有什么不同3. 为什...
    99+
    2022-11-12
  • 一篇文章带你了解jQuery动画
    目录1.控制元素的显示与隐藏 show() hide()2.控制元素的透明度 fadeIn() fadeOut()3：控制元素的高度 slideUp() slideDown()总结 ...
    99+
    2022-11-12
  • 一篇文章带你了解vue路由
    目录概念Vue Router简介Vue Router的特性Vue Router的使用步骤分类嵌套路由动态路由命名路由编程式导航总结概念 路由的本质就是一种对应关系，比如说我们在url...
    99+
    2022-11-13
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作