C++ ¿Cómo es que no puedo asignar una clase base a una clase para niños?

Question

tengo código como este:

class Base 
{ 
public: 
    void operator = (const Base& base_) 
    { 
    } 
}; 

class Child : public Base 
{ 
public: 

}; 

void func() 
{ 
    const Base base; 
    Child child; 
    child = base; 
} 

Mi pregunta es: desde niño se deriva de Base (por lo tanto, debe heredar operador de Base =), ¿cómo es que cuando se ejecuta la instrucción

child = base; 

, me conseguir un error del compilador de esta manera:

>.\main.cpp(78) : error C2679: binary '=' : no operator found which takes a right-hand operand of type 'const Base' (or there is no acceptable conversion) 
1>  .\main.cpp(69): could be 'Child &Child::operator =(const Child &)' 
1>  while trying to match the argument list '(Child, const Base)' 

el comportamiento que quiero es para la clase de niño a reconocer que está siendo asignado una clase base, y justo "automáticamente" llama al operador de su padre =.

Una vez que he añadido el código a la clase infantil

void operator = (const Base& base_) 
{ 
    Base::operator=(base_); 
} 

entonces todo compilado bien. Aunque no creo que esto sea bueno porque si tengo como 5 clases diferentes que heredan de Base, entonces tengo que repetir el mismo código en cada clase derivada.

NOTA: Mi intención para copiar el Base a Child es simplemente copiando los miembros que son comunes tanto Base y Child (que sería todos los miembros de Base). Incluso después de leer todas las respuestas a continuación, realmente no veo por qué C++ no permite que uno lo haga, especialmente si hay un operator= explícito definido en la clase Base.

Answer 1

El estándar proporciona el motivo de la pregunta específica de 12,8/10 "objetos de la clase de copia" (énfasis añadido):

Debido a que un operador de asignación de copia se declara implícitamente por una clase si no declarada por el usuario , un operador de asignación de copia de clase base siempre está oculto por el operador de asignación de copia de una clase derivada (13.5.3).

Así que ya que hay un declarado implícitamente operator=(const Child&) cuando el compilador está realizando la resolución/sobrecarga de búsqueda de nombres para un Child::operator=(), firma de la función de la clase Base ni siquiera se considera (que está escondido).

Answer 2

El problema es que no puede asignar un valor constante a una variable no constante. Si pudiera, podría modificar el valor constante modificando la variable no constante.

¿Es necesario que la base esté const? Lo pregunto porque realmente te encuentras con dos problemas: const correctness y inheritence/polymorphism.

EDITAR: Estoy dudando de mi primera declaración. ¿Alguna aclaración?

Answer 3

Porque una base no es un niño. Considere lo siguiente:

class Child : public Base 
{ 
public: 
    SomeFunc(); 
}; 

void func() 
{ 
    const Base base; 
    Child child; 
    child = base; 
    child.SomeFunc();  // whatcha gonna call? 
} 

ACTUALIZACIÓN: Para responder a la pregunta en el comentario, child.SomeFunc(); es perfectamente legal - es sólo un problema si ésimo valor de child no es realmente un objeto secundario. El compilador no puede permitir child = base; porque crearía una situación donde falla la llamada legal.

Answer 4

Cuando no declara explícitamente la asignación de copia, el compilador de C++ creará la asignación de copia para usted. En su caso, sería

class Child : public Base 
{ 
public: 
Child& operator=(const Child& rhs) { ... } 

}; 

Y es por eso que obtiene este error de compilación. Además, tiene más sentido devolver una referencia a sí mismo cuando proporciona una asignación de copia porque le permitirá encadenar al operador.

No es una buena idea declarar una asignación de copia como esta.

void operator = (const Base& base_) 
{ 
    Base::operator=(base_); 
} 

No veo por qué solo quiere copiar la parte de la clase base cuando realiza una asignación de copia.

Answer 5

No puede asignar Base a Niño porque Child podría no ser la base. Para utilizar el ejemplo típico animal, lo que tenemos aquí es:

const Animal animal; 
Dog dog; 
dog = animal; 

Pero animal podría ser un gato, y que sin duda no puede asignar un gato a un perro.

Dicho esto, no se podía hacerlo a la inversa, ya sea:

const Dog dog; 
Animal animal; 
animal = dog; 

Un perro sin duda es un animal, pero hay un problema de talla aquí. animal ocupa espacio sizeof(Animal) en la pila, pero dog ocupa espacio sizeof(Dog), y esas dos cantidades pueden ser diferentes.

