преобразование структуры в/из std::tuple

К сожалению, нет автоматического способа сделать это, НО альтернативой является адаптация структуры к последовательности Boost.Fusion. Вы делаете это раз и навсегда для каждого нового класса.

#include <boost/fusion/adapted/struct/adapt_struct.hpp>
...
struct MyStruct { int i; bool b; double d; }

BOOST_FUSION_ADAPT_STRUCT(
    MyStruct,
    (int, i)
    (bool, b)
    (double, d)
)

Используйте MyStruct так, как если бы это был Fusion.Sequence (в общем, он подходит почти везде, где вы уже используете std::tuple<...>, если вы сделаете эти функции универсальными). В качестве бонуса вам вообще не нужно копировать элементы данных.

Если вам действительно нужно конвертировать в std::tuple, после "Fusion-адаптации" вы можете сделать это:

#include <boost/fusion/adapted/std_tuple.hpp>
#include <boost/fusion/algorithm/iteration/for_each.hpp>
#include <boost/fusion/algorithm/transformation/zip.hpp>
...
auto to_tuple(MyStruct const& ms){
   std::tuple<int, bool, double> ret;
   auto z = zip(ret, ms);
   boost::fusion::for_each(z, [](auto& ze){get<0>(ze) = get<1>(ze);});
   // or use boost::fusion::copy
   return ret;
}

Правда в том, что std::tuple — это половинчатая функция. Это как иметь STD-контейнеры и никаких алгоритмов. К счастью, у нас есть #include <boost/fusion/adapted/std_tuple.hpp>, который позволяет нам делать удивительные вещи.

Полный код:

При включении заголовка std_tuple.hpp из Boost.Fusion std::tuple автоматически адаптируется к последовательности Boost.Fusion, поэтому при использовании Boost.Fusion в качестве моста между вашей структурой и std::tuple возможно следующее:

#include <iostream>
#include <string>
#include <tuple>

#include <boost/fusion/adapted/struct/adapt_struct.hpp>
#include <boost/fusion/algorithm/auxiliary/copy.hpp>
#include <boost/fusion/adapted/std_tuple.hpp>

struct foo
{
  std::string a, b, c;
  int d, e, f;
};

BOOST_FUSION_ADAPT_STRUCT(
    foo,
    (std::string, a)
    (std::string, b)
    (std::string, c)
    (int, d)
    (int, e)
    (int, f)
)

template<std::size_t...Is, class Tup>
foo to_foo_aux(std::index_sequence<Is...>, Tup&& tup) {
  using std::get;
  return {get<Is>(std::forward<Tup>(tup))...};
}
template<class Tup>
foo to_foo(Tup&& tup) {
  using T=std::remove_reference_t<Tup>;
  return to_foo_aux(
    std::make_index_sequence<std::tuple_size<T>{}>{},
    std::forward<Tup>(tup)
  );
}

template<std::size_t...Is>
auto to_tuple_aux( std::index_sequence<Is...>, foo const& f ) {
  using boost::fusion::at_c;
  return std::make_tuple(at_c<Is>(f)...);
}
auto to_tuple(foo const& f){
  using T=std::remove_reference_t<foo>;
  return to_tuple_aux(
    std::make_index_sequence<boost::fusion::result_of::size<foo>::type::value>{},
    f
  );    
}

int main(){


    foo f{ "Hello", "World", "!", 1, 2, 3 };

    std::tuple<std::string, std::string, std::string, int, int, int> dest = to_tuple(f);
    // boost::fusion::copy(f, dest); // also valid  but less general than constructor

    std::cout << std::get<0>(dest) << ' ' << std::get<1>(dest) << std::get<2>(dest) << std::endl;
    std::cout << at_c<0>(dest) << ' ' << at_c<1>(dest) << at_c<2>(dest) << std::endl; // same as above

    foo f2 = to_foo(dest);

    std::cout << at_c<0>(f2) << ' ' << at_c<1>(f2) << at_c<2>(f2) << std::endl;
}

Я не буду рекомендовать reinterpret_cast<std::tuple<...>&>(mystructinstance.i), потому что это приведет к отрицательному голосованию и не будет переносимым.

Мы можем использовать структурированные привязки для преобразования структуры в кортеж, немного потрудившись.

Struct-to-tuple очень неудобно.

template<std::size_t N>
struct to_tuple_t;

