C++: ¿Cómo puedo evitar el "tipo de retorno covariante no válido" en clases heredadas sin conversión?

Question

Tengo una jerarquía de clases bastante compleja en la que las clases son cruzadas dependiendo de cada una: Hay dos clases abstractas A y C que contienen un método que devuelve una instancia de C y A, respectivamente. En sus clases heredadas, quiero usar un tipo de covariante, que en este caso es un problema, ya que no conozco una forma de reenviar: declarar la relación de herencia.

Obtengo un "test.cpp: 22: error: tipo de retorno de covariante no válido para 'virtual D * B :: outC()'" - error ya que el compilador no sabe que D es una subclase de C.

class C; 

class A { 
public: 
     virtual C* outC() = 0; 
}; 

class C { 
public: 
     virtual A* outA() = 0; 
}; 


class D; 

class B : public A { 
public: 
     D* outC(); 
}; 

class D : public C { 
public: 
     B* outA(); 
}; 

D* B::outC() { 
     return new D(); 
} 

B* D::outA() { 
     return new B(); 
} 

Si cambio el tipo de retorno de B :: outC() a C *, el ejemplo se compila. ¿Hay alguna manera de mantener B * y D * como tipos de devolución en las clases heredadas (sería intuitivo para mí que haya una manera)?

Answer 1

No conozco ninguna forma de tener miembros covariantes directamente acoplados en C++. Tendrás que añadir una capa o implementar tú mismo el retorno covariante.

Para la primera opción

class C; 

class A { 
public: 
     virtual C* outC() = 0; 
}; 

class C { 
public: 
     virtual A* outA() = 0; 
}; 


class BI : public A { 
public: 
}; 

class D : public C { 
public: 
     BI* outA(); 
}; 

class B: public BI { 
public: 
     D* outC(); 
}; 

D* B::outC() { 
     return new D(); 
} 

BI* D::outA() { 
     return new B(); 
} 

y para la segunda

class C; 

class A { 
public: 
     C* outC() { return do_outC(); } 
     virtual C* do_outC() = 0; 
}; 

class C { 
public: 
     virtual A* outA() = 0; 
}; 


class D; 

class B : public A { 
public: 
     D* outC(); 
     virtual C* do_outC(); 
}; 

class D : public C { 
public: 
     B* outA(); 
}; 

D* B::outC() { 
     return static_cast<D*>(do_outC()); 
} 

C* B::do_outC() { 
     return new D(); 
} 

B* D::outA() { 
     return new B(); 
} 

Tenga en cuenta que esta segunda opción es lo que se hace implícitamente por el compilador (con algunas comprobaciones estáticas que el static_cast es válida) .

Answer 2

No puede hacer esto debido a las expectativas del lado del cliente. Al usar una instancia C, no puede decir qué tipo de C es (una D u otra cosa). Por lo tanto, si almacena el puntero B (resultante de una llamada a la clase derivada pero no lo conoce en tiempo de compilación) en un puntero A, no estoy seguro de que todas las cosas de la memoria sean correctas.

Cuando llama a un método en un tipo polimórfico, el entorno de tiempo de ejecución tiene que verificar el tipo dinámico del objeto y mueve los punteros para adaptarse a su jerarquía de clases. No estoy seguro de que deba confiar en la covarianza. Eche un vistazo a this

Answer 3

Hasta donde yo sé, no hay forma de hacerlo sin una conversión explícita. El problema es que la definición de la clase B no puede saber que D es una subclase de C hasta que ve una definición completa de la clase D, pero la definición de clase D no puede saber que B es una subclase de A hasta que se ve una definición completa de la clase B, por lo que tiene una dependencia circular. Esto no se puede resolver con forward-declarations porque desafortunadamente una declaración forward no puede especificar una relación de herencia.

Hay un problema similar al tratar de implementar un método coherente clone() utilizando plantillas, which I found can be solved, pero la solución análoga sigue fallando porque la referencia circular sigue siendo imposible de resolver.