Cuando se trabaja con polimorfismo en C++, debe trabajar con referencias o punteros. Por ejemplo, la siguiente es bien:

Dog* const dog; 
Animal* animal; 
animal = dog; 

En este caso, el tamaño de un puntero es el mismo, independientemente de lo que apunta, por lo que la asignación es posible. Tenga en cuenta que aún necesita mantener las conversiones de jerarquía correctas. Incluso cuando se utiliza un puntero, no se puede asignar una Base a un Niño, por la razón que expliqué anteriormente: Una Base puede ser algo completamente diferente del Niño.

Answer 6

La respuesta es más aterradora de lo que pensaba. Usted puede hacer esto. El evens estándar tiene una pequeña nota al respecto en la sección 7.3.3 El principal problema es que el operador = que se define de forma predeterminada en Child oculta el operator = de Base, por lo que debe importarlo de nuevo al ámbito de clase utilizando "using ".

Esto compila OK para mí. Sin embargo, considero que esta idea es muy aterradora y potencialmente plagada de comportamientos indefinidos si se necesita inicializar algo en Child.

class Base 
{ 
public: 
    void operator = (const Base& base_) 
    { 
    } 
}; 

class Child : public Base 
{ 
public: 
using Base::operator=; 

}; 

int main() 
{ 
    const Base base = Base(); 
    Child child; 
    child = base; 
} 

EDITAR: Hizo la base const nuevamente y evitó el error "const no inicializada".

Answer 7

El código siguiente es el comportamiento que quería desde el principio, y que compila,

class Base 
{ 
public: 
    void operator = (const Base& base_) 
    { 
    } 
}; 

class Child : public Base 
{ 
}; 

void func() 
{ 
    const Base base; 

    Child child; 

    child.Base::operator=(base); 
} 

nunca supe que se puede llamar explícitamente a algo como:

child.Base::operator=(base); 

De todos modos, he aprendido mucho. Gracias por todas las personas que publicaron respuestas aquí.

Answer 8

Esto no es realmente una respuesta, pero la pregunta de cómo hacerlo ha sido respondida. Este es el porqué, no.

Las clases deben significar algo. Debería haber cosas útiles que pueda decir sobre cualquier objeto bien formado en la clase ("invariantes de clase"), porque de esa manera puede razonar acerca de los programas sobre la base de cómo funciona una clase. Si una clase es simplemente una colección de miembros de datos, no puede hacer eso, y tiene que razonar sobre el programa en función de cada elemento de datos individual.

El operador de asignación propuesto cambiará todos los miembros de datos en la clase base, pero no tocará los definidos en la clase secundaria. Esto significa una de dos cosas.

Si un objeto secundario está bien formado después de que otro objeto base se vierte en su componente base, significa que los miembros de datos adicionales no tienen una conexión real con los miembros de datos base. En ese caso, Child no es realmente un subtipo de Base, y la herencia pública es la relación incorrecta. El niño no está en una relación "is-a" con Base, sino más bien con una relación "tiene-a". Esto generalmente se expresa por composición (Child tiene un miembro de datos base) y también se puede expresar por herencia privada.

Si un objeto secundario no está bien formado después de que otro objeto base se vierte en su componente base, el operador de asignación propuesto es un método realmente rápido y conveniente para estropear una variable.

Por ejemplo, tengamos una clase base de mamíferos y dos clases secundarias, Cetacean y Bat. El animal tiene cosas como el tamaño y el peso, y las clases de los niños tienen campos relacionados con lo que comen y cómo se mueven. Asignamos un Cetáceo a un Mamífero, lo cual es razonable (todos los campos específicos de Cetáceos se acaban de soltar), y ahora asignamos ese Mamífero a un Murciélago. De repente, tenemos un bate de veinte toneladas.

Con un conjunto de clases bien diseñado, la única forma en que puedo concebir que este operador de asignación siquiera se piense es si las clases secundarias no tienen datos adicionales, solo comportamiento adicional, e incluso entonces es sospechoso.

Por lo tanto, mi único consejo es volver a hacer el diseño de la clase. Muchas personas, particularmente las que están familiarizadas con Java y otros lenguajes que tienden a jerarquías de herencia profunda, usan la herencia demasiado en C++. C++ generalmente funciona mejor con una gran cantidad de clases base y una jerarquía relativamente poco profunda.