从C语言到C++_21(模板进阶+array)+相关笔试题（下）-阿里云开发者社区

从C语言到C++_21(模板进阶+array)+相关笔试题（上）：https://developer.aliyun.com/article/1521897

2.2 类模板的特化

刚才函数模板不一定非要特化，因为可以写一个具体实现的函数。

但是类模板我们没法实现一个具体的实际类型，就必须要特化了。

我们前面实现的仿函数（类模板）也有这样的问题：

#include <iostream>
using namespace std;
 
class Date // 简化的日期类
{
public:
  Date(int year, int month, int day)
    :_year(year)
    , _month(month)
    , _day(day)
  {}
 
  bool operator<(const Date& d) const
  {
    if ((_year < d._year)
      || (_year == d._year && _month < d._month)
      || (_year == d._year && _month == d._month && _day < d._day))
    {
      return true;
    }
    else
    {
      return false;
    }
  }
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;
}
 
类模板
template<class T>
struct Less2
{
  bool operator()(const T& x1, const T& x2) const
  {
    return x1 < x2;
  }
};
 
int main()
{
  Less2<Date> LessFunc1;
  Date d1(2023, 1, 1);
  Date d2(2023, 1, 2);
  cout << LessFunc1(d1, d2) << endl;  // 可以比较，结果正确
 
  Less2<Date*> LessFunc2;
  Date* p2 = &d2;
  Date* p1 = &d1;
  cout << LessFunc2(p1, p2) << endl;  // 可以比较，结果错误
 
  return 0;
}

加上类模板的特化：

#include <iostream>
using namespace std;
 
class Date // 简化的日期类
{
public:
  Date(int year, int month, int day)
    :_year(year)
    , _month(month)
    , _day(day)
  {}
 
  bool operator<(const Date& d) const
  {
    if ((_year < d._year)
      || (_year == d._year && _month < d._month)
      || (_year == d._year && _month == d._month && _day < d._day))
    {
      return true;
    }
    else
    {
      return false;
    }
  }
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;
}
 
类模板
template<class T>
struct Less2
{
  bool operator()(const T& x1, const T& x2) const
  {
    return x1 < x2;
  }
};
template<>// 类模板特化
struct Less2<Date*>
{
  bool operator()(const Date* x1, const Date* x2) const
  {
    return *x1 < *x2;
  }
};
 
int main()
{
  Less2<Date> LessFunc1;
  Date d1(2023, 1, 1);
  Date d2(2023, 1, 2);
  cout << LessFunc1(d1, d2) << endl;  // 可以比较，结果正确
 
  Less2<Date*> LessFunc2;
  Date* p2 = &d2;
  Date* p1 = &d1;
  cout << LessFunc2(p1, p2) << endl;  // 可以比较，结果错误，加上类模板特化后结果正确
 
  return 0;
}

2.3 全特化和偏特化(半特化)

全特化和偏特化的概念和缺省值很像，前面我们写的都叫作模板的全特化。

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

偏特化（又称半特化）：将部分参数类表中的一部分参数特化。

（半特化并不是特化一半，就像半缺省并不是缺省一半一样）

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

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

// 将第二个参数特化为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); // 调用特化的指针版本
}

放一段代码体会偏特化的花哨玩法：

#include <iostream>
using namespace std;
 
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; }
private:
  /*int _d1;
  char _d2;*/
};
 
// 偏特化
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; }
};
 
template<class T1, class T2>
class Data<T1&, T2&>
{
public:
  Data() { cout << "Data<T1&, T2&>" << endl; }
};
 
template<class T1, class T2>
class Data<T1&, T2*>
{
public:
  Data() { cout << "Data<T1&, T2*>" << endl; }
};
 
int main()
{
  Data<int, int> d0;
  Data<double, int> d1;
 
  Data<int, char> d2;
 
  Data<double, double> d3;
  Data<double*, double*> d4;
  Data<int*, char*> d5;
  Data<int*, char> d6;
 
  Data<int&, char&> d7;
  Data<int&, double&> d8;
  Data<int&, double*> d9;
 
  return 0;
}

这就对应说过的类型匹配原则，有更匹配的就去调用它，没有就逐层递减去匹配。

3. 模板关于分离编译

什么是分离编译？

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，

最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

先说结论：模板是不支持分离编译的。

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

如上图所示，在template.cpp源文件中定义了Sub函数，并在template.h头文件中进行了声明。

但是在编译过程中，编译器是对各个源文件进行单独编译的，template.cpp源文件进行编译的过程中，没有检测到Sub函数模板的实例化，所以不会生成对应的代码，在main.cpp源文件中进行调用，链接阶段便会出错。如图：

理解两个概念：

导出符号表：编译完成后该源文件中地址（函数定义的位置）已经确定的函数
未解决符号表：源文件中地址还没有确定的函数

