Вариативная последовательность указателя на рекурсивный член структуры / класса в качестве параметра шаблона

Question

Я борюсь с некоторыми шаблонами программирования и надеюсь, что вы мне поможете.Я кодировал интерфейс C ++ 11, который с учетом некоторых структур, таких как:

struct Inner{
  double a;
};
struct Outer{
  double x, y, z, r;
  Inner in;
};

Реализует метод получения / установки для реальных данных, настроенных для указанных членов структуры:

MyData<Outer, double, &Outer::x,
                               &Outer::y, 
                               &Outer::z,
                               &Outer::in::a //This one is not working
              > state();

Outer foo = state.get();
//...  
state.set(foo);

Мне удалось реализовать это для простых структур следующим образом:

template <typename T, typename U, U T::* ... Ms>
class MyData{
   std::vector<U *> var;
  public:
    explicit MyData();
    void set(T const& var_);
    T get() const;
};

template <typename T, typename U, U T::* ... Ms>
MyData<T, U, Ms ... >::Struct():var(sizeof...(Ms))
{
}

template <typename T, typename U, U T::* ... Ms>
void MyData<T, U, Ms ...>::set(T const& var_){
  unsigned i = 0;
  for ( auto&& d : {Ms ...} ){
    *var[i++] = var_.*d;
  }
}

template <typename T, typename U, U T::* ... Ms>
T MyData<T, U, Ms ...>::get() const{
  T var_;
  unsigned i = 0;
  for ( auto&& d : {Ms ...} ){
    var_.*d = *var[i++];
  }
  return var_;
}

Но это не удается, когда я передаю член вложенной структуры.В идеале я хотел бы реализовать универсальный указатель на тип члена, который позволяет мне быть совместимым с несколькими уровнями разрешения областей.Я нашел такой подход , но я не уверен, следует ли это применить к моей проблеме или существует какая-то реализация, готовая к использованию.Заранее спасибо!

Похожие записи:

Неявные параметры шаблона

Указатель на внутреннюю структуру

Answer 1

Я бы использовал лямбда-подход для реализации аналогичных функций в C ++ 17 (C ++ 14 тоже подойдет, просто измените выражение сгиба):

auto access_by() {
    return [] (auto &&t) -> decltype(auto) {
        return decltype(t)(t);
    };
}

template<class Ptr0, class... Ptrs>
auto access_by(Ptr0 ptr0, Ptrs... ptrs) {
    return [=] (auto &&t) -> decltype(auto) {
        return access_by(ptrs...)(decltype(t)(t).*ptr0);
    };
}

auto data_assigner_from = [] (auto... accessors) {
    return [=] (auto... data) {
        return [accessors..., data...] (auto &&t) {
            ((accessors(decltype(t)(t)) = data), ...);
        };
    };
};

Давайте посмотрим, как использовать эти лямбды:

struct A {
    int x, y;
};

struct B {
    A a;
    int z;
};

access_by можно использовать как:

auto bax_accessor = access_by(&B::a, &A::x);
auto bz_accessor = access_by(&B::z);

Тогда для B b;, bax_accessor(b) равно b.a.x;bz_accessor(b) - это b.z.Категория значений также сохраняется, поэтому вы можете назначить: bax_accessor(b) = 4.

data_assigner_from() создаст присваиватель для назначения экземпляра B с заданными средствами доступа:

auto data_assigner = data_assigner_from(
        access_by(&B::a, &A::x),
        access_by(&B::z)
     );

data_assigner(12, 3)(b);

assert(b.z == 3 && b.a.x == 12);

Answer 2

Обобщение указателя на член - это функция, которая может отображать T на X& во время компиляции.

В c ++ 17 подключить не сложновсе благодаря auto.В c ++ 11 становится все сложнее.Но основная идея состоит в том, что вы на самом деле не передаете указатели членов, вы передаете типы, и эти типы знают, как взять ваш класс и получить из него ссылку.

template<class T, class D, class...Fs>
struct MyData {
  std::array<D*, sizeof...(Fs)> var = {};
  explicit MyData()=default;
  void set(T const& var_) {
    var = {{ Fs{}(std::addressof(var_))... }};
  }
  T get() {
    T var_;
    std::size_t index = 0;
    using discard=int[];
    (void)discard{ 0, (void(
      *Fs{}(std::addressof(var_)) = *var[index++]
    ),0)... };
    return var_;
  }
};

Осталось написатьутилита, облегчающая написание Fs... для регистра указателя члена

