C++小白的逆袭之路——初阶（第十二章：模版进阶）

2024-05-03 01:04
文章标签 c++ 进阶 初阶 之路 小白 模版 第十二章 逆袭

本文主要是介绍C++小白的逆袭之路——初阶（第十二章：模版进阶），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

C++小白的逆袭之路——初阶（第十二章：模版进阶）

  • 1. 非类型模版参数
  • 2. 模版的特化
    • 2.1 概念
    • 2.2 类模版特化
    • 2.3 函数模版特化
  • 3. 模版分离编译
  • 4. 模版总结

1. 非类型模版参数

1. 模板参数分类型模版参数与非类型模版参数：

  • 类型模版参数：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
  • 非类型模版参数：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

2. 问题引入：

  • 现在有一个需求，要求创建两个静态栈，一个栈定长为10，一个栈定长为10000。如何设计？
#define N 10000template<class T>
class Stack
{// ...
private:T _a[N];
};
  • 一种方式是用#define定义的宏来设置栈的大小，为了兼容定长为10000的栈，N的大小设置为10000，但是这样做会让定长为10的栈浪费大量空间。

3. 引入非类型模版参数：

// 非类型模版参数 -- 只支持整型家族
template<class T, int N>
class Stack
{// ...
private:T _a[N];
};int main()
{Stack<int, 10> st1;		  // 大小为10Stack<double, 10000> st2; // 大小为10000return 0;
}
  • N在这里是非类型模版参数，我们传10这个栈就是10大小，传10000这个栈就是10000大小，完美解决上述问题。

4. 非类型模版参数的特点：

  • 非类型模版参数只支持整型类型，也就是只支持char，int，long，long long这些类型；不支持浮点数类型、字符串类型等等其他类型。
  • 非类型模版参数只能传常量，不能传变量；非类型模版参数必须在编译期间就能确定。

5. 非类型模版参数在C++11中的运用：

  • C++11中引入了一个新容器array，其实就是一个定长数组。
    在这里插入图片描述
  • array相较于普通静态数组的优势是可以防止越界。
int main()
{int arr1[10];array<int, 10> arr2;arr1[15] = 1; // 不一定报错arr2[15] = 1; // 直接报错return 0;
}
  • 但是实际上array设计的非常鸡肋，C++委员会的初衷是想让array替代静态数组，但是很多人用习惯了C语言的那套东西，嫌麻烦，也就不会选择array。更重要的原因是，array<int, 10> arr2;完全可以被vector<int> v(10, 0);替换，并且vector也会检查越界。

2. 模版的特化

2.1 概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理。

// 模版特化：针对某些类型做特殊化处理
template<class T1, class T2>
class Data
{
public:Data(){cout << "Data<T1, T2>" << endl;}
private:T1 _d1;T2 _d2;
};// 特化 -- 全特化，所有参数都特化
template<>
class Data<int, double>
{
public:Data(){cout << "Data<int, double>" << endl;}
private:int _d1;double _d2;
};int main()
{Data<int, int> d1;		// 走模版Data<int, double> d2;	// 走模版特化return 0;
}/*
输出：
Data<T1, T2>
Data<int, double>
*/

上面的例子中，特化出的类是class Data<int, double>，Data<int, int> d1;会匹配模版，Data<int, double> d2;会匹配模版特化，做特殊处理。特化的前面必须加上template<>，这是语法规定。

2.2 类模版特化

1. 全特化：

  • 全特化即将模板参数列表中所有的参数都确定化。2.1例子中的特化就是全特化。
template<class T1, class T2>
class Data
{
public:Data(){cout << "Data<T1, T2>" << endl;}
private:T1 _d1;T2 _d2;
};// 特化 -- 全特化，所有参数都特化
template<>
class Data<int, double>
{
public:Data(){cout << "Data<int, double>" << endl;}
private:int _d1;double _d2;
};

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<class T1, class T2>
class Data<T1*, T2*>
{
public:Data(){cout << "Data<T1*, T2*>" << endl;}
private:T1* _d1;T2* _d2;
};// 限制模版参数为引用类型
template<class T1, class T2>
class Data<T1&, T2&>
{
public:Data(const T1& a, const T2& b):_d1(a),_d2(b){cout << "Data<T1&, T2&>" << endl;}
private:const T1& _d1;const T2& _d2;
};int main()
{Data<int*, int*> d4;Data<int&, int&> d5(1, 2);return 0;
}
/*
输出：
Data<T1*, T2*>
Data<T1&, T2&>
*/
  • 模版的特化也遵循最匹配原则。

