AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

2024-05-28 54
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 从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++
编译器
关键词：
C++ array
C语言C++
C++模板
C++ c语言
C语言笔试题
GR鲸鱼
目录
相关文章
半截诗
|
2月前
|
存储 算法 C++
C++ STL 初探：打开标准模板库的大门
C++ STL 初探：打开标准模板库的大门
半截诗
112 10
徐霞客320
|
2月前
|
安全 编译器 C语言
C++入门1——从C语言到C++的过渡
C++入门1——从C语言到C++的过渡
徐霞客320
69 2
chian-ocean
|
26天前
|
安全 编译器 C++
【C++11】可变模板参数详解
本文详细介绍了C++11引入的可变模板参数，这是一种允许模板接受任意数量和类型参数的强大工具。文章从基本概念入手，讲解了可变模板参数的语法、参数包的展开方法，以及如何结合递归调用、折叠表达式等技术实现高效编程。通过具体示例，如打印任意数量参数、类型安全的`printf`替代方案等，展示了其在实际开发中的应用。最后，文章讨论了性能优化策略和常见问题，帮助读者更好地理解和使用这一高级C++特性。
chian-ocean
42 4
chian-ocean
|
26天前
|
算法 编译器 C++
【C++】模板详细讲解（含反向迭代器）
C++模板是泛型编程的核心，允许编写与类型无关的代码，提高代码复用性和灵活性。模板分为函数模板和类模板，支持隐式和显式实例化，以及特化（全特化和偏特化）。C++标准库广泛使用模板，如容器、迭代器、算法和函数对象等，以支持高效、灵活的编程。反向迭代器通过对正向迭代器的封装，实现了逆序遍历的功能。
chian-ocean
34 3
oioihoii
|
4天前
|
存储 对象存储 C++
C++ 中 std::array＜int, array_size＞ 与 std::vector＜int＞ 的深入对比
本文深入对比了 C++ 标准库中的 `std::array` 和 `std::vector`，从内存管理、性能、功能特性、使用场景等方面详细分析了两者的差异。`std::array` 适合固定大小的数据和高性能需求，而 `std::vector` 则提供了动态调整大小的灵活性，适用于数据量不确定或需要频繁操作的场景。选择合适的容器可以提高代码的效率和可靠性。
oioihoii
22 0
LuckiBit
|
19天前
|
算法 编译器 C语言
【C语言】C++ 和 C 的优缺点是什么？
C 和 C++ 是两种强大的编程语言，各有其优缺点。C 语言以其高效性、底层控制和简洁性广泛应用于系统编程和嵌入式系统。C++ 在 C 语言的基础上引入了面向对象编程、模板编程和丰富的标准库，使其适合开发大型、复杂的软件系统。 在选择使用 C 还是 C++ 时，开发者需要根据项目的需求、语言的特性以及团队的技术栈来做出决策。无论是 C 语言还是 C++，了解其优缺点和适用场景能够帮助开发者在实际开发中做出更明智的选择，从而更好地应对挑战，实现项目目标。
LuckiBit
44 0
ephemerals__
|
29天前
|
编译器 C++
【c++】模板详解(1)
本文介绍了C++中的模板概念，包括函数模板和类模板，强调了模板作为泛型编程基础的重要性。函数模板允许创建类型无关的函数，类模板则能根据不同的类型生成不同的类。文章通过具体示例详细解释了模板的定义、实例化及匹配原则，帮助读者理解模板机制，为学习STL打下基础。
ephemerals__
31 0
白子寰
|
2月前
|
编译器 程序员 C++
【C++打怪之路Lv7】-- 模板初阶
【C++打怪之路Lv7】-- 模板初阶
白子寰
18 1
c的前世今生
|
2月前
|
C语言 C++
C 语言的关键字 static 和 C++ 的关键字 static 有什么区别
在C语言中，`static`关键字主要用于变量声明，使得该变量的作用域被限制在其被声明的函数内部，且在整个程序运行期间保留其值。而在C++中，除了继承了C的特性外，`static`还可以用于类成员，使该成员被所有类实例共享，同时在类外进行初始化。这使得C++中的`static`具有更广泛的应用场景，不仅限于控制变量的作用域和生存期。
c的前世今生
67 10
徐霞客320
|
2月前
|
编译器 C语言 C++
C++入门6——模板（泛型编程、函数模板、类模板）
C++入门6——模板（泛型编程、函数模板、类模板）
徐霞客320
60 0
C++入门6——模板（泛型编程、函数模板、类模板）