c++ 模版元编程 算法

1. 元素访问算法

元素访问算法用于访问元素或成员，如std::get、std::tuple_size、std::tuple_element等。例如：

#include <tuple>
#include <iostream>

int main()
{
    std::tuple<int, float, char> t(42, 3.14, 'a');
    std::cout << std::get<0>(t) << '\n'; // 访问元组的第一个元素
    std::cout << std::tuple_size<decltype(t)>::value << '\n'; // 获取元组的大小
    using SecondType = std::tuple_element<1, decltype(t)>::type; // 获取元组的第二个元素类型
    return 0;
}

1. 转换算法

转换算法用于将编译器常量或类型转换为其他类型，如std::integral_constant、std::conditional、std::enable_if等。例如：

#include <type_traits>
#include <iostream>

template<typename T>
struct is_pointer : std::false_type {}; // 默认情况下不是指针类型

template<typename T>
struct is_pointer<T*> : std::true_type {}; // 针对指针类型进行特化

template<typename T>
typename std::enable_if<is_pointer<T>::value, void>::type
foo(T value)
{
    std::cout << "This is a pointer\n";
}

template<typename T>
typename std::enable_if<!is_pointer<T>::value, void>::type
foo(T value)
{
    std::cout << "This is not a pointer\n";
}

int main()
{
    int x = 1;
    int* px = &x;
    foo(x); // 输出This is not a pointer
    foo(px); // 输出This is a pointer
    return 0;
}

1. 比较算法

比较算法用于比较编译期常量或类型，如std::is_same、std::conditional、std::common_type等。例如：

#include <type_traits>
#include <iostream>

template<typename T1, typename T2>
struct is_same_v : std::false_type {};

template<typename T>
struct is_same_v<T, T> : std::true_type {};

template<typename T1, typename T2>
using enable_if_same_t = std::enable_if<is_same_v<T1, T2>::value>;

template<typename T1, typename T2>
typename enable_if_same_t<T1, T2>::type
swap(T1& a, T2& b)
{
    auto tmp = a;
    a = b;
    b = tmp;
}

int main()
{
    int x = 1;
    double y = 2.0;
    std::cout << "before swap: x=" << x << ", y=" << y << '\n';
    swap(x, y); // 编译时报错，因为类型不一致
    std::cout << "after swap: x=" << x << ", y=" << y << '\n';
    return 0;
}

transform 是 C++ 标准库中的一个常用算法函数，用于在容器范围内对元素进行转换操作，并将结果存储在另一个容器中。它接受输入范围的迭代器和输出范围的迭代器作为参数，以及一个一元操作函数或二元操作函数。

以下是 transform 函数的函数签名：

template <class InputIterator, class OutputIterator, class UnaryOperation>
OutputIterator transform (InputIterator first1, InputIterator last1,
                          OutputIterator result, UnaryOperation unary_op);

其中的参数说明如下：

• first1：表示输入范围的起始位置的迭代器。
• last1：表示输入范围的结束位置的迭代器。
• result：表示输出范围的起始位置的迭代器。
• unary_op：一元操作函数，可接受一个输入值并返回一个结果值。

函数的返回值为输出范围的结束位置的迭代器。

使用示例： 下面是一个使用 transform 函数的示例代码，演示了如何将一个容器中的每个元素乘以2，并将结果存储在另一个容器中：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::vector<int> doubledNumbers;

    // 使用 transform 将 numbers 中的每个元素乘以2，并将结果存储在 doubledNumbers 中
    std::transform(numbers.begin(), numbers.end(), std::back_inserter(doubledNumbers),
                   [](int num) { return num * 2; });

    // 输出转换后的结果
    for (const auto& num : doubledNumbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}