3. 类模版特化实际应用：

  • 创建一个专门用于比较小于的仿函数Less。
template<class T>
class Less
{
public:bool operator()(const T& left, const T& right) const{return left < right;}
};
  • 在sort中使用这个比较方法。
void test()
{int a = 0;int b = 20;int c = 13;vector<int> v;v.push_back(a);v.push_back(b);v.push_back(c);sort(v.begin(), v.end(), Less<int>());for (auto e : v){cout << e << " ";}cout << endl;vector<int*> v2;v2.push_back(&a);v2.push_back(&b);v2.push_back(&c);sort(v2.begin(), v2.end(), Less<int*>()); // 结果是随机的for (auto e : v2){cout << *e << " ";}cout << endl;
}
  • 发现如果是直接比较a,b,c的值，结果正确；但是如果要通过a,b,c的指针对其指向内容进行排序，结果错误。
  • 之前我们的做法是自定义一个比较方法Compare，然后传给sort。如今也可以通过特化Less解决。
template<class T>
class Less
{
public:bool operator()(const T& left, const T& right) const{return left < right;}
};// 特化Less
template<class T>
class Less<T*>
{
public:bool operator()(T* left, T* right){return *left < *right;}
};
  • 之后我们再执行之前的sort，就可以比较出正确的结果了。

2.3 函数模版特化

1. 函数模板的特化步骤：

  • 必须要先有一个基础的函数模板；
  • 关键字template后面接一对空的尖括号<>；
  • 函数名后跟一对尖括号，尖括号中指定需要特化的类型；
  • 函数形参表，必须要和模板函数的基础参数类型完全相同，不然不同编译器可能会报一些奇怪的错误。
template<class T>
bool Less(T left, T right)
{return left < right;
}// 特化一个int类型的Less函数
template<>
bool Less<int>(int left, int right)
{return left < right;
}int main()
{cout << Less(1.1, 2.2) << endl; // 走函数模版cout << Less(1, 2) << endl;		// 走函数模版特化
}

2. 函数模版特化的注意事项：

  • 在上面的示例中，Less传形参时会发生数据拷贝，我们为了提高效率，一般选择传引用，并且用const修饰引用。
template<class T>
bool Less(const T& left, const T& right)
{return left < right;
}// 特化一个int类型的Less函数
template<>
bool Less<int>(const int& left, const int& right)
{return left < right;
}
  • int类型的特化就需要稍作改动，保持跟模版函数的基础参数类型完全相同。但是如果我们使用指针特化Less就会出问题。
template<class T>
bool Less(const T& left, const T& right)
{return left < right;
}template<>
bool Less<int*>(const int* &left, const int* &right) // 报错
{return *left < *right;
}
  • 如果单从替换的角度去看这个特化函数，T被替换为了int*，和模版函数参数列表保持一致，好像没什么问题。但是这样写却会直接报错，因为语义发生了改变。
  • const int* p中，const修饰的是*p，表示*p不能改变，p指向的内容不能改变。const int* &left也是如此，const修饰*left，表示left指向的内容不会改变。但是原模版函数参数列表中，语义是left本身不能被改变，特化的函数就出现了歧义。
  • 为了解决这一问题，我们需要改变一下特化函数中const的位置，改为int* const &left，就可以了。和原模版函数参数列表语义相同，left不允许被改变。
template<class T>
bool Less(const T& left, const T& right)
{return left < right;
}template<> 
bool Less<int*>(int* const &left, int* const &right) // 编译通过
{return *left < *right;
}

3. 经验：

  • 类模板特化建议使用，函数模版特化不建议使用，因为函数模版特化完全可以被函数重载代替。
