operatori di assegnazione di overload quando la classe è un figlio

Question

Come si impostano i membri della classe base utilizzando l'implementazione dell'operatore di assegnazione? Se per esempio qualcuno definisce l'operatore di assegnazione in una classe derivata simili:

(dove sia colour e Colour() sono membri della classe base - significa le linee indicate sotto sono illegali)

Derived& Derived::operator=(const Derived& rhs) 
{ 
if (&rhs != this) 
{ 

    Colour(rhs.colour); // not allowed 
     Colour(rhs.Colour()); // not allowed 
} 
return *this; 
} 

qual è il soluzione? C'è un modo per collegare i sovraccarichi dell'operatore nella base? Devo fare qualcosa di simile ...

Derived& Derived::operator=(const Derived& rhs) : Base::operator=(rhs) 
...? 

Answer 1

Sei vicino, basta mettere la chiamata nel corpo del metodo.

if (&rhs != this) 
{ 
    Base::operator=(rhs); 
    // ... 

Answer 2

Si dovrebbe essere in grado di utilizzare funzioni di accesso pubblici e mutators:

Derived& Derived::operator=(const Derived& rhs) 
{ 
    if (&rhs != this) 
     SetColour(rhs.GetColour()); 
    return *this; 
} 

Altrimenti rendere i membri protetti della classe base in modo che le classi derivate hanno accesso:

Derived& Derived::operator=(const Derived& rhs) 
{ 
    if (&rhs != this) 
     colour = rhs.colour; 
    return *this; 
} 

una terza opzione potrebbe essere quella di definire un pubblico operatore di assegnazione nella classe di base e avere la vostra chiamata classe derivata l'operatore di base:

Derived& Derived::operator=(const Derived& rhs) 
{ 
    if (&rhs != this) 
     Base::operator=(rhs); 
    return *this; 
} 

Ecco un banco di prova completa:

#define TEST 2 
class Base 
{ 
public: 
    Base() : m_protected(0), m_private(0) {} 
    Base(int pro, int pri) : m_protected(pro), m_private(pri) {} 
    ~Base() {} 

#if TEST == 1 
    Base& operator=(const Base& rhs) 
    { 
     if (this != &rhs) 
     { 
      m_protected = rhs.m_protected; 
      m_private = rhs.m_private; 
     } 

     return *this; 
    } 
#elif TEST == 2 
    void SetPrivate(int i) { m_private = i; } 
    int GetPrivate() const { return m_private; } 
#endif 

protected: 
    int m_protected; 
private: 
    int m_private; 
}; 

class Derived : public Base 
{ 
public: 
    Derived() : Base() {} 
    Derived(int pro, int pri) : Base(pro, pri) {} 
#if TEST == 1 
    Derived& operator=(const Derived& rhs) 
    { 
     Base::operator=(rhs); 
     return *this; 
    } 
#elif TEST == 2 
    Derived& operator=(const Derived& rhs) 
    { 
     if (this != &rhs) 
     { 
      SetPrivate(rhs.GetPrivate()); 
      m_protected = rhs.m_protected; 
     } 
     return *this; 
    } 
#endif 
}; 

int main() 
{ 
    Derived a; 
    Derived b(10, 5); 

    a = b; 
     return 0; 
} 

Answer 3

a implementare l'operatore = funzionalità assegnazione/colore costruire nel operatore di classe di base se si vuole chiamare l'operatore Base = dall'utilizzo della classe derivata:

Base::operator=(rhs) 

nell'operatore Classe derivata =() implementazione. La firma che hai proposto per Operatore derivato = non è C++ valido per quanto ne so.

Answer 4

E 'fatto così:

class B 
{ 
public: 
    B& operator=(const B & other) 
    { 
    v = other.v; 
    return *this; 
    } 
    int v; 
}; 

class D : public B 
{ 
public: 
    D& operator=(const D & other) 
    { 
    B::operator=(other); 
    return *this; 
    } 
};