¿Se puede obtener el tipo de una clase base de un tipo de plantilla automáticamente?

Question

Estoy tratando de usar la meta-programación de plantillas para determinar la clase base. ¿Hay alguna manera de obtener la clase base automáticamente sin especializarse explícitamente para cada clase derivada?

class foo { public: char * Name() { return "foo"; }; }; 
class bar : public foo { public: char * Name() { return "bar"; }; }; 

template< typename T > struct ClassInfo { typedef T Base; }; 
template<> struct ClassInfo<bar> { typedef foo Base; }; 

int main() 
{ 
    ClassInfo<foo>::Base A; 
    ClassInfo<bar>::Base B; 

    std::cout << A.Name(); //foo 
    std::cout << B.Name(); //foo 
} 

por ahora cualquier método automático tendría que seleccionar la primera base declarada y fallaría para las bases privadas.

Answer 1

Mis soluciones no son realmente automáticas, pero lo mejor que se me ocurre.solución

intrusiva C++ 03:

class B {}; 

class A : public B 
{ 
public: 
    typedef B Base; 
}; 

no intrusiva solución C++ 03:

class B {}; 

class A : public B {}; 

template<class T> 
struct TypeInfo; 

template<> 
struct TypeInfo<A> 
{ 
    typedef B Base; 
}; 

Answer 2

No conozco ninguna plantilla de selección de clase base, y no estoy seguro de que exista o incluso sea una buena idea. Hay muchas formas en que esto rompe la extensibilidad y va en contra del espíritu de la herencia. Cuando bar hereda públicamente foo, bares unfoo para todos los fines prácticos, y el código del cliente no debería necesitar distinguir la clase base y la clase derivada.

un typedef público en la clase base menudo roza la pica puede que tenga que haber rayado y es más claro:

class foo { public: typedef foo name_making_type; ... }; 

int main() { 
    Foo::name_making_type a; 
    Bar::name_making_type b; 
} 

Answer 3

Es posible con C++ 11 y decltype. Para eso, explotaremos que un puntero a miembro no es un puntero en la clase derivada cuando el miembro se hereda de una clase base.

Por ejemplo:

struct base{ 
    void f(){} 
}; 
struct derived : base{}; 

El tipo de &derived::f será void (base::*)(), no void (derived::*)(). Esto ya era cierto en C++ 03, pero era imposible obtener el tipo de clase base sin especificarlo realmente. Con decltype, es fácil y sólo necesita esta pequeña función:

// unimplemented to make sure it's only used 
// in unevaluated contexts (sizeof, decltype, alignof) 
template<class T, class U> 
T base_of(U T::*); 

Uso:

#include <iostream> 

// unimplemented to make sure it's only used 
// in unevaluated contexts (sizeof, decltype, alignof) 
template<class T, class R> 
T base_of(R T::*); 

struct base{ 
    void f(){} 
    void name(){ std::cout << "base::name()\n"; } 
}; 
struct derived : base{ 
    void name(){ std::cout << "derived::name()\n"; } 
}; 

struct not_deducible : base{ 
    void f(){} 
    void name(){ std::cout << "not_deducible::name()\n"; } 
}; 

int main(){ 
    decltype(base_of(&derived::f)) a; 
    decltype(base_of(&base::f)) b; 
    decltype(base_of(&not_deducible::f)) c; 
    a.name(); 
    b.name(); 
    c.name(); 
} 

Salida:

base::name() 
base::name() 
not_deducible::name() 

Como último ejemplo muestra, es necesario utilizar un elemento que se es en realidad un miembro heredado de la clase base en la que está interesado.

The re son más defectos, sin embargo: El miembro también debe identificar de forma inequívoca un miembro de la clase base:

struct base2{ void f(){} }; 

struct not_deducible2 : base, base2{}; 

int main(){ 
    decltype(base_of(&not_deducible2::f)) x; // error: 'f' is ambiguous 
} 

Eso es lo mejor que se puede conseguir, sin embargo, sin el apoyo del compilador.

Answer 4

¿Qué pasa con la clase base? ¿Eres un programador de .NET o Java?

C++ admite herencia múltiple, y tampoco tiene una clase base común global. Entonces, un tipo de C++ puede tener cero, una o muchas clases base. El uso del artículo definido está por lo tanto contraindicado.

Dado que la clase base no tiene sentido, no hay forma de encontrarla.

Answer 5

Busco a una solución portátil para problemas similares durante meses. Pero aún no lo encuentro.

G ++ tiene __bases y __direct_bases. Puede envolverlos en una lista de tipos y luego acceder a cualquiera de sus elementos, p. a std::tuple con std::tuple_element. Ver libstdc++'s <tr2/type_traits> para el uso.

Sin embargo, esto no es portátil. Clang++ currently has no such intrinsics.

Answer 6

con C++ 11, puede crear un método intrusivo para tener siempre un miembro base_t, cuando su clase sólo se hereda de uno de los padres:

template<class base_type> 
struct labeled_base : public base_type 
{ 
    using base_t = base_type; // The original parent type 
    using base::base; // Inherit constructors 

protected: 
    using base = labeled_base; // The real parent type 
}; 

struct A { virtual void f() {} }; 

struct my_class : labeled_base<A> 
{ 
    my_class() : parent_t(required_params) {} 

    void f() override 
    { 
     // do_something_prefix(); 
     base_t::f(); 
     // do_something_postfix(); 
    } 
}; 

Con esa clase, que siempre tendrá un parent_t alias, para llamar a los constructores padre como si fueran los constructores base con un nombre (probablemente) más corto y un alias base_t, para hacer que su clase no sea consciente del nombre de tipo de clase base si tiene una plantilla larga o pesada.

El alias parent_t está protegido para no exponerlo al público. Si no desea que el alias base_t sea público, siempre puede heredar labeled_base como protected o private, sin necesidad de cambiar la definición de clase labeled_base.

Esa base debe tener 0 en tiempo de ejecución o sobrecarga de espacio ya que sus métodos están en línea, no hacen nada y no tienen atributos propios.