template<class T>
bool Less(const T& left, const T& right)
{return left < right;
}bool Less(const int* const left, const int* const right)
{return *left < *right;
}
  • Less(const int* const left, const int* const right)，是原模版函数实例化后的一个重载，这样写不香吗，不用非要写一个函数模版特化。

3. 模版分离编译

1. 什么是分离编译：

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

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. 解决方法：

  • 将声明和定义统一放到一个文件xxx.hpp里或者xxx.h也是可以的。推荐使用这种。
  • 模板定义的位置显式实例化。这种方法很鸡肋，不推荐使用。
// a.h
template<class T>
T Add(const T& left, const T& right);template<class T>
class Stack
{... // 只有声明
};// a.cpp
template<class T>
T Add(const T& left, const T& right)
{return left + right;
}
int Add<int>(const int& left, const int& right);  			// 显示实例化
double Add<double>(const double& left, const double& right);	// 显示实例化template<class T>
void Stack<T>::Push(const T& x)
{...
}.../*
等等类方法的定义
*/
template
class Stack<int> // 显示实例化// main.cpp
#include"a.h"
int main()
{Add(1, 2);Add(1.0, 2.0);return 0;
}

4. 模版总结

1. 优点：

  • 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生；
  • 增强了代码的灵活性。

2. 缺陷：

  • 模板会导致代码膨胀问题，也会导致编译时间变长；
  • 出现模板编译错误时，错误信息非常凌乱，不易定位错误。

这篇关于C++小白的逆袭之路——初阶（第十二章：模版进阶）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/955511。

相关文章

Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
【C++ Primer Plus习题】13.4

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<
阅读更多...
C++包装器

C++包装器

包装器 在 C++ 中，“包装器”通常指的是一种设计模式或编程技巧，用于封装其他代码或对象，使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍，可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型： 1. 函数包装器 函数包装器用于封装一个或多个函数，使其接口更统一或更便于调用。例如，std::function 是一个通用的函数包装器，它可以存储任意可调用对象（函数、函数
阅读更多...
C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页： 南桥几晴秋 🌈C++专栏： 南桥谈C++ 🌈C语言专栏： C语言学习系列 🌈Linux学习专栏： 南桥谈Linux 🌈数据结构学习专栏： 数据结构杂谈 🌈数据库学习专栏： 南桥谈MySQL 🌈Qt学习专栏： 南桥谈Qt 🌈菜鸡代码练习： 练习随想记录 🌈git学习： 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
06 C++Lambda表达式

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获：包含零个或者多个捕获符的逗号分隔列表 模板形参：用于泛型lambda提供个模板形参的名
阅读更多...
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

上篇：6.1.数据结构-c/c++模拟实现堆上篇（向下，上调整算法，建堆，增删数据）-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小)： 2.2 C语言代码（手写堆） 2.3 C++代码（使用优先级队列 priority_queue）
阅读更多...
[MySQL表的增删改查-进阶]

[MySQL表的增删改查-进阶]

🌈个人主页：努力学编程’ ⛅个人推荐： c语言从初阶到进阶 JavaEE详解 数据结构 ⚡学好数据结构，刷题刻不容缓：点击一起刷题 🌙心灵鸡汤：总有人要赢，为什么不能是我呢 💻💻💻数据库约束 🔭🔭🔭约束类型 not null: 指示某列不能存储 NULL 值unique: 保证某列的每行必须有唯一的值default: 规定没有给列赋值时的默认值.primary key:
阅读更多...
【C++高阶】C++类型转换全攻略：深入理解并高效应用

【C++高阶】C++类型转换全攻略：深入理解并高效应用

📝个人主页🌹：Eternity._ ⏩收录专栏⏪：C++ “ 登神长阶 ” 🤡往期回顾🤡：C++ 智能指针 🌹🌹期待您的关注 🌹🌹 ❀C++的类型转换 📒1. C语言中的类型转换📚2. C++强制类型转换⛰️static_cast🌞reinterpret_cast⭐const_cast🍁dynamic_cast 📜3. C++强制类型转换的原因📝
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2