Можно ли избежать необходимости в конструкторах копирования / перемещения в следующем коде? - PullRequest
Новая
       6

Можно ли избежать необходимости в конструкторах копирования / перемещения в следующем коде?

0 голосов
/ 24 августа 2018

Пожалуйста, рассмотрите следующий код для типа, который может составлять различные типы смешивания.Конструктор составного типа принимает переменный список кортежей, представляющих аргументы для конструкторов составных типов: 

#include <string>
#include <tuple>
#include <utility>

struct MixinBase {
  MixinBase() = default;
  // Note; want to delete these instead of default them.
  MixinBase(const MixinBase&) = default;
  MixinBase(MixinBase&&) = default;
};

struct MixinA : public MixinBase {
  MixinA(int, const std::string&, const std::string&) {}
};

struct MixinB : public MixinBase {
  MixinB(const std::string&, const std::string&) {}
};

template <typename... Mixins>
struct Composition : private Mixins... {
  template <typename... Packs>
  Composition(Packs&&... packs)
      : Mixins(constructMixin<Mixins>(
            std::forward<Packs>(packs),
            std::make_index_sequence<std::tuple_size_v<Packs>>{}))...
  {
  }

private:
  template <typename Mixin, typename Pack, size_t... Indexes>
  Mixin constructMixin(Pack&& arguments, std::index_sequence<Indexes...>) const
  {
    return Mixin(std::get<Indexes>(std::forward<Pack>(arguments))...);
  }
};

int main()
{
  std::string a{"a"};
  std::string b{"b"};

  Composition<MixinA, MixinB>(
      std::forward_as_tuple(7, a, b), std::forward_as_tuple(a, b));

  return 0;
}

Это прекрасно работает, однако я хотел бы избежать косвенного обращения через constructMixin и непосредственно создайте каждый унаследованный объект mixin, чтобы избежать необходимости в конструкторе копирования / перемещения для типа mixin.Возможно ли это?

Ответы [ 2 ]

0 голосов
/ 24 августа 2018

Вы можете определить вспомогательный класс для поддержки кусочной конструкции: 

template <typename T>
struct Piecewise_construct_wrapper : T {
    template <typename Tuple>
    Piecewise_construct_wrapper(Tuple&& t) : 
        Piecewise_construct_wrapper(std::forward<Tuple>(t), 
                                    std::make_index_sequence<std::tuple_size_v<Tuple>>{}) {}

    template <typename Tuple, size_t... Indexes>
    Piecewise_construct_wrapper(Tuple&& t, std::index_sequence<Indexes...>) : 
        T(std::get<Indexes>(std::forward<Tuple>(t))...) {}
};

Затем вы можете сделать ваше Composition наследуемым Piecewise_construct_wrapper<Mixins>...: 

template <typename... Mixins>
struct Composition : private Piecewise_construct_wrapper<Mixins>... {
    template <typename... Packs>
    Composition(Packs&&... packs)
        : Piecewise_construct_wrapper<Mixins>(std::forward<Packs>(packs))...
    {
    }
};
0 голосов
/ 24 августа 2018

Я бы хотел избежать косвенного обращения через constructMixin и напрямую создавать каждый унаследованный объект mixin, чтобы избежать необходимости в конструкторе копирования / перемещения для типа mixin.Возможно ли это?

Вам понадобятся миксины, чтобы разрешить кусочную конструкцию напрямую.К сожалению, это довольно повторяющееся, поэтому вы можете использовать макрос вроде: 

#define PIECEWISE_CONSTRUCT(Type)                               \
  template <typename Tuple>                                     \
  Type(std::piecewise_construct_t, Tuple&& tuple)               \
    : Type(std::piecewise_construct,                            \
        std::forward<Tuple>(tuple),                             \
        std::make_index_sequence<std::tuple_size_v<Tuple>>())   \
  { }                                                           \  
  template <typename Tuple, size_t... Indexes>                  \
  Type(std::piecewise_construct_t, Tuple&& tuple,               \
        std::index_sequence<Indexes...>)                        \
    : Type(std::get<Indexes>(std::forward<Tuple>(tuple))...)    \
  { }

Для использования в качестве: 

struct MixinA : public MixinBase {
  MixinA(int, const std::string&, const std::string&) {}

  PIECEWISE_CONSTRUCT(MixinA)
};

struct MixinB : public MixinBase {
  MixinB(const std::string&, const std::string&) {}

  PIECEWISE_CONSTRUCT(MixinB)
};

template <typename... Mixins>
struct Composition : private Mixins... {
  template <typename... Packs>
  Composition(Packs&&... packs)
      : Mixins(std::piecewise_construct, std::forward<Packs>(packs))...
  { }
};

Гарантированное разрешение копирования, к сожалению, не может работать при построении подобъектов - так что этоможет быть, ваш лучший выбор.Я не думаю, что вы можете сделать это напрямую, не имея каких-то вложенных пакетов?Вполне возможно, что я просто недостаточно креативен, и мне было бы очень любопытно, если бы кто-нибудь придумал что-то лучшее.

...