template<>
struct to_tuple_t<3> {
  template<class S>
  auto operator()(S&& s)const {
    auto[e0,e1,e2]=std::forward<S>(s);
    return std::make_tuple(e0, e1, e2);
  }
};

Теперь напишите to_tuple_t для каждого размера, который вы хотите поддерживать. Это становится утомительным. К сожалению, я не знаю, как добавить туда пакет параметров.

template<std::size_t N, class S>
auto to_tuple(S&& s) {
  return to_tuple_t<N>{}(std::forward<S>(s));
}

Я также не знаю, как рассчитать требуемое значение N. Таким образом, вам нужно будет ввести 3 в auto t = to_tuple<3>(my_struct);, когда вы его вызываете.

Я не мастер структурированных привязок. Вероятно, существует && или &, или decltype, который позволит идеально пересылать следующие строки:

    auto[e0,e1,e2]=std::forward<S>(s);
    return std::make_tuple(e0, e1, e2);

но без компилятора я буду консервативен и буду делать лишние копии.

Преобразовать кортеж в структуру очень просто:

template<class S, std::size_t...Is, class Tup>
S to_struct( std::index_sequence<Is...>, Tup&& tup ) {
  using std::get;
  return {get<Is>(std::forward<Tup>(tup))...};
}
template<class S, class Tup>
S to_struct( Tup&&tup ) {
  using T=std::remove_reference_t<Tup>;

  return to_struct(
    std::make_index_sequence<std::tuple_size<T>{}>{},
    std::forward<Tup>(tup)
  );
}

Поддержка SFINAE, основанная на tuple_size, может быть полезной для to_struct.

Приведенный выше код работает со всеми подобными кортежами, такими как std::pair, std::array, и всем, что вы настроили для поддержки структурированных привязок (tuple_size и get<I>).

Забавно,

std::array<int, 3> arr{1,2,3};
auto t = to_tuple<3>(arr);

работает и возвращает кортеж с 3 элементами, так как to_tuple основан на структурированных привязках, которые работают с подобными кортежами в качестве входных данных.

to_array - еще одна возможность в этой семье.

Есть ли какой-нибудь стандартный способ приведения одного к другому?

Невозможно «привязать» одно к другому.

Проще всего использовать std::tie для упаковки кортежа в struct;

struct MyStruct { int i; bool b; double d; };
using MyTuple = std::tuple<int,bool,double>;

auto t = std::make_tuple(42, true, 5.1);
MyStruct s;

std::tie(s.i, s.b, s.d) = t;

Демо.

Вы можете дополнительно обернуть это макросами более высокого уровня или функциями «генератора» (стиль make), например;

std::tuple<int, bool, double> from_struct(MyStruct const& src)
{
  return std::make_tuple(src.i, src.b, src.d);
}

MyStruct to_struct(std::tuple<int, bool, double> const& src)
{
  MyStruct s;
  std::tie(s.i, s.b, s.d) = src;
  return s;
}

Я знаю, что тривиальное копирование памяти может помочь, но это зависит от выравнивания и реализации?

Вы упомянули, что «тривиальная копия памяти» будет работать - только для копирования отдельных членов. Таким образом, memcpy всей структуры в tuple и наоборот не всегда будет вести себя так, как вы ожидаете (если вообще когда-либо); схема памяти tuple не стандартизирована. Если это работает, это сильно зависит от реализации.

Преобразование кортежа в struct тривиально, но обратное, я думаю, невозможно на текущем уровне C++ в целом.

#include <type_traits>
#include <utility>

#include <tuple>

namespace details
{

template< typename result_type, typename ...types, std::size_t ...indices >
result_type
make_struct(std::tuple< types... > t, std::index_sequence< indices... >) // &, &&, const && etc.
{
    return {std::get< indices >(t)...};
}

}

template< typename result_type, typename ...types >
result_type
make_struct(std::tuple< types... > t) // &, &&, const && etc.
{
    return details::make_struct< result_type, types... >(t, std::index_sequence_for< types... >{}); // if there is repeated types, then the change for using std::index_sequence_for is trivial
}

#include <cassert>
#include <cstdlib>

int main()
{
    using S = struct { int a; char b; double c; };
    auto s = make_struct< S >(std::make_tuple(1, '2', 3.0));
    assert(s.a == 1);
    assert(s.b == '2');
    assert(s.c == 3.0);
    return EXIT_SUCCESS;
}

Живой пример.