C++初阶(十三) 模板

最新推荐文章于 2024-05-08 23:36:13 发布
最新推荐文章于 2024-05-08 23:36:13 发布
阅读量938 收藏 20
点赞数 16
文章标签： 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62800805/article/details/136132961
版权

一、非类型模板参数

  1. 模板参数分类类型形参与非类型形参。
  2. 类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
  3. 非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;


class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}
	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}

	friend ostream& operator<<(ostream& _cout, const Date& d);
private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}

template<class T>
bool Less(T left, T right)
{
	return left < right;
}

// //解决方法:
// //函数模板的特化
//template<>
//bool Less<Date*>(Date* left, Date* right)
//{
//	return *left < *right;
//}

bool Less(Date* left, Date* right)
{
	return *left < *right;
}

int main()
{
	cout << Less(1, 2) << endl;

	Date d1(2024, 2, 7);
	Date d2(2024, 2, 8);
	cout << Less(d1, d2) << endl; // 可以比较，结果正确

	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl; 
	/*
	 可以比较，结果错
	 因为比较的其实是 p1 和 p2 两个指针变量的地址，
	而不是它们所指向的 Date 对象的值。
	*/

	Date* p3 = new Date(2024, 2, 7);
	Date* p4 = new Date(2024, 2, 8);
	cout << Less(p3, p4) << endl;  
		/*可以比较，结果错
		* p3 和 p4 是通过 new 运算符创建的 Date* 类型的指针，
		分别指向了两个动态分配的 Date 对象。
		当你调用 Less(p3, p4) 时，实际上是在比较这两个指针的地址，
		而不是它们所指向的对象的值。
由于这两个指针指向的是动态分配的对象，
它们的地址是不确定的，因此比较结果错误。
		*/
	return 0;
}

注意：

  • 1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
  • 2. 非类型的模板参数必须在编译期就能确认结果。 

 二、模板的特化

2.1 概念

在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。

模板特化中分为函数模板特化与类模板特化。

2.2  函数模板特化

函数模板的特化步骤：

  • 1. 必须要先有一个基础的函数模板
  • 2. 关键字template后面接一对空的尖括号<>
  • 3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
  • 4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right) {
    return left < right;
}
// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right) {
    return *left < *right;
}
int main() {
    cout << Less(1, 2) << endl;
    Date d1(2024, 2, 7);
    Date d2(2024, 2, 8);
    cout << Less(d1, d2) << endl;
    Date* p1 = &d1;
    Date* p2 = &d2;
    cout << Less(p1, p2) << endl; // 调用特化之后的版本，而不走模板生成了
    return 0;
}

 

注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

函数模板的特化可以用于为特定类型提供定制的实现，从而覆盖默认的模板实现。尽管函数模板特化在某些情况下是有用的，但通常情况下，不建议频繁使用函数模板的特化。以下是一些原因：

  1. 代码复杂性增加：函数模板的特化会导致代码的维护和理解变得更加困难。每个特化版本都需要单独编写和维护，如果有多个特化版本，代码的复杂性将大大增加。

  2. 可读性和可维护性下降：特化版本的实现可能与原始模板实现不一致，这会使代码更难以理解和调试。同时，当需求变化时，特化版本可能需要相应地更新，这会增加维护的负担。

  3. 可移植性受限：特化版本可能依赖于特定的编译器行为或库支持，这会导致代码在不同的编译环境中的行为不一致。

  4. 概念耦合度增加：函数模板的特化可能会导致代码之间的紧密耦合，使得代码更难以重用和扩展。

2.3 类模板特化

2.3.1全特化

全特化即是将模板参数列表中所有的参数都确定化。

#include <iostream>
using namespace std;

// 定义模板类 Data
template<class T1, class T2>
class Data {
  public:
    Data() {
        cout << "Data<T1, T2>" << endl;
    }
  private:
    T1 _d1;
    T2 _d2;
};

// 对 Data 类进行全特化，特化为 Data<int, char>
template<>
class Data<int, char> {
  public:
    Data() {
        cout << "Data<int, char>" << endl;
    }
  private:
    int _d1;
    char _d2;
};

