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

目录

第一题

C++代码示例

第二题

C++代码示例

第三题

3.1 使用std::integral_constant模板类

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

总结

第四题

C++代码示例

第五题

C++代码示例

第六题

C++代码示例

第七题

C++代码示例

总结

第一题

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

C++代码示例

#include 
#include 
 
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 
#include 
 
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 
#include 
 
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直接访问value成员变量。

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

#include 
#include 
 
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 
#include 
 
template <typename Input>
struct FirstLayer {
    template <typename Func>
    struct SecondLayer {
        template <typename... Args>
        constexpr auto operator()(Args&&... args) const {
            return Func{}(std::forward(args)...);
        }
    };
    
    template <typename Func>
    constexpr auto operator()(Func) const {
        return SecondLayer{};
    }
};
 
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 对象，即返回一个闭包（closure）元函数。

在 main() 函数中，我们先创建一个 FirstLayer 对象 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 
#include 
 
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(nullptr))::value;
};
 
// 测试用例
struct A {
    using type = int;
};
 
struct B {};
 
int main() {
    std::cout << std::boolalpha;
    std::cout << HasType::value << std::endl;  // 输出：true（A 类型存在名为 type 的子类型）
    std::cout << HasType::value << std::endl;  // 输出：false（B 类型不存在名为 type 的子类型）
 
    return 0;
}

#include 
#include 
#include 
 
template <typename... Types>
struct SizeOfArray;
 
// 基本情况：处理空类型数组
template <>
struct SizeOfArray<> {
    using type = std::arraysize_t, 0>;
};
 
// 递归情况：处理非空类型数组
template <typename T, typename... Types>
struct SizeOfArray {
    using type = std::arraysize_t, sizeof...(Types)+1>;
};
 
// 辅助函数，打印无符号整型数组
template size_t N, std::size_t... Sizes>
void printSizes(const std::arraysize_t, N>& sizes, std::index_sequence) {
    ((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_sequencesize()>());  // 输出：4 8 1 1
    
    return 0;
}

#include 
 
// 终止条件，判断最后一个元素是否等于 1
template <int Last>
bool hasOne() {
    return Last == 1;
}
 
// 递归情况，判断当前元素是否等于 1，并继续判断后面的元素
template <int First, int Second, int... Rest>
bool hasOne() {
    return (First == 1) || hasOne();
}
 
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;
}