Tipo abstracto devuelto en la clase base

Question

En un diseño de una jerarquía de clases, estoy usando una clase base abstracta que declara varios métodos que implementarían las clases derivadas. En cierto sentido, la clase base está lo más cerca posible de una interfaz en C++. Sin embargo, hay un problema específico. Considere el siguiente código que declara nuestra clase de interfaz:

class Interface { 
public: 
    virtual Interface method() = 0; 
}; 

class Implementation : public Interface { 
public: 
    virtual Implementation method() { /* ... */ } 
}; 

Por supuesto, esto no sería compilar, porque no se puede volver una clase abstracta en C++. Para solucionar este problema que estoy usando la siguiente solución:

template <class T> 
class Interface { 
public: 
    virtual T method() = 0; 
}; 

class Implementation : public Interface<Implementation> { 
public: 
    virtual Implementation method() { /* ... */ } 
}; 

esta solución funciona y es todo lo fino y elegante, sin embargo, para mí, no se ve muy elegante, debido al poco redundante de texto cuál sería el parámetro para la interfaz. Me alegraría si ustedes pudieran señalar nuestros otros problemas técnicos con este diseño, pero esa es mi única preocupación en este momento.

¿Hay alguna manera de deshacerse de ese parámetro de plantilla redundante? Posiblemente usando macros?

Nota: El método en cuestión tiene que devolver una instancia. Soy consciente de que si method() devolviera un puntero o una referencia, no habría ningún problema.

Answer 1

Interface::method() no se puede devolver una instancia de Interface sin utilizar un puntero o referencia. Devolver una instancia que no sea de puntero Interface requiere instanciar una instancia de Interface, lo que es ilegal porque Interface es abstracto. Si desea que la clase base para devolver una instancia de objeto, usted tiene que utilizar uno de los siguientes:

Un puntero:

class Interface 
{ 
public: 
    virtual Interface* method() = 0; 
}; 

class Implementation : public Interface 
{ 
public: 
    virtual Interface* method() { /* ... */ } 
}; 

Una referencia:

class Interface 
{ 
public: 
    virtual Interface& method() = 0; 
}; 

class Implementation : public Interface 
{ 
public: 
    virtual Interface& method() { /* ... */ } 
}; 

un parámetro de plantilla:

template<type T> 
class Interface 
{ 
public: 
    virtual T method() = 0; 
}; 

class Implementation : public Interface<Implementation> 
{ 
public: 
    virtual Implementation method() { /* ... */ } 
}; 

Answer 2

Si bien no puede devolver valor obvio Easons, es completamente en Aceptar para volver punteros o referencias - esto se llama "tipo de retorno covariantes", y es una forma válida de primordial función virtual:

struct Base { virtual Base * foo(); } 
struct Derived : Base { virtual Derived * foo(); } 

El punto es que Derived::foo() es una verdadera anulación , y no una sobrecarga de ocultación de base, porque Derived* es un puntero a una clase derivada de Base. Lo mismo se aplica a las referencias.

En otras palabras, si usted tiene un Base * p, y se llama a p->foo(), siempre se puede tratar el resultado como un puntero a Base (pero si tiene información adicional, como la que su clase es, de hecho, Derived, entonces puede usar esa información).

_{El orden de composición opuesto, es decir, "tipos de argumentos contravariantes", no está permitido como parte de C++.}