que - sobrecarga de constructores c++

C++-Cómo introducir el conjunto de sobrecarga a partir del número variable de bases.

Question

La clase derivada oculta el nombre de un conjunto de sobrecarga de la clase base si la clase derivada tiene el mismo nombre definido, pero siempre podemos introducir esa sobrecarga reestablecida con using-declaration:

template <class BASE>
class A : public BASE
{
public:
  using BASE::some_method;
  void some_method();
}

Pero, ¿y si introduzco todos los conjuntos de sobrecarga de las clases base variadic? ¿Podría escribir algo así?

template <class... BASES>
class A : public BASES...
{
public:
  using BASES::some_method...;
  void some_method();
}

He considerado usar una clase de ayuda como:

template <class... BASES>
struct helper;

template <>
struct helper<> {};

template <class OnlyBase>
struct helper<OnlyBase> : OnlyBase
{
  using OnlyBase::some_method;
};

template <class Base1, class... OtherBases>
struct helper<Base1, OtherBases> : public Base1, public helper<OtherBases...>
{
  using Base1::some_method;
  using helper<OtherBases...>::some_method;
};

Y funciona Pero requiere mucha escritura (por supuesto, puedo usar macro pero trato de usar la función de tiempo de compilación de C ++ siempre que sea posible), y cuando quiero introducir más métodos, tengo que cambiar mucho en esa parte del código.

Una respuesta perfecta sería una sintaxis simple, pero si no hay ninguna, iré con la clase de ayuda.

Answer 1

Aquí hay un truco sobre cómo reducir la escritura a mano:

// U<X,Y> is a binary operation on two classes
template<template<class,class>class U, class... Xs> struct foldr;
template<template<class,class>class U, class X> struct foldr<U,X> : X {};
template<template<class,class>class U, class X, class... Xs> struct foldr<U,X,Xs...> : U<X, foldr<U,Xs...>> {};

// our operation inherits from both classes and declares using the member f of them    
template<class X, class Y> struct using_f : X,Y { using X::f; using Y::f; };

struct A { void f(int) {} };
struct B { void f(char) {} };
struct C { void f(long) {} };

struct D : foldr<using_f, A, B, C> {};


int main() {
    D d;
    d.f(1);
    d.f(''1'');
    d.f(1L);
    return 0;
}

Entonces deberíamos escribir foldr una vez, luego escribir operaciones ad-hoc simples - using_f, using_g, using_f_g

Tal vez haya una forma de simplificar aún más. Déjame pensar un poco ...