// 创建 Data<int, int> 和 Data<int, char> 两个对象实例
void TestVector() {
    Data<int, int> d1; 
    Data<int, char> d2; 
}

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

 

因为Data<int, int> 和 Data<int, char>是不同类型的对象，所以它们的构造函数会被分别调用。对于Data<int, int>，会调用原始模板的构造函数，输出 "Data<T1, T2>"；而对于 Data<int, char>，会调用全特化的构造函数，输出 "Data<int, char>"。

 2.3.2 偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。比如对于以下原模板类：

template<class T1, class T2>
class Data {
  public:
    Data() {
        cout << "Data<T1, T2>" << endl;
    }
  private:
    T1 _d1;
    T2 _d2;
};

 偏特化有以下两种表现方式：

  • 部分特化 将模板参数类表中的一部分参数特化。​
// 将第二个参数特化为int
template <class T1>
class Data<T1, int> {
  public:
    Data() {
        cout << "Data<T1, int>" << endl;
    }
  private:
    T1 _d1;
    int _d2;
};
  •  参数更进一步的限制

偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*> {
public:
    Data() {
        cout << "Data<T1*, T2*>" << endl;
    }

private:
    T1 _d1;
    T2 _d2;
};
// 两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data<T1&, T2&> {
public:
    Data(const T1& d1, const T2& d2)
        : _d1(d1)
        , _d2(d2) {
        cout << "Data<T1&, T2&>" << endl;
    }

private:
    const T1& _d1;
    const T2& _d2;
};
void test2() {
    Data<double, int> d1; // 调用特化的int版本
    Data<int, double> d2; // 调用基础的模板 
    Data<int*, int*> d3; // 调用特化的指针版本
    Data<int&, int&> d4(1, 2); // 调用特化的引用版本
}

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

 2.3.3 类模板特化应用示例

有如下专门用来按照小于比较的类模板Less：


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Date {
public:
    int year;
    int month;
    int day;

    Date(int year, int month, int day) : year(year), month(month), day(day) {}

    bool operator<(const Date& other) const {
        // 按年、月、日升序排序
        if (this->year == other.year) {
            if (this->month == other.month) {
                return this->day < other.day;
            }
            return this->month < other.month;
        }
        return this->year < other.year;
    }
};

template<class T>
struct Less {
    bool operator()(const T& x, const T& y) const {
        // 通过指针间接比较对象，用于排序
        return x < y;
    }
};

int main() {
    Date d1(2024, 7, 7);
    Date d2(2024, 7, 6);
    Date d3(2024, 7, 8);
    vector<Date> v1;
    v1.push_back(d1);
    v1.push_back(d2);
    v1.push_back(d3);

    // 对 vector v1 中的 Date 对象进行排序
    sort(v1.begin(), v1.end());

    // 输出排序后的结果,结果是日期升序
    for (const auto& date : v1) {
        cout << date.year << "-" << date.month << "-" << date.day << endl;
    }

    cout << "---------------------" << endl;
    vector<Date*> v2;
    v2.push_back(&d1);
    v2.push_back(&d2);
    v2.push_back(&d3);

    // 对存储 Date 指针的 vector v2 中的对象进行排序
    sort(v2.begin(), v2.end(), Less<Date*>());

    // 结果错误日期还不是升序，而v2中放的地址是升序
 // 此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象
 // 但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期

    // 输出排序后的结果
    for (const auto& ptr : v2) {
        cout << (*ptr).year << "-" << (*ptr).month << "-" << (*ptr).day << endl;
    }

    return 0;
}

通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果是正确的。但是如果待排序元素是指针,结果就不一定正确。因为：sort最终按照Less模板中方式比较，所以只会比较指针，而不是比较指针指 向空间中内容，此时可以使用类版本特化来处理上述问题：

// 对Less类模板按照指针方式特化
template<>
struct Less<Date*> {
    bool operator()(Date* x, Date* y) const {
        return *x < *y;
    }
};

三 、模板的分离编译

3.1 什么是分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链 接起来形成单一的可执行文件的过程称为分离编译模式。

 3.2 模板的分离编译

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