template<class X, X M>
struct get_ptr_to_member_t;
template<class T, class D, D T::* M>
struct get_ptr_to_member_t< D T::*, M > {
  D const* operator()( T const* t )const{
    return std::addressof( t->*M );
  }
};
#define TYPE_N_VAL(...) \
  decltype(__VA_ARGS__), __VA_ARGS__
#define MEM_PTR(...) get_ptr_to_member_t< TYPE_N_VAL(__VA_ARGS__) >

теперь базовый регистр

MyData< Outer, double, MEM_PTR(&Outer::x), MEM_PTR(&Outer::y) >

Теперь можно обрабатывать более сложный регистр.

Один из подходов - научить get_ptr_to_member сочинять.Это раздражающая работа, но ничего фундаментального.Компоновка такова, что decltype(ptr_to_member_t * ptr_to_member_t) возвращает тип, который экземпляры вправо, применяет его, затем берет этот указатель и запускает на нем левую часть.

template<class First, class Second>
struct composed;

template<class D>
struct composes {};

#define RETURNS(...) \
  noexcept(noexcept(__VA_ARGS__)) \
  decltype(__VA_ARGS__) \
  { return __VA_ARGS__; }

template<class First, class Second>
struct composed:composes<composed<First, Second>> {
  template<class In>
  auto operator()(In&& in) const
  RETURNS( Second{}( First{}( std::forward<In>(in) ) ) )
};

template<class First, class Second>
composed<First, Second> operator*( composes<Second> const&, composes<First> const& ) {
  return {};
}

, затем мы обновляем:

template<class X, X M>
struct get_ptr_to_member_t;
template<class T, class D, D T::* M>
struct get_ptr_to_member_t< D T::*, M >:
  composes<get_ptr_to_member_t< D T::*, M >>
{
  D const* operator()( T const* t )const{
    return std::addressof( t->*M );
  }
};

и теперь * составляет их.

MyData<TestStruct, double, MEM_PTR(&Outer::x),
                           MEM_PTR(&Outer::y), 
                           MEM_PTR(&Outer::z),
                           decltype(MEM_PTR(&Inner::a){} * MEM_PTR(&Outer::in){})
          > state();

ответ, вероятно, содержит много опечаток, но дизайн - это звук.

В c ++ 17 большая частьмусор испаряется, как макросы.

Answer 3

Вы можете заключить указатель члена в struct, чтобы упростить создание цепочки:

template <typename...> struct Accessor;

template <typename T, typename C, T (C::*m)>
struct Accessor<std::integral_constant<T (C::*), m>>
{
    const T& get(const C& c) { return c.*m; }
    T& get(C& c) { return c.*m; }
};

template <typename T, typename C, T (C::*m), typename ...Ts>
struct Accessor<std::integral_constant<T (C::*), m>, Ts...>
{
    auto get(const C& c) -> decltype(Accessor<Ts...>().get(c.*m))
    { return Accessor<Ts...>().get(c.*m); }

    auto get(C& c) -> decltype(Accessor<Ts...>().get(c.*m))
    { return Accessor<Ts...>().get(c.*m); }
};

template <typename T, typename U, typename ...Ts>
class MyData
{
    std::vector<U> vars{sizeof...(Ts)};

    template <std::size_t ... Is>
    T get(std::index_sequence<Is...>) const
    {
        T res;
        ((Ts{}.get(res) = vars[Is]), ...); // Fold expression C++17
        return res;
    }
    template <std::size_t ... Is>
    void set(std::index_sequence<Is...>, T const& t)
    {
        ((vars[Is] = Ts{}.get(t)), ...); // Fold expression C++17
    }

public:
    MyData() = default;

    T get() const { return get(std::index_sequence_for<Ts...>()); }
    void set(const T& t) { return set(std::index_sequence_for<Ts...>(), t); }

};

При использовании, аналогичном

template <auto ...ms> // C++17 too
using Member = Accessor<std::integral_constant<decltype(ms), ms>...>;

MyData<Outer, double, Member<&Outer::x>,
                           Member<&Outer::y>,
                           Member<&Outer::z>,
                           Member<&Outer::in, &Inner::a>
       > state;

std::index_sequence, это C ++ 14, но может быть реализовано вC ++ 11.
Складывание выражения из C ++ 17 также может быть смоделировано в C ++ 11.
typename <auto> (C ++ 17) следует заменить на typename <typename T, T value>.

Демо