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

C++模板元模板实战书籍讲解第一章题目讲解

2023-11-20 78
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C++模板元模板实战书籍讲解第一章题目讲解

第一题

对于元函数来说，数值与类型其实并没有特别明显的差异：元函数的输入可以是数值或类型，对应的变换可以在数值与类型之间进行。比如可以构造一个元函数，输入是一个类型，输出是该类型变量所占空间的大小---------这就是一个典型的从类型变换为数值的元函数。尝试构造该函数，并测试是否能行。

C++代码示例

#include <iostream>
#include <type_traits>
template <typename T>
struct TypeSize {
    static constexpr size_t value = sizeof(T);
};
int main() {
    std::cout << TypeSize<int>::value << std::endl;  // 输出：4（int 类型在大多数平台上占用4个字节）
    std::cout << TypeSize<double>::value << std::endl;  // 输出：8（double 类型在大多数平台上占用8个字节）
    std::cout << TypeSize<char>::value << std::endl;  // 输出：1（char 类型在大多数平台上占用1个字节）
    return 0;
}

输出结果：

代码详解：


在上面的代码中，我们定义了一个名为TypeSize的模板结构体，它有一个静态成员变量value，其默认值是sizeof(T)，其中T是TypeSize的模板参数类型。通过sizeof运算符，我们可以在编译时获取类型T的大小，并将其保存在value中。


在main函数中，我们分别测试了int、double和char类型的大小，并使用std::cout输出结果。可以看到，对于每个类型，我们都成功地获取了其在内存中所占空间的大小。

第二题

作为进一步的扩展，元函数的输入参数甚至可以是类型与数值混合的。尝试构造一个元函数，其输入参数为一个类型以及

C++代码示例

#include <iostream>
#include <type_traits>
template <typename T, size_t N>
struct CheckSize {
    static constexpr bool value = sizeof(T) == N;
};
int main() {
    std::cout << std::boolalpha;
    std::cout << CheckSize<int, 4>::value << std::endl;  // 输出：true（int 类型在大多数平台上占用4个字节）
    std::cout << CheckSize<double, 8>::value << std::endl;  // 输出：true（double 类型在大多数平台上占用8个字节）
    std::cout << CheckSize<char, 2>::value << std::endl;  // 输出：false（char 类型在大多数平台上占用1个字节）
    return 0;
}

输出结果：

代码详解：

我们使用了一个元函数 CheckSize ，结构体 CheckSize 接受两个模板参数：类型 T 和大小 N。在元函数中，我们使用 sizeof 运算符计算类型 T 的大小，并将其与整数 N 进行比较。如果相等，则元函数的静态成员变量 value 设置为 true，否则设置为 false。

第三题

3.1 使用std::integral_constant模板类

#include <iostream>
#include <type_traits>
template <typename T, size_t N>
struct CheckSize : std::integral_constant<bool, sizeof(T) == N> {};
int main() {
    std::cout << std::boolalpha;
    std::cout << CheckSize<int, 4>::value << std::endl;  // 输出：true（int 类型在大多数平台上占用4个字节）
    std::cout << CheckSize<double, 8>::value << std::endl;  // 输出：true（double 类型在大多数平台上占用8个字节）
    std::cout << CheckSize<char, 2>::value << std::endl;  // 输出：false（char 类型在大多数平台上占用1个字节）
    return 0;
}

使用std::integral_constant模板类来实现元函数CheckSize。CheckSize结构体继承自std::integral_constant，并提供两个模板参数：bool类型表示返回类型，以及sizeof(T) == N作为值。通过继承自std::integral_constant，我们可以从CheckSize<T, N>直接访问value成员变量。

3.2 使用std::conditional结合std::is_same判断

#include <iostream>
#include <type_traits>
template<typename T, size_t N>
struct CheckSize {
    static constexpr bool value = std::is_same_v<sizeof(T), N>;
};
int main() {
    std::cout << std::boolalpha;
    std::cout << CheckSize<int, 4>::value << std::endl;            // 输出：true（int 类型在大多数平台上占用4个字节）
    std::cout << CheckSize<double, 8>::value << std::endl;         // 输出：true（double 类型在大多数平台上占用8个字节）
    std::cout << CheckSize<char, 2>::value << std::endl;           // 输出：false（char 类型在大多数平台上占用1个字节）
    return 0;
}

使用了std::conditional结合std::is_same检查类型大小。std::is_same_v是一个用于判断两个类型是否相同的模板，sizeof(T)表示类型 T 的大小，在此和 N 进行比较。如果两者相同，则value被设置为 true，否则被设置为 false。


总结

这些是更特殊或不太常见的元函数表示形式，这些形式可能适用于某些特定的使用场景或要求。

第四题

本章讨论了以类模板作为元函数的输出，尝试构造一个元函数，它接收输入后会返回一个元函数，后者接收输入后会再返回一个元函数------这仅仅是一个联系，不必过于在意其应用场景

C++代码示例

#include <iostream>
#include <functional>
template <typename Input>
struct FirstLayer {
    template <typename Func>
    struct SecondLayer {
        template <typename... Args>
        constexpr auto operator()(Args&&... args) const {
            return Func{}(std::forward<Args>(args)...);
        }
    };
    template <typename Func>
    constexpr auto operator()(Func) const {
        return SecondLayer<Func>{};
    }
};
struct MyFunction {
    template <typename... Args>
    constexpr auto operator()(Args&&... args) const {
        return sizeof...(Args);
    }
};
int main() {
    FirstLayer<int> first;
    auto second = first(MyFunction{});
    std::cout << second(1, 2, 3, 4, 5) << std::endl;  // 输出：5（返回传入参数的数量）
    return 0;
}

输出结果：

代码详解：

示例中，FirstLayer 是一个元函数，它接收一个输入类型 Input。FirstLayer 结构体中定义了一个内部模板结构体 SecondLayer，它接收一个元函数类型 Func。SecondLayer 结构体中定义了一个函数调用运算符 operator()，它接收任意参数 Args...，并通过调用 Func 来实现对元函数的调用。


FirstLayer 还定义了一个函数调用运算符 operator()，它接收一个元函数类型 Func，并返回一个 SecondLayer<Func> 对象，即返回一个闭包（closure）元函数。


在 main() 函数中，我们先创建一个 FirstLayer<int> 对象 first。然后，我们通过调用 first(MyFunction{}) 来传递一个 MyFunction 元函数对象，得到一个 SecondLayer 对象 second。最后，我们通过调用 second 来调用传入的 MyFunction 元函数，并传递参数 1, 2, 3, 4, 5。


运行示例代码后，将输出 5，表示传入的参数数量为 5。


这个示例就是一个接收输入并返回元函数的元函数的实现。当 FirstLayer 元函数接收一个输入类型后，它返回一个闭包元函数 SecondLayer。你可以继续调用 SecondLayer 元函数，并传递其他的元函数来实现更多的函数组合和操作。

第五题

使用SFINAE构造一个元函数：输入一个类型T，当T存在子类型type时该元函数返回true，否则返回false。

C++代码示例

#include <iostream>
#include <type_traits>
template <typename T>
struct HasType {
    // 检查 SFINAE 的辅助函数
    template <typename U>
    static std::true_type test(typename U::type*);
    template <typename U>
    static std::false_type test(...);
    static constexpr bool value = decltype(test<T>(nullptr))::value;
};
// 测试用例
struct A {
    using type = int;
};
struct B {};
int main() {
    std::cout << std::boolalpha;
    std::cout << HasType<A>::value << std::endl;  // 输出：true（A 类型存在名为 type 的子类型）
    std::cout << HasType<B>::value << std::endl;  // 输出：false（B 类型不存在名为 type 的子类型）
    return 0;
}

输出结果：

代码详解：


示例中，HasType 是一个元函数，用于检查类型 T 是否具有名为 type 的子类型。我们先定义了两个辅助函数 test，一个接收具有 type 子类型的输入类型 U（使用 typename U::type* 作为函数参数），另一个使用 ... 表示可变参的占位符。在 HasType 元函数中，test<T>(nullptr) 这一表达式启用了 SFINAE 机制，如果传递的类型具有名为 type 的子类型，则会选择第一个辅助函数进行调用，否则会选择第二个辅助函数。使用 decltype 和 std::true_type、std::false_type 来从辅助函数的返回类型中提取布尔值。


在测试用例中，我们分别检查了类型 A 和类型 B。因为类型 A 存在名为 type 的子类型，所以 HasType<A>::value 的结果为 true。而类型 B 不存在名为 type 的子类型，所以 HasType<B>::value 的结果为 false。

第六题

使用在本章中学到的循环代码书写方式，编写一个元函数，输入一个类型数组，输出一个无符号整形数组，输出数组中的每个元素表示输入数组中相应类型变量的大小。