// a.h
template<class T>
T Add(const T& left, const T& right);
// a.cpp
template<class T>
T Add(const T& left, const T& right) {
    return left + right;
}
// main.cpp
#include"a.h"
int main() {
    Add(1, 2);
    Add(1.0, 2.0);

    return 0;
}

​

 

 

3.3 解决方法

  • 1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。
// a.hpp (或者 a.h)
template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}

// main.cpp
#include "a.hpp"

int main()
{
    Add(1, 2);
    Add(1.0, 2.0);

    return 0;
}

.hpp是一种常见的用于包含C++头文件的命名约定，和.h头文件没有本质上的区别，只是在命名上有所不同。.hpp通常用于包含C++中的类定义、模板定义等，以区分于传统的C语言风格的.h头文件。 

  •  2. 模板定义的位置显式实例化。显式实例化是一种在编译器中明确指定模板函数或类的实例化的方法。它可以用于将模板代码编译成特定类型的函数或类，以提高编译和链接的效率。这种方法不实用，主要是因为它会导致模板的定义与实例化分离，增加了代码的复杂性和维护难度。不推荐使用。
// a.h
template<class T>
T Add(const T& left, const T& right);

// a.cpp
template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}

// 显式实例化
template int Add<int>(const int& left, const int& right);
template double Add<double>(const double& left, const double& right);

// main.cpp
#include "a.h"

int main()
{
    Add(1, 2);
    Add(1.0, 2.0);

    return 0;
}

 四、模板总结

优点：

  1. 代码重用： 使用模板可以编写通用的代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生,适用于多种数据类型，避免了为每种数据类型都编写相似的代码的重复劳动。
  2. 类型安全： 模板可以提供编译期间的类型检查，从而在一定程度上提高了代码的类型安全性。
  3. 性能优化： 通过编译器根据实际使用情况生成具体的代码，可以针对特定的数据类型进行优化，提高程序的性能。
  4. 灵活性： 可以轻松地扩展模板代码以适应新的数据类型或需求，提高了代码的灵活性和可扩展性。

缺点：

  1. 编译时间： 使用模板会增加编译时间，因为模板代码通常需要在每个使用处进行实例化，导致编译时间增加。
  2. 可读性： 模板代码可能会影响代码的可读性，特别是在模板特化和元编程等高级用法中，代码可能变得晦涩难懂。
  3. 链接错误信息： 当模板代码出现问题时，可能会导致编译器产生复杂或晦涩的错误信息，对调试造成困难。​ ​

