L'opérateur d'assignation de l'héritage

Il y a ce code:

#include <iostream>

class Base {
public:
    Base(){
        std::cout << "Constructor base" << std::endl;
    }
    ~Base(){
        std::cout << "Destructor base" << std::endl;
    }
    Base& operator=(const Base& a){
        std::cout << "Assignment base" << std::endl;
    }
};

class Derived : public Base{
public:

};

int main ( int argc, char **argv ) {
    Derived p;
    Derived p2;
    p2 = p;
    return 0;
}

La sortie après la compilation par g++ 4.6:

Constructor base
Constructor base
Assignment base
Destructor base
Destructor base

Pourquoi opérateur d'affectation de la classe de base est appelé bien, il est dit que l'opérateur d'affectation n'est pas héréditaire?

double possible de des Problèmes avec l'héritage de l'opérateur= en C++

OriginalL'auteur scdmb | 2012-02-06

c++inheritance

16

Vous n'avez pas de défaut
```
Derived& operator=(const Base& a);
```
dans votre Derived classe.

Un opérateur d'affectation par défaut, cependant, est créé:
```
Derived& operator=(const Derived& a);
```
et cela demande de l'opérateur d'affectation de Base. Il n'est donc pas une question d'hériter de l'opérateur d'affectation, mais de l'appeler via le générées par défaut par l'opérateur dans votre classe dérivée.

l'opérateur= est hériter de la classe en fonction que je cite à partir de 98 c++ standard "fonctions de l'Exploitant sont héritées de la même manière que les autres de la classe de base fonctions." Il a juste été caché par implicitement créé opérateur= pour la classe Dérivée.
"Il a juste été caché par implicitement créé opérateur= pour la classe Dérivée". Tout comme dans le cas de la classe de base a void func(int) et dérivée de la classe a void func(double), de la classe de base de la fonction void func(int) est caché. Sur les mêmes lignes de la classe de base de l'opérateur= est caché par classe dérivée de l'opérateur=.
...et pour être clair, depuis la base operator= n'a été caché, il peut être visible dans la classe dérivée avec using Base::operator=; et boom: il est héréditaire. Voir: stackoverflow.com/questions/4122214/...
si elle n'est pas hérité de le rendre privé dans la classe de base et de voir le résultat

OriginalL'auteur Luchian Grigore
34

En fait, ce qui est appelé est implicitement défini operator = pour Derived. La définition fournie par le compilateur appelle à son tour operator = pour la Base et de vous voir à la sortie correspondante. La même chose est avec le constructeur et le destructeur. Lorsque vous laissez le compilateur pour définir operator =, il se définit comme suit:
```
Derived& operator = (const Derived& rhs)
{
    Base1::operator =(rhs);
    ...
    Basen::operator =(rhs);
    member1 = rhs.member1;
    ...
    membern = rhs.membern; 
}
```
où Base1,...,Basen sont les bases de la classe (dans l'ordre de les spécifier dans la liste d'héritage) et member1, ..., membern sont les membres de la Dérivée (sans compter les membres qui ont été héritées) dans l'ordre que vous avez déclaré dans la définition de la classe.

OriginalL'auteur Armen Tsirunyan
23

Vous pouvez également utiliser "utiliser":
```
class Derived : public Base{
public:
    using Base::operator=;
};
```
http://en.cppreference.com/w/cpp/language/using_declaration

J'ai lu ce post plusieurs fois avant que quelqu'un ne m'a aidé avec cela.

Enfin, quelqu'un l'a dit. +1. Voir aussi: stackoverflow.com/questions/4122214/...

OriginalL'auteur Paul Thomas
7

Standard dit (12.8):

Un opérateur d'affectation doit être mis en œuvre par un non-membre statique
fonction avec un seul paramètre. Parce qu'une copie de l'assignation
opérateur de opérateur= est implicitement déclarée pour une classe, si non déclarée
par l'utilisateur (12.8), une classe de base de l'opérateur d'affectation est toujours caché
par l'opérateur d'assignation de copie de la classe dérivée.

et puis la cession de l'opérateur de dérivée appelez votre base de

La implicitement défini par copier/déplacer opérateur d'affectation pour une non-union
la classe X effectue memberwise de copie/déplacement de cession de ses sous-objets.
La direct les classes de base de X sont affectés en premier, dans l'ordre de leur
la déclaration dans la base de spécificateur de liste, et puis l'immédiat
non aux données membres statiques de X sont affectés, dans l'ordre dans lequel ils
ont été déclarés dans la définition de classe.

OriginalL'auteur Yola
-1

C'est parce que l'affectation par défaut de l'opérateur créé l'appelle de base de l'opérateur d'affectation, c'est à dire qu'il n'est pas héréditaire, mais encore appelée dans le cadre de l'affectation par défaut de l'opérateur.

L'opérateur d'affectation hérité de la base. Il est juste caché par le compilateur généré dans la classe dérivée. À l'aide de using Base::operator=; serait de prouver cela en activant la base de la mise en œuvre et de la rendre disponible via la classe dérivée. Voir: stackoverflow.com/questions/4122214/...

OriginalL'auteur Cpt. Red
-1

Opérateur d'affectation est en effet pas hérité. Héritant que l'opérateur vous permet d'assigner un Base à un Derived, cependant Base b; p = a; sera (à juste titre) ne parviennent pas à compiler.

Ce qui se passe est que le compilateur génère un operator=, puisque vous n'avez pas défini un programme personnalisé pour Derived. L'générée automatiquement operator= va appeler les opérateurs d'affectation de l'ensemble de toutes les classes de base et de tous les membres. Dans cette perspective, il est à peu près le même que les constructeurs/destructeurs, qui a également appeler la fonction correspondante sur toutes les Bases/les membres de l'.

L'opérateur d'affectation hérité de la base. Il est juste caché par le compilateur généré dans la classe dérivée. À l'aide de using Base::operator=; serait de prouver cela en activant la base de la mise en œuvre et de la rendre disponible via la classe dérivée. Voir: stackoverflow.com/questions/4122214/...

OriginalL'auteur Grizzly

Vous devez vous connecter pour publier un commentaire.