Question

我有两种解决方案，既可以按照我的预期工作，也可以按照我的预期进行仅适用于较新版本的GCC（肯定是5.2.1），第二个适用于GCC＆gt; = 4.8.3。问题是，在我的工作中，我很遗憾无法访问更新版本的GCC。

第一个解决方案基本上是我想要的行为和复杂程度。第二个也有效，但这是我写过的最丑陋的东西，说实话我不知道这是不是正确的代码（但它确实有效）。

好的，首先我将描述我面临的问题：我在这里有一个名为logic()的函数，它使可调用对象在其他指令中调用一些额外的逻辑。这些说明当然不在这里，因为它们不是必需的，它们被标记为(X)。

template <typename C>
void logic (C c) {
    // before callable actions (X)
    c ();
    // after callable actions (X)
}

我想要做的是因为可调用对象是使用适当的类型 - bool函数设置一些set_single()值。对于示例，我将使用一些其他类型：

struct P1 {};
struct P2 {};
struct P3 {};

考虑第一个解决方案：

namespace Solution1 {

template <typename T>
void set_single (bool c) {
    // use type T to set c value - details are not the case here.

    std::cout << "value = " << c << std::endl;
    std::cout << "P1 = " << std::is_same<T, P1>::value << std::endl;
    std::cout << "P2 = " << std::is_same<T, P2>::value << std::endl;
    std::cout << "P3 = " << std::is_same<T, P3>::value << std::endl;
}

template <typename T, typename K, typename... Ts, typename... Vs>
void set_single (bool t, bool k, Vs&&... args) {
    set_single<T> (t);
    set_single<K, Ts...> (k, std::forward<Vs> (args)...);
}

template <typename... Ts, typename... Args>
void set (Args&&... args) {
    static_assert (sizeof... (Ts) == sizeof... (Args), "");

    logic ([&] () {
        set_single<Ts...> (std::forward<Args> (args)...);
    });
}

}

set()函数是一个包装器，对于用户来说是公共的，set_single()是实现细节，因此它们是隐藏的（为简单起见，它们不是在类中编写的）。

因此，将可调用对象传递给logic()函数内的set()函数我调用set_single()函数任意次数传递所有值和我需要的相应类型。因此，例如，使用可能是这样的：

Solution1::set<P1, P2, P3> (true, false, true);

这将使用类型P1设置为true，键入P2以设置false并键入P3以设置为true。

因此，当编译器不支持将可变参数传递给lambda表达式时，我们有一个解决方案。

namespace Solution2 {

template <typename... Ts>
struct X {
    X () = default;
    X (Ts... t) : tup {std::make_tuple (t...)} {}
    std::tuple<Ts...> tup;
};

template <int...>
struct Ints {};

template <int N, int... Is>
struct Int_seq : Int_seq<N-1, N, Is...> {};

template <int... Is>
struct Int_seq<0, Is...> {
    using type = Ints<0, Is...>;
};

template <int... Is>
using Iseq = typename Int_seq<Is...>::type;

template <int I, typename... Args, typename... Types>
void set_single (Ints<I>, const std::tuple<Args...>& a, const std::tuple<Types...>& t) {
    std::cout << "value = " << std::get<I> (a) << std::endl;
    auto p1 = std::get<I> (t);
    auto p2 = std::get<I> (t);
    auto p3 = std::get<I> (t);
    std::cout << "P1 = " << std::is_same<P1, decltype (p1)>::value << std::endl;
    std::cout << "P2 = " << std::is_same<P2, decltype (p2)>::value << std::endl;
    std::cout << "P3 = " << std::is_same<P3, decltype (p3)>::value << std::endl;
}

template <int I, int K, int... Is, typename... Args, typename... Types>
void set_single (Ints<I, K, Is...>, const std::tuple<Args...>& a, const std::tuple<Types...>& t) {
    set_single (Ints<I> {}, a, t);
    set_single (Ints<K, Is...> {}, a, t);
}

template <typename... Ts, typename... Args>
void set (Args... args) {
    static_assert (sizeof... (Ts) == sizeof... (Args), "");

    X<Ts...> types {};
    X<Args...> arguments {args...};

    logic ([&types, &arguments] () {
        set_single (Iseq<std::tuple_size<decltype (arguments.tup)>::value-1> {}, arguments.tup, types.tup);
    });

}

}

我使用类型Solution2::X来存储值和类型。我试着做一些std::bind()的东西，但是很痛苦，所以我用了一些整数序列（可能实现相当差）。就像我说的那样，两种解决方案都有效，但第二种解决方案并不像第一种解决方案那么酷。

您是否可以告诉我Solution2是否可以被某种更简单的解决方案取代？我很确定有些存在。

输出的用法如下：

Solution1::set<P1, P2, P3> (true, false, true);

value = 1
P1 = 1
P2 = 0
P3 = 0
value = 0
P1 = 0
P2 = 1
P3 = 0
value = 1
P1 = 0
P2 = 0
P3 = 1


Solution2::set<P1, P2, P3> (true, false, true);

value = 1
P1 = 1
P2 = 0
P3 = 0
value = 0
P1 = 0
P2 = 1
P3 = 0
value = 1
P1 = 0
P2 = 0
P3 = 1

Answer 1

您需要使用一些标记来保留给定的类型，因为它们可能不是默认的可构造的。

我会这样实现：

#if 1 // Not in C++11 // make_index_sequence
#include <cstdint>

template <std::size_t...> struct index_sequence {};

template <std::size_t N, std::size_t... Is>
struct make_index_sequence : make_index_sequence<N - 1, N - 1, Is...> {};

template <std::size_t... Is>
struct make_index_sequence<0u, Is...> : index_sequence<Is...> {};

#endif // make_index_sequence

#if 1 // Not in C++11 // tuple_element_t
template <std::size_t I, typename T>
using tuple_element_t = typename std::tuple_element<I, T>::type;
#endif

namespace Solution3 {

    template <typename T>
    struct bool_impl {
        using type = bool;
    };

    template <typename T>
    using bool_t = typename bool_impl<T>::type; // or simply using bool_t = bool

    template <typename T>
    void set_single (bool c) {
        // use type T to set c value - details are not the case here.

        std::cout << "value = " << c << std::endl;
        std::cout << "P1 = " << std::is_same<T, P1>::value << std::endl;
        std::cout << "P2 = " << std::is_same<T, P2>::value << std::endl;
        std::cout << "P3 = " << std::is_same<T, P3>::value << std::endl;
    }

    template <typename T> struct Tag {};

    template <typename T1, typename T2, std::size_t ... Is>
    void set_singles (Tag<T1>, T2 t, index_sequence<Is...>) {
        int dummy[] = {0, (set_single<tuple_element_t<Is, T1>>(std::get<Is>(t)), 0)...};
        static_cast<void>(dummy); // Avoid warning for unused variable
    }

    template <typename... Ts>
    void set (bool_t<Ts>... args) {
        Tag<std::tuple<Ts...>> tag;
        auto bools = std::make_tuple(args...);
        auto seq = make_index_sequence<sizeof...(Ts)>();

        logic ([&]() {
            set_singles(tag, bools, seq);
        });
    }

}

Demo

简化了最新编译器的版本

Demo

如果编译器不支持lambda表达式，则将变量参数传递给lambda表达式的解决方法

1 个答案: