Question

我想要什么：我有一对具有未知类型和未知数量的参数的元组，但这两个元组和变量计数的类型完全相同，例如：

std::pair<std::tuple<Ts...>, std::tuple<Ts...>>

让我们称之为元组A和B

现在我想通过以下方式从这两个具有完全相同类型和参数计数（std::tuple<Ts...>）的新元组中创建：

1。随机选择一个元素的元组A或B （我想我可以通过调用std :: experimental :: rand_int（0,1）或其他生成器来实现）。

2。将此元素放在新元组中（让我们称之为C）（也许std :: experimental :: apply可以帮助指向 2。和 3。？）

第3。重复步骤1-2，直到元组A和B结束

实施例

A = std::tuple<double, int, long, int> {2.7, 1, 22, 4};
B = std::tuple<double, int, long, int> {12.4, 7, -19, 18};

我希望收到算法之后，例如：

C = std::tuple<double, int, long, int> {12.4, 1, 22, 18};

（或该方案后的A和B的任何其他组合）

Answer 1

不应该太难：

template <typename Tuple, std::size_t ...I>
Tuple rand_tuple_aux(const Tuple & a, const Tuple & b, std::index_sequence<I...>)
{
    return Tuple(std::get<I>(flip_coin() ? a : b)...);
}

template <typename ...Args>
std::tuple<Args...> rand_tuple(const std::tuple<Args...> & a,
                               const std::tuple<Args...> & b)
{
    return rand_tuple_aux(a, b, std::index_sequence_for<Args...>());
}

Answer 2

我知道有一个明显的答案，所以我不会改变它，但我想添加我的解决方案（这是非常hackish所以不是真的建议，但我想让这个功能成为一个lambda）。 父母输入：

std::pair<std::pair<std::tuple<Ts...>>, std::pair<std::tuple<Ts...>>>

（这就是为什么我用过汽车......）

以下是代码：

auto generate_child=[&](const auto& parents){
            auto genotype=std::experimental::apply(
                    [&](const auto&... mother){
                        return std::experimental::apply(
                                [&](const auto&... father){
                                    return std::make_tuple(
                                            (std::experimental::randint(0,1)?mother:father)...
                                    );
                                },
                                parents.second.second
                        );
                    },
                    parents.first.second
            );
            return std::make_pair(
                    std::experimental::apply(function,genotype),
                    genotype
            );
        };

C ++通过随机选择元素来构造来自两个元组的元组

2 个答案: