【c++】模板进阶-阿里云开发者社区

【c++】模板进阶

2024-06-26 5

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 【c++】模板进阶

1. 非类型模板参数

定义一个数组类

#include<iostream>
using namespace std;
#define N   1000
namespace zjw
{   
  // 定义一个模板类型的静态数组
  template<class T>
  class array
  {
  public:
    T& operator[](size_t index) { return _array[index]; }
    const T& operator[](size_t index)const { return _array[index]; }
    size_t size()const { return _size; }
    bool empty()const { return 0 == _size; }
  private:
    T _array[N];
    size_t _size=N;
  };
}

我们需要两个对象，分别数组大小为10，和1000的话，只用上面一个类是不够的，两个类给不同的N值.

这里我们可以用非类型模板参数来解决这个问题，只需要一个类。

在这之前有一个知识点

#include<iostream>
using namespace std;
#include<iostream>
using namespace std;
#define N   1000
namespace zjw
{
  // 定义一个模板类型的静态数组
  template<class T>
  class array
  {
  public:
    T& operator[](size_t index) { return _array[index]; }
    const T& operator[](size_t index)const { 
      size(1);//这里故意写错
      return _array[index]; }
    size_t size()const { return _size; }
    bool empty()const { return 0 == _size; }
  private:
    T _array[N];
    size_t _size = N;
  };
}
int main()
{
  zjw::array<int>st1;
  cout << st1.size() << endl;
}

size(1);//这里故意写错，但是在实例化st1,它只对要用的函数实例化，并不会检查其他类成员函数内部有没有错误。在operator[]中，size(1);//这里故意写错，就不会报错。而编译器只会对大体的结构进行检查，比如说哪个类成员函数少一个分号。

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

#include<iostream>
using namespace std;
namespace zjw
{
  // 定义一个模板类型的静态数组
  template<class T, size_t N = 10>
  class array
  {
  public:
    T& operator[](size_t index) { return _array[index]; }
    const T& operator[](size_t index)const { return _array[index]; }
    size_t size()const { return _size; }
    bool empty()const { return 0 == _size; }
  private:
    T _array[N];
    size_t _size=N;
  };
}

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

#include<iostream>
using namespace std;
namespace zjw
{
  
  template<string str>
     class A
   { 
    };
}
int main()
{
  zjw::A<"11111">st3;
}

2. 类模板的特化

上篇文章我们使用仿函数来给日期类比较大小，现在我们可以使用函数模板来给日期类比较大小

先定义一个日期类

class Date
{
public:
  friend ostream& operator<<(ostream& _cout, const Date& d);
  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);
  }
private:
  int _year;
  int _month;
  int _day;
};

然后实现函数模板比较大小

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

主函数

int main()
{
  Date d1(2024, 2, 10);
  Date d2(2024, 3, 10);
  cout << Less(d1, d2) << endl;
}

此时d1<d2返回1.

实例化过程如下：

如果我们要给日期类指针进行比较大小

这里我们可以用特化

函数模板的特化步骤：

必须要先有一个基础的函数模板

关键字template后面接一对空的尖括号<>

函数名后跟一对尖括号，尖括号中指定需要特化的类型

函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

class Date
{
public:
  friend ostream& operator<<(ostream& _cout, const Date& d);
  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);
  }
private:
  int _year;
  int _month;
  int _day;
};
template<class T>
bool Less(T left, T right)
{
return left < right;
}
// 特化，针对某些特殊类型可以进行特殊处理
template<>
bool Less<Date*>(Date* left, Date* right)
{
  return *left < *right;
}
int main()
{
  Date d1(2024, 2, 10);
  Date d2(2024, 3, 10);
  Date* p1 = new Date(2022, 7, 7);
  Date* p2 = new Date(2022, 7, 8);
   cout << Less(p1,p2) << endl;
}

或者这样类似函数重载，匹配最符合的，有现成的使用现成的

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

特化，针对某些特殊类型可以进行特殊处理

类模板的特化

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

template<class T1, class T2>
class Data
{
public:
  Data() { cout << "Data<T1, T2>" << endl; }
private:
  T1 _d1;
  T2 _d2;
};
// 全特化
template<>
class Data<int, char>
{
public:
  Data() { cout << "Data<int, char>" << endl; }
};
int main()
{
  
    
    Data<int, char> d2;
    
}

半特化->部分特化

将模板参数类表中的一部分参数特化。

template<class T1, class T2>
class Data
{
public:
  Data() { cout << "Data<T1, T2>" << endl; }
private:
  T1 _d1;
  T2 _d2;
};
// 半特化/偏特化
template<class T1>
class Data<T1, char>
{
public:
  Data() { cout << "Data<T1, char>" << endl; }
};

半特化->参数更进一步的限制

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

本。

template<class T1, class T2>
class Data
{
public:
  Data() { cout << "Data<T1, T2>" << endl; }
private:
  T1 _d1;
  T2 _d2;
};
// 半特化/偏特化，不一定是特化部分参数，可能是对参数的进一步限制
template<class T1, class T2>
class Data<T1*, T2*>
{
public:
  Data() { cout << "Data<T1*, T2*>" << endl; }
};

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

5. 模板的分离编译

首先声明定义不分离：不会出现问题

声明定义分离：

链接出现问题，原因是在源.cpp中调用st1.size()会call这个函数的地址，在编译时候，去array.h中发现他只有声明，编译器会以为函数地址会在其他cpp中，等到链接的时候在call size函数地址，但是等到链接时，在cpp之间是分离的，，所以源.cpp中st1实例化的参数<int,10>不会给array.cpp中<T,N>;模板没有实例化，所以array.cpp中的size()函数没有地址，出现了链接错误。

解决方法：显示实例化

反汇编观察size()函数地址，call size()函数地址说明要调用该函数

文章标签：

C++

编译器

关键词：

C++模板

【c++】模板进阶

1. 非类型模板参数

2. 类模板的特化

5. 模板的分离编译

热门文章

最新文章

相关课程

相关电子书