Replacing a type inside a tuple in C ++ 11

Question

I am trying to use C ++ templates to do the following:

I have a function like this:

template<typename... Args>
void f1(const std::tuple<Args...>& t1);

Inside this function, I would like to create another tuple t2 such that all elements of t1 will be copied to t2 at the same position, except for elements of type A, for which t2 must create an object of type B.

However, the constructor Brefers to the type object as Awell as the second type argument C&. An instance Cis created before the conversion and should be passed as a second argument to the constructor Bwhen an object of type is encountered A.

Something like this, only fully generalized:

std::tuple<int, B, double, B> Convert(std::tuple<int, A, double, A> tpl, C& c)
{
  return std::tuple<int, B, double, B>(
    std::get<0>(tpl),
    B(std::get<1>(tpl), c),
    std::get<2>(tpl),
    B(std::get<3>(tpl), c),
  );
}

Answer 1

. - . , .

:

template<typename... Args>
void f1(const std::tuple<Args...>& t1) {
    std::tuple<typename std::conditional<
        std::is_same<A, Args>::value, B, Args>::type...> t2(t1);
    // Both Args are expanded in parallel, resulting in the same types
    // Do things with t2
}

Answer 2

, :

#include<functional>
#include<tuple>
#include<cassert>

struct A {};
struct C {};
struct B { B(const A &, C &) {} };

template<typename T>
T g(const T &t, C &) { return t; }

B g(const A &a, C &c) {
    return B{a, c};
}

template<std::size_t... I, typename... Args>
void f(const std::tuple<Args...> &tup,std::index_sequence<I...>) {
    C c;
    auto val = std::make_tuple(g(std::get<I>(tup), c)...);
    assert((std::is_same<std::tuple<C, B, C>, decltype(val)>::value));
}

template<typename... Args>
void f(const std::tuple<Args...> &tup) {
    f(tup, std::make_index_sequence<sizeof...(Args)>());
}

int main() {
    auto tup = std::make_tuple(C{}, A{}, C{});
    f(tup);
}

, ++ 14, - std::make_index_sequence std::index_sequence.
++ 11 , .