• C++【STL】【模板进阶】

    目录

    一、非类型模板参数

    1.给模板参数设置缺省值

    2.Array 

    二、模板的特化

    1.函数模板的特化

    2.类模板的特化

    3.类模板的全特化

    4.类模板的偏特化（半特化）

    模板参数可以是匹配指针

    模板参数可以是匹配引用

    模板参数可以是匹配指针和引用

    三、模板的分离编译

    typename和class的区别

     声明和定义分离就会报错

    为什么声明和定义分离就链接错误了？

    如何解决？

    1.在同一个文件中分离声明和定义

    2.显式实例化（不推荐）

    模板总结

    一、非类型模板参数

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

    之前我们使用模板都是这样使用的

    1. #include 
    2. #define N 100
    3. template<class T>
    4. class array{
    5. private:
    6.     T _a[N];
    7. };
    8. int main()
    9. {
    10.     array<int> a1;
    11.     array<double> a2;
    12.     return 0;
    13. }

    但是假设我们想要让a1的大小变成100，a2的大小变成1000，怎么办呢？

    这里我们就可以再添加一个模板参数，但是这个模板参数并不是某一种数据类型，而是一个常量。

    1. #include 
    2. //非类型模板参数 --常量
    3. template<class T,size_t N>
    4. class array{
    5. private:
    6.     T _a[N];
    7. };
    8. int main()
    9. {
    10.     array<int,100> a1;
    11.     array<double,1000> a2;
    12.     return 0;
    13. }

    1.给模板参数设置缺省值

     模板参数和函数参数是非常像的，我们还可以给我们的模板参数一个缺省值

    1. #include 
    2. //非类型模板参数 --常量
    3. template<class T,size_t N=10>
    4. class array{
    5. private:
    6.     T _a[N];
    7. };
    8. int main()
    9. {
    10.     array<int,100> a1;
    11.     array<double> a2;
    12.     return 0;
    13. }

    注意：
    1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的（char是算整型家族的）。
    2. 非类型的模板参数必须在编译期就能确认结果。

    2.Array 

    这里我们从cpluscplus网站中看到我们的的array定义 

    fixed-size sequence containers，固定大小的顺序容器，也就是一个静态数组

     这个标准库的array是在2011年的c++11才增加的

    这个array和我们c语言中的数组的区别是什么呢？

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8.     array<int,100> a1;//c++
    9.     int a2[10];//c
    10.     cout<<sizeof (a1)<
    11.     cout<<sizeof (a2)<
    12.     return 0;
    13. }

     除了array是支持使用迭代器去访问的，其两者的区别还在于其迭代器的的越界检查。

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5. int main()
    6. {
    7.     array<int,10> a1;
    8.     int a2[10];
    9.  
    10.     //越界写和越界读都能被查到
    11.     a1[10];
    12.     //a2的越界读是检查不到的，越界写是可以检查到的
    13. //    a2[10];
    14.     cout<<sizeof (a1)<
    15.     cout<<sizeof (a2)<
    16.     return 0;
    17. }

    array中是一个函数调用，这个函数调用就会检查这个函数的下标有没有超出参数N，所以它对于越界的检查会更加好

     而我们的c语言中的数组仅仅是将数组的首地址加上N，再解引用来得到我们的结果。指针解引用只是抽查是否越界，只针对越界写，越界读不检查。

    二、模板的特化

    有些情况下我们希望我们能够对模板进行特殊化处理， 这里我们就要用到模板特化

    1.函数模板的特化

    我们首先定义一个日期类

    1. struct Date
    2. {
    3.     Date(int year, int month, int day)
    4.             :_year(year)
    5.             , _month(month)
    6.             , _day(day)
    7.     {}
    8.  
    9.     bool operator>(const Date& d) const
    10.     {
    11.         if ((_year > d._year)
    12.             || (_year == d._year && _month > d._month)
    13.             || (_year == d._year && _month == d._month && _day > d._day))
    14.         {
    15.             return true;
    16.         }
    17.         else
    18.         {
    19.             return false;
    20.         }
    21.     }
    22.  
    23.     bool operator<(const Date& d) const
    24.     {
    25.         if ((_year < d._year)
    26.             || (_year == d._year && _month < d._month)
    27.             || (_year == d._year && _month == d._month && _day < d._day))
    28.         {
    29.             return true;
    30.         }
    31.         else
    32.         {
    33.             return false;
    34.         }
    35.     }
    36.  
    37.     int _year;
    38.     int _month;
    39.     int _day;
    40. };
    1. #include 
    2. using namespace std;
    3.  
    4.  
    5. // 函数模板 -- 参数匹配
    6. template<class T>
    7. bool Less(T left, T right)
    8. {
    9.     return left < right;
    10. }
    11.  
    12. // 函数模板 -- 参数匹配
    13. template<class T>
    14. bool Greater(T left, T right)
    15. {
    16.     return left > right;
    17. }
    18.  
    19.  
    20. int main()
    21. {
    22.     cout << Greater(1, 2) << endl; // 可以比较，结果正确
    23.     Date d1(2022, 7, 7);
    24.     Date d2(2022, 7, 8);
    25.     cout << Greater(d1, d2) << endl; // 可以比较，结果正确
    26.     Date* p1 = &d1;
    27.     Date* p2 = &d2;
    28.     //指针比较指针，但是我们并不想要的是指针大小的比较结果，我们只是想知道这个指针指向的日期类的比较
    29.     cout << Greater(p1, p2) << endl; // 可以比较，结果错误
    30.     return 0;
    31. }

     C++中比较的都是变量和对象，类型不能够比较！！

    比方说我们设置T==Date*类型，进行单独比较，C++是不支持的！！！

    1. // 函数模板 -- 参数匹配
    2. template<class T>
    3. bool Less(T left, T right)
    4. {
    5.     return left < right;
    6. }
    7.  
    8.  函数模板 -- 参数匹配
    9. template<class T>
    10. bool Greater(T left, T right)
    11. {
    12.     return left > right;
    13. }
    14.  
    15. // 特化--针对某些类型进行特殊化处理
    16. //如果我们这个T是Date*类型，就会走下面这个函数
    17. //注意，下面这个函数是对上面这个函数的特化，上面那个函数必须存在的！！！
    18. template<>
    19. bool Greater(Date* left, Date* right)
    20. {
    21.     return *left > *right;
    22. }
    23.  
    24. int main()
    25. {
    26.     cout << Greater(1, 2) << endl; // 可以比较，结果正确
    27.     Date d1(2022, 7, 7);
    28.     Date d2(2022, 7, 8);
    29.     cout << Greater(d1, d2) << endl; // 可以比较，结果正确
    30.     Date* p1 = &d1;
    31.     Date* p2 = &d2;
    32.     //指针比较指针，但是我们并不想要的是指针大小的比较结果，我们只是想知道这个指针指向的日期类的比较
    33.     cout << Greater(p1, p2) << endl; // 可以比较，结果错误
    34.     return 0;
    35. }

    2.类模板的特化

    下面我们写了一个less仿函数

    1. namespace zhuyuan
    2. {
    3.     template<class T>
    4.     struct less
    5.     {
    6.         bool operator()(const T& x1, const T& x2) const
    7.         {
    8.             return x1 < x2;
    9.         }
    10.     };
    11.  
    12. }
    13.  
    14.  
    15. int main()
    16. {
    17.     Date d1(2022, 7, 7);
    18.     Date d2(2022, 7, 8);
    19.  
    20.     Date* p1 = &d1;
    21.     Date* p2 = &d2;
    22.  
    23.     zhuyuan::less lessFunc1;
    24.     cout << lessFunc1(d1, d2) << endl;
    25.     
    26.     //我们想要比较的并不是指针的大小，而是指针指向的对象的大小
    27.     zhuyuan::less lessFunc2;
    28.     cout << lessFunc2(p1, p2) << endl;
    29.  
    30.     return 0;

    针对类模板也可以特化

    1. namespace zhuyuan
    2. {
    3.     template<class T>
    4.     struct less
    5.     {
    6.         bool operator()(const T& x1, const T& x2) const
    7.         {
    8.             return x1 < x2;
    9.         }
    10.     };
    11.  
    12.     // 特化
    13.     template<>
    14.     struct less
    15.     {
    16.     	bool operator()(Date* x1, Date* x2) const
    17.     	{
    18.     		return *x1 < *x2;
    19.     	}
    20.     };
    21. }
    22.  
    23.  
    24. int main()
    25. {
    26.     Date d1(2022, 7, 7);
    27.     Date d2(2022, 7, 8);
    28.  
    29.     Date* p1 = &d1;
    30.     Date* p2 = &d2;
    31.  
    32.     zhuyuan::less lessFunc1;
    33.     cout << lessFunc1(d1, d2) << endl;
    34.  
    35.     zhuyuan::less lessFunc2;
    36.     cout << lessFunc2(p1, p2) << endl;
    37.     return 0;
    38. }

     不特化就会按指针的大小比较，特化就会按指针指向的对象比

    1. namespace zhuyuan
    2. {
    3.     template<class T>
    4.     struct less
    5.     {
    6.         bool operator()(const T& x1, const T& x2) const
    7.         {
    8.             return x1 < x2;
    9.         }
    10.     };
    11.  
    12.     // 特化
    13.     template<>
    14.     struct less
    15.     {
    16.     	bool operator()(Date* x1, Date* x2) const
    17.     	{
    18.     		return *x1 < *x2;
    19.     	}
    20.     };
    21. }
    22.  
    23.  
    24. int main()
    25. {
    26.  
    27.  
    28.     std::priority_queue, zhuyuan::less> dq1;
    29.     //这个如果不特化，就会出现问题
    30.     std::priority_queue, zhuyuan::less> dq2;
    31.     dq2.push(new Date(2022, 9, 27));
    32.     dq2.push(new Date(2022, 9, 25));
    33.     dq2.push(new Date(2022, 9, 28));
    34.     dq2.push(new Date(2022, 9, 29));
    35.  
    36.  
    37.     return 0;
    38. }

    这是有特化的结果，也就是按照从大到小排

    如果我们将上面的特化的代码处理掉，我们观察到我们的地址是按照从大到小排的

    注意：

    1.特化不能单独存在，原来的函数模板必须存在! 

    3.类模板的全特化

     这个与我们的缺省参数非常像，缺省可以分为全缺省和半缺省，特化也可以分为全特化和半特化，偏特化。

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

    1. template<class T1, class T2>
    2. class Data
    3. {
    4. public:
    5. 	Data() { cout << "Data" << endl; }
    6. private:
    7. 	T1 _d1;
    8. 	T2 _d2;
    9. };
    10.  
    11. // 全特化
    12. template<>
    13. //全部的模板参数全部都写死，只能匹配类型
    14. class Data<int, char>
    15. {
    16. public:
    17. 	Data() { cout << "Data" << endl; }
    18. private:
    19. 	/*int _d1;
    20. 	char _d2;*/
    21. };
    22.  
    23.  
    24. int main()
    25. {
    26. 	Data<int, int> d0;
    27. 	Data<double, int> d1;
    28. 	Data<int, char> d2;
    29. 	return 0;
    30. }

    4.类模板的偏特化（半特化）

    部分参数特化

    1. //原模板
    2. template<class T1, class T2>
    3. class Data
    4. {
    5. public:
    6. 	Data() { cout << "Data" << endl; }
    7. private:
    8. 	T1 _d1;
    9. 	T2 _d2;
    10. };
    11.  
    12. // 偏特化
    13. template <class T1>
    14. class Dataint>
    15. {
    16. public:
    17. 	Data() { cout << "Data" << endl; }
    18. private:
    19. 	/*T1 _d1;
    20. 	int _d2;*/
    21. };
    22. int main()
    23. {
    24.     //下面两个都是可以匹配到偏特化的版本的
    25. 	Data<int, int> d0;
    26. 	Data<double, int> d1;
    27.     
    28.     //
    29. 	Data<int, char> d2;
    30. 	return 0;
    31. }

    模板参数可以是匹配指针

    1. template<class T1, class T2>
    2. class Data
    3. {
    4. public:
    5. 	Data() { cout << "Data" << endl; }
    6. private:
    7. 	T1 _d1;
    8. 	T2 _d2;
    9. };
    10.  
    11.  
    12. //偏特化，只要这两个模板参数是指针，就能够被匹配到
    13. template<class T1, class T2>
    14. class Data
    15. {
    16. public:
    17. 	Data() { cout << "Data" << endl; }
    18. };
    19.  
    20.  
    21. int main()
    22. {
    23.  
    24. 	Data<double, double> d3;
    25. 	Data<double*, double*> d4;
    26. 	Data<int*, char*> d5;
    27.     //只有一个指针，匹配不到两个都是指针的模板的，只会匹配到最初原来的模板
    28. 	Data<int*, char> d6;
    29.  
    30. 	return 0;
    31. }

    模板参数可以是匹配引用

    1. template<class T1, class T2>
    2. class Data
    3. {
    4. public:
    5. 	Data() { cout << "Data" << endl; }
    6. private:
    7. 	T1 _d1;
    8. 	T2 _d2;
    9. };
    10.  
    11.  
    12. template<class T1, class T2>
    13. class Data
    14. {
    15. public:
    16. 	Data() { cout << "Data" << endl; }
    17. };
    18.  
    19. int main()
    20. {
    21.     //可以用于匹配迭代器
    22. 	Data<int&, char&> d7;
    23. 	Data<int&, double&> d8;
    24.  
    25. 	return 0;
    26. }

    模板参数可以是匹配指针和引用

    1. template<class T1, class T2>
    2. class Data
    3. {
    4. public:
    5. 	Data() { cout << "Data" << endl; }
    6. private:
    7. 	T1 _d1;
    8. 	T2 _d2;
    9. };
    10.  
    11. template<class T1, class T2>
    12. class Data
    13. {
    14. public:
    15. 	Data() { cout << "Data" << endl; }
    16. };
    17.  
    18. int main()
    19. {
    20. 	Data<int&, double*> d9;
    21.  
    22. 	return 0;
    23. }

     特化匹配的原则就是有匹配的就匹配的，没有匹配的，就凑合一下，走相对匹配的

    1.         const_iterator begin() const
    2.         {
    3.             return const_iterator(_head->_next);
    4.         }
    5.  
    6.         const_iterator end() const
    7.         {
    8.             return const_iterator(_head);
    9.         }
    10.  
    11.         iterator begin()
    12.         {
    13.             return iterator(_head->_next);
    14.         }
    15.  
    16.         iterator end()
    17.         {
    18.             return iterator(_head);
    19.         }

     比方说我们上面之前写的list中的迭代器，有const版本的和普通版本的，那如果只有const版本，那普通对象能调用吗？

    能调用！因为普通对象变成const对象，是权限的缩小，是允许的。

    那如果普通和const版本的迭代器都存在的时候，普通对象一定会去匹配普通版本的const。

    当我们如果想要让const对象和普通对象分开处理的时候，我们必须要分开去写。比方说我们想要对const不进行操作，但是对普通对象进行操作，我们就需要将const版本和普通版本的分开写出来。

    三、模板的分离编译

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

    typename和class的区别

    1. template<class T>
    2.     //平时typename和class没有区别，但是在这里有区别
    3.     //这个typename存在于这里是为了告诉编译器vector::iterator vector是一整个类型
    4.     //就是你制定一个还没有实例化的模板，然后你要去取里面的内嵌类型
    5.     // （在这个类里面定义的内部类，或者在这个类里面typedef的，这里我们的iterator就是一个内嵌类型）
    6.     //因为编译器区分不清楚你的iterator到底是一个类型还是一个变量
    7.     //因为静态的变量指定类域就可以访问，那这个iterator就变成一个变量了，所以编译器区分不清楚这是一个类型还是一个变量
    8.     //所以加一个typename来告诉编译器这是一个类型
    9.     typename vector::iterator vector::insert(typename vector::iterator pos, const T& x)
    10.     {
    11.         assert(pos >= _start);
    12.         assert(pos <= _finish);
    13.  
    14.         if (_finish == _end_of_storage)
    15.         {
    16.             size_t len = pos - _start;
    17.             reserve(capacity() == 0 ? 4 : capacity() * 2);
    18.             pos = _start + len;
    19.         }
    20.  
    21.         //
    22.         iterator end = _finish - 1;
    23.         while (end >= pos)
    24.         {
    25.             *(end + 1) = *end;
    26.             --end;
    27.         }
    28.         *pos = x;
    29.  
    30.         ++_finish;
    31.  
    32.         return pos;
    33.     }

    进一步看下面的例子

    1. template<class T>
    2. void PrintContainer(const list& lt)
    3. {
    4.     //这里编译器就区分不清楚这个const_iterator是变量还是类型
    5. 	list::const_iterator it = lt.begin();
    6. 	// ...
    7. }
    8.  
    9. int main()
    10. {
    11.  
    12. 	list<int> lt;
    13. 	PrintContainer(lt);
    14.  
    15. 	return 0;
    16. }

    1. template<class T>
    2. void PrintContainer(const list& lt)
    3. {
    4.     //typename告诉编译器，这个list::const_iterator是一个类型，不是静态变量
    5. 	typename list::const_iterator it = lt.begin();
    6. 	// ...
    7. }
    8.  
    9. int main()
    10. {
    11.  
    12. 	list<int> lt;
    13. 	PrintContainer(lt);
    14.  
    15. 	return 0;
    16. }

     

     声明和定义分离就会报错

    1. //这是测试程序
    2. int main()
    3. {
    4. 	zhuyuan::vector<int> v;
    5. 	v.push_back(1);
    6. 	v.push_back(2);
    7. 	v.push_back(3);
    8.  
    9. 	for (size_t i = 0; i < v.size(); ++i)
    10. 	{
    11. 		cout << v[i] << " ";
    12. 	}
    13. 	cout << endl;
    14.  
    15. 	return 0;
    16. }

    这是push_back的声明，放在vector.h文件中

    1. void push_back(const T& x);
    2. iterator insert(iterator pos, const T& x);

    这是push_back的定义，放在vector.cpp中

    1. template<class T>
    2.     void vector::push_back(const T& x)
    3.     {
    4.         insert(_finish, x);
    5.     }

    运行一下，直接报错，push_back链接错误

    链接错误都是有声明，找不到定义

    为什么声明和定义分离就链接错误了？

    这些函数调用都是call一个地址。

    构造函数，size函数，operator[]函数不会去链接，在vector.h中有定义。

    vector实例化时，这些成员函数也实例化，直接就有定义，编译阶段就确定地址了。

    但是push_back和insert这两个函数与上面不同，因为在vector.h中只有声明，没有定义，那么地址就只能在链接阶段去确认了。

    这里的报错说明，链接阶段找不到！

    1. template<class T>
    2.     void vector::push_back(const T& x)
    3.     {
    4.         insert(_finish, x);
    5.     }

    因为上面的模板的定义中的T在编译链接阶段是没办法确定的，那么就没办法实例化（根本不知道应该实例化成什么类型），所以我们的push_back就没有进符号表，所以也就没办法确定链接地址。

    如何解决？

    1.在同一个文件中分离声明和定义

    模板的声明和定义不要分离到.h和.cpp，但在同一个文件中可以分离。

    下面我们就是将相对较长的函数push_back，insert，和reserve函数封装在类的外面。

    1. #pragma once
    2. #include 
    3.  
    4. // 声明
    5. namespace zhuyuan
    6. {
    7.     template<class T>
    8.     class vector
    9.     {
    10.     public:
    11.         typedef T* iterator;
    12.  
    13.         vector()
    14.                 :_start(nullptr)
    15.                 , _finish(nullptr)
    16.                 , _end_of_storage(nullptr)
    17.         {}
    18.  
    19.         ~vector()
    20.         {
    21.             delete[] _start;
    22.             _start = _finish = _end_of_storage = nullptr;
    23.         }
    24.  
    25.         size_t capacity() const
    26.         {
    27.             return _end_of_storage - _start;
    28.         }
    29.  
    30.         const T& operator[](size_t pos) const
    31.         {
    32.             assert(pos < size());
    33.  
    34.             return _start[pos];
    35.         }
    36.  
    37.         T& operator[](size_t pos)
    38.         {
    39.             assert(pos < size());
    40.  
    41.             return _start[pos];
    42.         }
    43.  
    44.         size_t size() const
    45.         {
    46.             return _finish - _start;
    47.         }
    48.  
    49.         void push_back(const T& x);
    50.         iterator insert(iterator pos, const T& x);
    51.         void reserve(size_t n);
    52.  
    53.         friend void reserve(size_t n);
    54.     private:
    55.         iterator _start;
    56.         iterator _finish;
    57.         iterator _end_of_storage;
    58.     };
    59.  
    60.  
    61.  
    62.     //以下是上面的函数的定义
    63.     //是放置在类的外部的
    64.     //长的函数可以单独拎出来，让短的函数形成内联
    65.     template<class T>
    66.     void vector::push_back(const T& x)
    67.     {
    68.         insert(_finish, x);
    69.     }
    70.  
    71.     template<class T>
    72.     typename vector::iterator vector::insert(typename vector::iterator pos, const T& x)
    73.     {
    74.         assert(pos >= _start);
    75.         assert(pos <= _finish);
    76.  
    77.         if (_finish == _end_of_storage)
    78.         {
    79.             size_t len = pos - _start;
    80.             reserve(capacity() == 0 ? 4 : capacity() * 2);
    81.             pos = _start + len;
    82.         }
    83.  
    84.         //
    85.         iterator end = _finish - 1;
    86.         while (end >= pos)
    87.         {
    88.             *(end + 1) = *end;
    89.             --end;
    90.         }
    91.         *pos = x;
    92.  
    93.         ++_finish;
    94.  
    95.         return pos;
    96.  
    97.  
    98.     }
    99.  
    100.     template<class T>
    101.     void vector::reserve(size_t n)
    102.     {
    103.         if (n > capacity())
    104.         {
    105.             size_t sz = size();
    106.             T* tmp = new T[n];
    107.             if (_start)
    108.             {
    109.                 //memcpy(tmp, _start, sizeof(T)*sz);
    110.                 for (size_t i = 0; i < sz; ++i)
    111.                 {
    112.                     tmp[i] = _start[i]; // T对象是自定义类型时，调用T对象operator=
    113.                 }
    114.                 delete[] _start;
    115.             }
    116.  
    117.             _start = tmp;
    118.             _finish = _start + sz;
    119.             _end_of_storage = _start + n;
    120.         }
    121.     }
    122. }

    测试代码

    1. int main()
    2. {
    3. 	zhuyuan::vector<int> v;
    4. 	v.push_back(1);
    5. 	v.push_back(2);
    6. 	v.push_back(3);
    7.  
    8. 	for (size_t i = 0; i < v.size(); ++i)
    9. 	{
    10. 		cout << v[i] << " ";
    11. 	}
    12. 	cout << endl;
    13. 	return 0;
    14. }

    2.显式实例化（不推荐）

    这里我们显式实例化这一个类，其中的全部方法都会被实例化

    1. //显式实例化
    2.     template class vector<int> ;

    但是显式实例化的话就将这个实例化给写死了，不能灵活地变化，换一个类型就要实例化一次，太麻烦了。

    模板总结

    【优点】
    1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
    2. 增强了代码的灵活性
    【缺陷】
    1. 模板会导致代码膨胀问题，也会导致编译时间变长
    2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误

  • 相关阅读:
    举个栗子~Minitab 技巧（5）：掌握常用快捷键，提高统计分析效率
    动态RDLC报表（四）
    【Unity】Inspector排版扩展学习初探
    盘一盘高性能设计的哪些点（二）
    ssm+微信小程序网易云音乐设计与实现毕业设计源码261620
    计算机网络-性能指标
    跨线程访问控件的操作
    博流BL602开发一 编译与实例
    Qt通过正则表达式筛选出字符串中的手机号
    【优化调度】基于与学算法实现库存优化控制问题附matlab代码
  • 原文地址：https://blog.csdn.net/weixin_62684026/article/details/127097641