这里main.cpp源文件编译完成后，没有找到Sub函数的定义，但是由于头文件中进行了声明，在预处理阶段头文件中的声明会拷贝到源文件中，所以并不会立即报错，而是将Sub函数放在未解决符号表中，链接阶段，在template.cpp文件的导出符号表中找Sub函数的入口地址，而如果Sub函数没有生成则会报错。

解决方法：

① 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。

② 模板定义的位置显式实例化。这种方法不实用，不推荐使用。

4. 模板优缺点

【优点】

① 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库（STL）因此而产生。

② 增强了代码的灵活性。

【缺点】

① 模板会导致代码膨胀问题，也会导致编译时间变长。

② 出现模板编译错误时，错误信息非常凌乱，不易定位错误。

5. 模板相关笔试题

1. 下列的模板声明中，其中几个是正确的（）

1)template
 
2)template<T1,T2>
 
3)template<class T1,T2>
 
4)template<class T1,class T2>
 
5)template<typename T1,T2>
 
6)template<typename T1,typename T2>
 
7)template<class T1,typename T2>
 
8)<typename T1,class T2>
 
9)template<typeaname T1, typename T2, size_t N>
 
10)template<typeaname T, size_t N=100, class _A=alloc<T>>
 
11)template<size_t N>

A.3

B.4

C.5

D.6

2. 以下程序运行结果正确的是( )

#include <iostream>
using namespace std;
 
template<typename Type>
Type Max(const Type& a, const Type& b)
{
  cout << "This is Max<Type>" << endl;
  return a > b ? a : b;
}
 
template<>
int Max<int>(const int& a, const int& b)
{
  cout << "This is Max<int>" << endl;
  return a > b ? a : b;
}
 
template<>
char Max<char>(const char& a, const char& b)
{
  cout << "This is Max<char>" << endl;
  return a > b ? a : b;
}
 
int Max(const int& a, const int& b)
{
  cout << "This is Max" << endl;
  return a > b ? a : b;
}
 
int main()
{
  Max(10, 20);
  Max(12.34, 23.45);
  Max('A', 'B');
  Max<int>(20, 30);
  return 0;
}

A.This is Max This is Max<Type> This is Max<char> This is Max<int>

B.This is Max<int> This is Max<Type> This is Max<char> This is Max<int>

C.This is Max This is Max<int> This is Max<char> This is Max<int>

D.This is Max This is Max<Type> This is Max<char> This is Max

3. 关于模板的编译说法错误的是( )

A.模板在.h文件中声明，在.cpp里面实现

B.模板程序一般直接在一个文件里面进行定义与实现

C.不久的将来，编译器有望支持export关键字，实现模板分离编译

D.模板不能分离编译，是因为模板程序在编译过程中需要经过两次编译

4. 以下程序运行结果正确的是( )

#include <iostream>
using namespace std;
 
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, 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;
};
 
int main()
{
  Data<double, int> d1;
  Data<int, double> d2;
  Data<int*, int*> d3;
  Data<int&, int&> d4(1, 2);
  return 0;
}

A.Data<T1, T2> Data<T1, int> Data<T1*, T2*> Data<T1&, T2&>

B.Data<T1, int> Data<T1, T2> Data<T1&, T2&> Data<T1*, T2*>

C.Data<T1, int> Data<T1, T2> Data<T1*, T2*> Data<T1&, T2&>

D.Data<T1, T2> Data<T1, T2> Data<T1*, T2*> Data<T1&, T2&>

答案：

1. D

分析:正确的定义为：4 6 7 9 10 11，一共6个

2. A

分析:Max(10,20); //能够直接匹配int参数，调动非模板函数

Max(12.34,23.45); //double类型参数没有最佳匹配函数，此时只能调动模板函数

Max('A','B'); //能够直接匹配char参数,调动非模板函数

Max<int>(20,30); //由于直接实例化了函数，因此要调动模板函数，但是，由于进行函数的int特化，所以会调动特化版本的模板函数

3. A

A.模板不支持分离编译，所以不能在.h声明，在.cpp实现

B.由于不支持分离编译，模板程序一般只能放在一个文件里实现

C.不支持分离编译并不是语法错误，而是暂时的编译器不支持，不久将来，或许会被支持

D.模板程序被编译两次，这是不能分离编译的原因所在

4. C

分析:Data<double, int> d1; // 调用特化的int版本

Data<int, double> d2; // 调用基础的模板

Data<int *, int*> d3; // 调用特化的指针版本

Data<int&, int&> d4(1, 2); //调用特化的引用版本

本篇完。

下一部分：C++中的继承，讲完继承讲多态。

从C语言到C++_21(模板进阶+array)+相关笔试题（下）

2.2 类模板的特化

2.3 全特化和偏特化(半特化)

3. 模板关于分离编译

4. 模板优缺点

5. 模板相关笔试题

本篇完。

热门文章

最新文章

相关课程

相关电子书

相关实验场景