Факторинг повторных вызовов конструктора в шаблоне компоновщика шаблонов

Question

Рассмотрим следующий подобный строителю -подобный класс, который в конечном итоге позволяет мне создать объект с обоими определенными (во время выполнения) значениями для переменных-членов, а также внедрить некоторое поведение, которое выполняется несколькими (compile-time) types.

Та же сборка позволяет обновлять переменные-члены (обычный шаблон компоновщика), а также изменять параметры шаблона type , связанные с переносимым типом состоянием компоновщика (показывается только с парой параметров и членов типа шаблона, но на практике их будет больше):

template <typename T1 = DefaultT1, typename T2 = DefaultT2>
class Builder {
  int param1, param2;
  Builder(int param1, int param2) : param1{param1}, param2{param2} {}
public:
  Builder() : Builder(default1, default2) {}

  // methods to change param1 and param2 not shown

  /* return a new Builder with T1 changed to the given T1_NEW */
  template <typename T1_NEW>
  Builder<T1_NEW, T2   > withT1() { return {param1, param2}; }

  template <typename T2_NEW>
  Builder<T1   , T2_NEW> withT2() { return {param1, param2}; }

  Foo make() {
    // uses T1 and T2 to populate members of foo
    return Foo{ typename T1::member, typename T2::another };
  }
};

Обратите внимание на методы withT1<> и withT2<>, которые позволяют возвращать нового компоновщика сдругой тип для T1 или T2 соответственно.Тела для этих методов идентичны: return {param1, param2};, и на практике гораздо сложнее, чем показано здесь (например, если имеется много параметров).

Я бы хотел выделить тело в некоторый метод, которыйвыполняет конструкцию, такую ​​как:

template <typename T1_, typename T2_>
Builder<T1_, T2_> copy() { return {param1, param2}; }

, а затем каждый метод withT* может просто вызвать копирование.

Однако мне не ясно, как избежать включения полностью определенного типаBuilder в вызове:

template <typename T1_NEW>
Builder<T1_NEW, T2   > withT1() { return copy<T1_NEW, T2>(); }

Здесь лечение хуже, чем исходный яд, так как мне нужно квалифицировать каждый вызов копирования с помощью <T1_NEW, T2> (и это отличается для каждого метода withT*),Есть ли какой-то способ, которым я могу ссылаться на тип возвращаемого значения или другой тип вывода, который я могу использовать для вызова copy() таким же образом в каждой функции?

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

Answer 1

Вы можете ввести прокси-строитель, который имеет неявное преобразование, чтобы сэкономить при наборе:

template<typename T1, typename T2>
struct Builder;

struct BuilderProxy
{
    int param1, param2;

    template<typename T1, typename T2>
    operator Builder<T1, T2>() const { return {param1, param2}; }
};

template <typename T1, typename T2>
struct Builder {
    int param1, param2;
    Builder(int param1, int param2) : param1{param1}, param2{param2} {}

    BuilderProxy copy() { return {param1, param2}; }

    template <typename T1_NEW>
    Builder<T1_NEW, T2   > withT1() { return copy(); }

    template <typename T2_NEW>
    Builder<T1   , T2_NEW> withT2() { return copy(); }
};

int main() {
    Builder<int, int> a(1, 2);
    Builder<double, double> b = a.withT1<double>().withT2<double>();
}

Answer 2

У меня нет решения для C ++ 11, но, как вы сказали сами, C ++ 14 может быть полезным для других.

Если я правильно понял, вам нужен класс, который хранит произвольные аргументыс удобным способом передать все аргументы в конструктор.Это может быть достигнуто с помощью аргументов шаблона переменной и std::tuple:

#include <tuple>

template <typename... Args>
class Builder
{
public:
    explicit Builder(Args... args)
        : arg_tuple(std::forward<Args>(args)...)
    {}

    template <typename T>
    T make()
    {
        return std::make_from_tuple<T>(arg_tuple);
    }

    template <typename T>
    Builder<Args..., T> with(T t)
    {
        return std::make_from_tuple<Builder<Args..., T>>(std::tuple_cat(arg_tuple, std::make_tuple(std::move(t))));
    }

private:
    std::tuple<Args...> arg_tuple;
};

template <typename... Args>
Builder<Args...> make_builder(Args... args)
{
    return Builder<Args...>(std::forward<Args>(args)...);
}

Использование:

struct Foo
{
    Foo(int x, int y)
        : x(x), y(y)
    {}
    int x;
    int y;
};

struct Bar
{
    Bar(int x, int y, float a)
        : x(x), y(y), a(a)
    {}
    int x;
    int y;
    float a;
};

int main()
{
    auto b = make_builder().with(5).with(6);
    auto foo = b.make<Foo>();  // Returns Foo(5, 6).
    auto b2 = b.with(10.f);
    auto bar = b2.make<Bar>();  // Returns Bar(5, 6, 10.f).
}

Хотя std::make_from_tuple - это C ++ 17, его можно реализовать с помощью C ++14 функций:

namespace detail
{
    template <typename T, typename Tuple, std::size_t... I>
    constexpr T make_from_tuple_impl(Tuple&& t, std::index_sequence<I...>)
    {
        return T(std::get<I>(std::forward<Tuple>(t))...);
    }
}

template <typename T, typename Tuple>
constexpr T make_from_tuple(Tuple&& t)
{
    return detail::make_from_tuple_impl<T>(
        std::forward<Tuple>(t),
        std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<Tuple>>>{});
}

Answer 3

Не уверен, что я понял вашу проблему на 100%.В любом случае позвольте мне попробовать предварительный ответ: я добавил к вашему фрагменту кода шаблонный оператор неявного преобразования, который вызывает reinterpret_cast

template<typename U1, typename U2>
operator Builder<U1, U2>(){ return *reinterpret_cast<Builder<U1, U2>*>(this); }

Это обычно хакерский и небезопасный код, но в вашем случае он выполняет свою работу.он позволяет функциям-членам withT1 и withT2 быть похожими на

template <typename T1_NEW>
Builder<T1_NEW, T2   > withT1() { return *this; }

template <typename T2_NEW>
Builder<T1   , T2_NEW> withT2() { return *this; }

фрагмент, который я использовал для тестирования кода, прикреплен ниже

#include <type_traits>

template<typename T1, typename T2>
struct Foo;

template<>
struct Foo<int, double>{
    int mInt;
    double mDouble;
};

template<>
struct Foo<char, double>{
    char mChar;
    double mDouble;
};

struct t1{
    using type = int;
    static type member;
};

struct t2{
    using type = double;
    static type another;
};

struct tt1{
    using type = char;
    static type member;
};

template <typename T1 = t1, typename T2 = t2>
class Builder {
  // int param1, param2;
  Builder(int param1, int param2) : param1{param1}, param2{param2} {}
public:
  int param1, param2;
  Builder() : Builder(0, 0) {}

  template<typename U1, typename U2>
  operator Builder<U1, U2>(){ return *reinterpret_cast<Builder<U1, U2>*>(this); }

  template <typename T1_NEW>
  Builder<T1_NEW, T2   > withT1() { return *this; }

  template <typename T2_NEW>
  Builder<T1   , T2_NEW> withT2() { return *this; }

  Foo<typename T1::type, typename T2::type> make() {
    // uses T1 and T2 to populate members of foo
    return Foo<typename T1::type, typename T2::type>{T1::member, T2::another};
  }
};


int main(){
Builder<t1, t2> b;
auto c = b.withT1<tt1>();
static_assert(std::is_same<decltype(c), Builder<tt1, t2>>::value, "error");
}