C++代码示例

#include <iostream>
#include <utility>
#include <array>
template <typename... Types>
struct SizeOfArray;
// 基本情况：处理空类型数组
template <>
struct SizeOfArray<> {
    using type = std::array<std::size_t, 0>;
};
// 递归情况：处理非空类型数组
template <typename T, typename... Types>
struct SizeOfArray<T, Types...> {
    using type = std::array<std::size_t, sizeof...(Types)+1>;
};
// 辅助函数，打印无符号整型数组
template <std::size_t N, std::size_t... Sizes>
void printSizes(const std::array<std::size_t, N>& sizes, std::index_sequence<Sizes...>) {
    ((std::cout << sizes[Sizes] << ' '), ...);
    std::cout << std::endl;
}
int main() {
    using MyTypes = std::tuple<int, double, bool, char>;
    using Sizes = typename SizeOfArray<int, double, bool, char>::type;
    Sizes sizes;
    sizes[0] = sizeof(int);
    sizes[1] = sizeof(double);
    sizes[2] = sizeof(bool);
    sizes[3] = sizeof(char);
    printSizes(sizes, std::make_index_sequence<sizes.size()>());  // 输出：4 8 1 1
    return 0;
}

输出结果：

代码详解：

在这段代码中，我们定义了一个 SizeOfArray 结构体，用于计算类型数组的大小。它通过递归方式处理类型数组，当类型数组为空时，返回一个大小为 0 的 std::array，当类型数组非空时，返回一个大小为 sizeof...(Types)+1 的 std::array，其中 sizeof...(Types) 是类型数组的元素个数。


在 main 函数中，我们定义了一个类型数组 MyTypes，其中包含了 int、double、bool 和 char 类型。然后，我们使用 SizeOfArray 结构体计算 MyTypes 数组中各个类型的大小，并将它们存储在 Sizes 结构体中。


接下来，我们使用 sizeof 操作符获取每个类型的大小，并将它们存储在 sizes 数组中的相应位置。


最后，我们调用 printSizes 函数，打印 sizes 数组中的每个元素。这里使用了 std::make_index_sequence 来生成一个索引序列，使得我们可以使用折叠表达式在 printSizes 函数中依次访问 sizes 数组中的元素。

第七题

使用分支短路逻辑实现一个元函数，给定一个整数序列，判断其中是否存在值为1的元素。如果存在，就返回true，否则返回false

C++代码示例

#include <iostream>
// 终止条件，判断最后一个元素是否等于 1
template <int Last>
bool hasOne() {
    return Last == 1;
}
// 递归情况，判断当前元素是否等于 1，并继续判断后面的元素
template <int First, int Second, int... Rest>
bool hasOne() {
    return (First == 1) || hasOne<Second, Rest...>();
}
int main() {
    bool result1 = hasOne<1, 2, 3, 4>();       // 序列中存在值为1的元素，返回true
    bool result2 = hasOne<2, 3, 4, 5>();       // 序列中不存在值为1的元素，返回false
    std::cout << "Result 1: " << std::boolalpha << result1 << std::endl;
    std::cout << "Result 2: " << std::boolalpha << result2 << std::endl;
    return 0;
}

输出结果：

代码详解：

第一个版本是终止条件，用于判断最后一个元素是否等于1。在这个版本中，我们只有一个模板参数 Last，当 Last 等于 1 时，返回 true。


第二个版本是递归情况，用于判断当前元素是否等于1，并继续判断后面的元素。在这个版本中，我们有三个模板参数，分别代表当前元素 First、下一个元素 Second，以及剩余的元素 Rest...。在递归调用时，我们将 Second 作为新的 First，并继续判断后面的元素。


通过这段代码，我们可以正确判断整数序列中是否存在值为1的元素。


在 main 函数中，我们使用两个示例来测试 hasOne 元函数。第一个示例传入的序列为 <1, 2, 3, 4>，其中存在值为1的元素，因此返回 true。第二个示例传入的序列为 <2, 3, 4, 5>，其中不存在值为1的元素，因此返回 false。

总结

后续会开始陆续更新第二章，如果有需要博主讲解其他书也可以私信我！！！