质点994
关注
  • 16
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++堆栈类模板实现代码
08-26
主要为大家详细介绍了C++堆栈类模板的实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++初阶：模板进阶
yourfriendyo的博客
04-10 405
泛型编程和模板 STL 简介 STL（standard template libaray）是 C++ 标准库的重要组成部分：标准模板库。STL 不仅是一个可复用的组件库，而且 是一个包罗数据结构与算法的软件框架。 原始版本 Alexander Stepanov、Meng Lee 在惠普实验室完成的原始版本，本着开源精神，他们声明允许任何人任意运用、拷贝、修改、传播、商业使用这些代码，无需付费。唯一的条件就是也需要向原始版本一样做开源使用。也成为 HP 版本，是所有STL实现版本的始祖。 P. J. 版本 由
C++初阶：初识模板
Crazy_Rabbits的博客
03-20 764
class 类模板名// 类内成员定义// 动态顺序表// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具public:// 使用析构函数演示：在类中声明，在类外定义。~Vector();// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表。
C++初阶 —— 模板初阶
NapoleonCoder的博客
10-31 800
函数模板、类模板!
C++初阶：模板初阶
qq_71806743的博客
03-15 959
我们在之前类与对象的学习中，学习过类的默认成员函数，其中构造函数的函数名为类的名称，那么类模板的构造函数的函数名应该是什么呢。构造函数的名称为类名，而类模板[类名]为类型名，因此，构造函数名与普通类相同。类模板的成员函数声明与定义分离方式： 必须在同一文件下，否则报错 分离出的定义部分，必须也要加声明模板参数的声明，声明类域时要使用类型名，具体如下class [类名]public://函数声明[返回值] [函数名]();
C++初阶：模板
weixin_36194037的博客
03-11 898
C++初阶：模板
C++初阶模板
m0_74246469的博客
11-28 1138
讲述C++中的初级函数模板和类模板以及运用关系
C++初阶-模板初阶
~
12-22 332
【C++初阶学习】C++模板初阶零、前言一、泛型编程二、函数模板1、函数模板定义及使用2、函数模板原理3、函数模板实例化4、函数模板匹配原则三、类模板1、类模板定义及使用2、类模板实例化 零、前言 本章主要讲解C++的模板相关的初阶知识 一、泛型编程 用函数重载来实现交换变量函数： void Swap(int& left, int& right) { int temp = left; left = right; right = temp; } void Swap(double.
C++模板初阶
分享学习的知识，记录我的技术成长道路
03-13 954
在书写函数或类时，我们可能遇到这样的问题，明明结构一模一样但是只由于某个参数的类型不同就需要重新写函数，或者构建重载函数，重新书写类就更加麻烦了，并且使程序显得冗长，本文将介绍C++中的模板，从而解决相似函数重复书写问题。
[C++初阶]模板初阶
2301_80017277的博客
04-26 269
函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定。如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。巧的是前人早已将树栽好，我们只需在此乘凉。2. 代码的可维护性比较低，一个出错可能所有的重载均出错。，对于字符类型也是如此。，对于模板函数的使用，
C++初阶 内存管理和模板
fq157856469的博客
02-03 1329
C++在堆上开空间的操作为new，可以看作是C语言的malloc可等价为C语言中的free，用来释放在堆上开辟的空间的在生活中我们常常能遇到什么万用作文模板，用固定的句式加上几个词汇的那种大家应该都见过，而我接下来我们谈的模板也和这个有异曲同工之处，都是套一套固定的模式。模板分为函数模板和类模板这两种模板。
c++文件模板 c++文件模板
02-24
c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件...
c++上机实验报告模板
10-31
实验报告模板c++上机可以方便大家认真总结每一次的上机情况
基于C++的ACM模板
02-22
基于C++的ACM模板
由浅入深学习C++模板
11-21
模板练习 ├─Macro1 │ └─res ├─Macro2 │ └─res ├─Macro3 │ └─res ├─Template1 ├─Template2 ├─Template3 ├─Template4 ├─Template5 ├─函数指针模板 │ ├─FuncTemplate1 │ ├─...
《前端面试题》- TypeScript - TypeScript的优/缺点
小张微说的博客
04-22 5759
问题 简述TypeScript的优/缺点 答案 优点 增强了代码的可读性和可维护性 包容性，js可以直接改成ts，ts编译报错也可以生成js文件，兼容第三方库，即使不是ts编写的 社区活跃，完全支持es6 缺点 增加学习成本 增加开发成本，因为增加了类型定义 需要编译，类型检查会增加编译时长，语法和类型系统复杂的话时间特别特别长 eval和new Function()这种操作类型系统管不到 ...
C语言—操作符详解（操作符、进制转换、原码反码补码、结构体）
l1894的博客
05-04 1050
（左移一位有乘2的效果，右移一位有除2的效果）
c++ 点到多边形的距离
最新发布
jacke121的专栏
05-08 93
c++ 点到多边形的距离
C++ list 介绍
2301_77203593的博客
05-08 485
构造空list构造可包含n个T类型数据的list构造list，用first到last区间中的元素构造。注意可以是别的容器中的元素。（例如可以用vectorint<int>int中的一段数据构造一个新的listint<int>int。还可以用string等等）。拷贝构造。用已有的一个list构造新的list。注：前提是原链表和链表x都为有序链表，默认升序。将有序链表x按照默认的升序合并至原链表中，合并后x变为空链表。
C++模板数组类三行输入
05-28
下面是一个简单的 C++ 模板数组类的实现，可以用三行输入来创建和初始化一个数组对象： ```c++ #include template , int size> class Array { private: T arr[size]; public: void input() { for (int i = 0; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值