目录

第一题

C++代码示例

第二题

C++代码示例

第三题

3.1 使用std::integral_constant模板类

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

总结

第四题

C++代码示例

第五题

C++代码示例

第六题

C++代码示例

第七题

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输出结果。可以看到，对于每个类型，我们都成功地获取了其在内存中所占空间的大小。

第二题

作为进一步的扩展，元函数的输入参数甚至可以是类型与数值混合的。尝试构造一个元函数，其输入参数为一个类型以及一个整数。如果该类型所对应对象的大小等与该整数，那么返回true，否则返回false。

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。

---

总结

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