ToB企服应用市场:ToB评测及商务社交产业平台

标题: 初识C++ · 模板进阶 [打印本页]
作者: 我爱普洱茶    时间: 2024-6-8 06:37
标题: 初识C++ · 模板进阶
目录
前言：
1 非类型模板参数
2 按需实例化
3 模板特化
4 模板的分离编译
前言：

前面模板我们会了简单的使用，这里带来模板的进阶，当然，也就那么几个知识点，并不太难。
1 非类型模板参数

先来看这样一段代码：
  1. #define N 100
  2. template<class T>
  3. class Arr
  4. {
  5. public:
  7. private:
  8.         T _arr[N];
  9. };
复制代码
如果我们想要创建一个整型数组，可以使用这个类来创建，但是我们面临一个问题就是该数组的大小是固定的，我们想要简单控制这个数组的大小，可以使用宏，但是还是不够简便，因为宏不方便调试不说，实际上也是指定了大小，那么我们想要使用一个类，来创建不同大小的数组该怎么办？
这里使用到的就是非类型模板参数，如下：
  1. template<class T,size_t N = 100>
  2. class Arr
  3. {
  4. public:
  6. private:
  7.         T _arr[N];
  8. };
  9. int main()
  10. {
  11.         Arr<int,10> a1;
  12.         Arr<int,1000> a2;
  13.         Arr<int> a3;
  14.         return 0;
  15. }
复制代码
这里就得到了我们想要的不同大小的数组，那么，来个问题，编译器一共实现了几个类？
答：编译器这里一共实现了3个类，编译器根据模板参数的不同，就实现了不同的类。这里的非类型模板参数，我们可以理解为常量，如这里的N，但是在C++11只支持整型，连浮点数都不可以，只支持整型，比如int size_t char一类的，在C++ 20之后才可以支持其他类型。
这里涉及到了数组，那么引入一个小的知识点就是对于越界来说，array 数组 vector有着不同的反应：
  1. int main()
  2. {
  3.         int arr[10];
  4.         arr[10];
  5.         arr[15] = 1;
  6.         return 0;
  7. }
复制代码
对于普通数组来说，普通的越界只读来说，比如arr[10]是检查不来错误的，越界写来说，也是很多抽查不出来的，比如这段代码在vs2019上就不会报错。
那么对于array来说：
  1. int main()
  2. {
  3.         std::array<int,10> array;
  4.         array[10];
  5.         return 0;
  6. }
复制代码
任何读写越界都会报错，但是呢，这是c++委员会后面加的，但是挺鸡肋的，因为我们有vector。
  1. int main()
  2. {
  3.         std::vector<int> v;
  4.         v.reserve(1000);
  5.         return 0;
  6. }
复制代码
vector对越界的读写都会报错，这是一方面，其次是array是静态的数组，也就是大小定了，并且，它所属的空间是栈，栈的空间相对堆来说就会小很多，所以面临开大空间的时候，array就不吃香了，vector没事，因为可以动态开辟。
2 按需实例化

先看这样一段代码：
  1. template<class T,size_t N = 100>
  2. class Arr
  3. {
  4. public:
  5.         T& operator[](size_t i)
  6.         {
  7.                 size(1);
  8.                 return _arr[i];
  9.         }
  10.         size_t size()
  11.         {
  12.                 return _size;
  13.         }
  14.         bool empty()
  15.         {
  16.                 return _size == 0;
  17.         }
  18. private:
  19.         T _arr[N];
  20.         size_t _size = 0;
  21. };
  22. int main()
  23. {
  24.         Arr<int> a1;
  25.         a1.empty();
  27.         return 0;
  28. }
复制代码
从语法层面来说，size()函数没有参数，那么我们传参数的话就会导致报错对吧？可是，实际上：

代码是没有报错，也就是说size()传参数是对的吗？
不，这是因为按需实例化。
在主函数里面，我们实例化了a1,并且调用了empty函数，但是我们没有调用operator[]函数，那么编译器就不会实例化operator函数，因为我们没有调用，既然没有实例化size函数，那么传什么都不会报错，这就是按需实例化。
再细节一点来说，编译器会根据模板实例化->实例化一个半成品模板->再实例化为一个具体的类或者函数->最后才是语法编译,所以没有语法报错。
3 模板特化