文章标签：
C++
存储
测试技术
索引
关键词：
C++模板
C++实战
C++题目
C++模板实战
C++模板元
Fuxi-
目录
相关文章
羑悻的小杀马特
|
2天前
|
编译器 C++
㉿㉿㉿c++模板的初阶（通俗易懂简化版）㉿㉿㉿
㉿㉿㉿c++模板的初阶（通俗易懂简化版）㉿㉿㉿
羑悻的小杀马特
21 14
chian-ocean
|
3月前
|
安全 编译器 C++
【C++11】可变模板参数详解
本文详细介绍了C++11引入的可变模板参数，这是一种允许模板接受任意数量和类型参数的强大工具。文章从基本概念入手，讲解了可变模板参数的语法、参数包的展开方法，以及如何结合递归调用、折叠表达式等技术实现高效编程。通过具体示例，如打印任意数量参数、类型安全的`printf`替代方案等，展示了其在实际开发中的应用。最后，文章讨论了性能优化策略和常见问题，帮助读者更好地理解和使用这一高级C++特性。
chian-ocean
111 4
chian-ocean
|
3月前
|
算法 编译器 C++
【C++】模板详细讲解（含反向迭代器）
C++模板是泛型编程的核心，允许编写与类型无关的代码，提高代码复用性和灵活性。模板分为函数模板和类模板，支持隐式和显式实例化，以及特化（全特化和偏特化）。C++标准库广泛使用模板，如容器、迭代器、算法和函数对象等，以支持高效、灵活的编程。反向迭代器通过对正向迭代器的封装，实现了逆序遍历的功能。
chian-ocean
47 3
阿里云开发者
|
3月前
|
自然语言处理 编译器 Linux
告别头文件，编译效率提升 42%！C++ Modules 实战解析 | 干货推荐
本文中，阿里云智能集团开发工程师李泽政以 Alinux 为操作环境，讲解模块相比传统头文件有哪些优势，并通过若干个例子，学习如何组织一个 C++ 模块工程并使用模块封装第三方库或是改造现有的项目。
阿里云开发者
297 8
ephemerals__
|
3月前
|
编译器 C++
【c++】模板详解(1)
本文介绍了C++中的模板概念，包括函数模板和类模板，强调了模板作为泛型编程基础的重要性。函数模板允许创建类型无关的函数，类模板则能根据不同的类型生成不同的类。文章通过具体示例详细解释了模板的定义、实例化及匹配原则，帮助读者理解模板机制，为学习STL打下基础。
ephemerals__
45 0
白子寰
|
4月前
|
编译器 程序员 C++
【C++打怪之路Lv7】-- 模板初阶
【C++打怪之路Lv7】-- 模板初阶
白子寰
35 1
羑悻的小杀马特
|
2天前
|
编译器 C语言 C++
类和对象的简述（c++篇）
类和对象的简述（c++篇）
羑悻的小杀马特
49 28
RossyYan
|
1月前
|
C++ 芯片
【C++面向对象——类与对象】Computer类（头歌实践教学平台习题）【合集】
声明一个简单的Computer类，含有数据成员芯片（cpu）、内存（ram）、光驱（cdrom）等等，以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制，用于保护类的数据不被外部随意修改。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。成员可以在派生类（继承该类的子类）中访问。成员，在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务，你需要掌握。
RossyYan
68 19
RossyYan
|
1月前
|
存储 编译器 数据安全/隐私保护
【C++面向对象——类与对象】CPU类（头歌实践教学平台习题）【合集】
声明一个CPU类，包含等级（rank）、频率（frequency）、电压（voltage）等属性，以及两个公有成员函数run、stop。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中，类是创建对象的蓝图。类的声明定义了类的成员，包括数据成员（变量）和成员函数（方法）。一个简单的类声明示例如下： classMyClass{ public: int
RossyYan
50 13
RossyYan
|
1月前
|
编译器 数据安全/隐私保护 C++
【C++面向对象——继承与派生】派生类的应用（头歌实践教学平台习题）【合集】
本实验旨在学习类的继承关系、不同继承方式下的访问控制及利用虚基类解决二义性问题。主要内容包括： 1. **类的继承关系基础概念**：介绍继承的定义及声明派生类的语法。 2. **不同继承方式下对基类成员的访问控制**：详细说明`public`、`private`和`protected`继承方式对基类成员的访问权限影响。 3. **利用虚基类解决二义性问题**：解释多继承中可能出现的二义性及其解决方案——虚基类。 实验任务要求从`people`类派生出`student`、`teacher`、`graduate`和`TA`类，添加特定属性并测试这些类的功能。最终通过创建教师和助教实例，验证代码
RossyYan
51 5