特化我们可以理解为特殊化处理，比如我们在栈和队列的时候实现的日期类的比较，就可以不用仿函数来实现比较，可以用特化来处理。
日期类：
  1. class Date
  2. {
  3. public:
  4.         friend ostream& operator<<(ostream& _cout, const Date& d);
  6.         Date(int year = 1900, int month = 1, int day = 1)
  7.                 : _year(year)
  8.                 , _month(month)
  9.                 , _day(day)
  10.         {}
  12.         bool operator<(const Date& d)const
  13.         {
  14.                 return (_year < d._year) ||
  15.                         (_year == d._year && _month < d._month) ||
  16.                         (_year == d._year && _month == d._month && _day < d._day);
  17.         }
  19.         bool operator>(const Date& d)const
  20.         {
  21.                 return (_year > d._year) ||
  22.                         (_year == d._year && _month > d._month) ||
  23.                         (_year == d._year && _month == d._month && _day > d._day);
  24.         }
  25. private:
  26.         size_t _year;       
  27.         size_t _month;
  28.         size_t _day;
  29. };
  30. ostream& operator<<(ostream& _cout, const Date& d)
  31. {
  32.         _cout << d._year << "-" << d._month << "-" << d._day;
  33.         return _cout;
  34. }
复制代码
  1. template<class T>
  2. bool less(const T& a,const T& b)
  3. {
  4.         return a < b;
  5. }
  6. int main()
  7. {
  8.         Date d1(2024, 5, 20);
  9.         Date d2(2024, 5, 21);
  10.         cout << (d1 < d2) << endl;
  11.         return 0;
  12. }
复制代码
比如，使用函数模板，对于重载了比较符号的比较是没问题的，如果使用指针就会报错，因为默认是按照指针比较的，这里就可以使用特化：
  1. int main()
  2. {
  3.         Date* p1 = new Date(2020, 1, 1);
  4.         Date* p2 = new Date(2020, 1, 2);
  5.         cout << (p1 < p2) << endl;
  6.         return 0;
  7. }
复制代码
这段代码是有问题的是不用多说的，下面是解决方案：
  1. template<class T>
  2. bool Less(T left, T right)
  3. {
  4.         cout << "bool Less(T left, T right)" << endl;
  5.         return left < right;
  6. }
  8. template<>
  9. bool Less<Date*>(Date* p1,Date* p2)
  10. {
  11.         return *p1 < *p2;
  12. }
  14. int main()
  15. {
  16.         Date d1(2022, 7, 7);
  17.         Date d2(2022, 7, 8);
  18.         Date* p1 = &d1;
  19.         Date* p2 = &d2;
  20.         cout << Less(p1, p2) << endl;
  21.         return 0;
  22. }
复制代码
这里的语法就比较怪了，现在使用的是函数模板，有点像函数重载的感觉，当然，我们也可以直接重载一个出来：
  1. bool Less(Date* left, Date* right)
  2. {
  3.         return *left < *right;
  4. }
复制代码
那么，调用是怎么调用的呢？

这里就和半成品，成品是一个道理，重载的函数就相当于成品，特化的函数快成品了，模板就是个半成品，调用的顺序也就说的通了。
以上是函数模板的特化，看起来就像是函数重载，接着是类中的模板特化：
  2. //普通
  3. template<class T1,class T2>
  4. class Data
  5. {
  6. public:
  7.         Data() { cout << "Data<T1, T2>" << endl; }
  9. };
  11. //全特化
  12. template<>
  13. class Data<int, char>
  14. {
  15. public:
  16.         Data() { cout << "Data<int, char>" << endl; }
  17. };
  19. //偏特化
  20. template<class T1>
  21. class Data<T1, char>
  22. {
  23. public:
  24.         Data() { cout << "Data<T1, char>" << endl; }
  25. };
复制代码
使用方式和函数模板其实是差不多的，在特化这里分为全特化和偏特化，特化也不是什么特别的东西，其实就是对参数的进一步限制而已。
4 模板的分离编译

使用模板的时候，定义和声明最好放在一个文件，.h和.c文件分离会报错的，这里简单举个例子：
  1. // a.h
  2. template<class T>
  3. T Add(const T& left, const T& right);
  5. //a.cpp
  6. template<class T>
  7. T Add(const T& left, const T& right)
  8. {
  9. return left + right;
  10. }
复制代码
在调用这个函数的时候就会报错，只需要想清楚一个简单的问题就可以了，两个T是不是一样的T，能否用.h文件里面的T去平替.cpp里面的T，当然是不可以的，所以这里，就会报错，报的是链接错误，.h文件编译成功后，.cpp里面的文件是没有编译好的，因为T不知道是什么类型，调用的时候就会报错。
在链接阶段，编译器按照修饰好之后的函数名在符号表里面寻找函数，不知道类型就没有生成修饰好的函数名，那么就会报如下类似的错：

感谢阅读！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4