llamando a operadores de clase base ... ¿seguros?

Question

¿El siguiente patrón es correcto/seguro? ¿O hay alguna deficiencia? (también lo utilizan para operadores de igualdad)

Derived& operator=(const Derived& rhs) 
{ 
    static_cast<Base&>(*this) = rhs; 
    // ... copy member variables of Derived 
    return *this; 
} 

Answer 1

Esto está muy bien, pero es un montón en mi humilde opinión más legible para llamar a la clase base por su nombre:

Base::operator = (rhs); 

Answer 2

Sí, es seguro.

Una sintaxis diferente para hacer lo mismo podría ser:

Base::operator=(rhs); 

Answer 3

Eso es mejor usar

Base::operator=(rhs); 

porque si su clase base tiene un método virtual puro no se permite que el static_cast.

class Base { 
    // Attribute 
    public: 
     virtual void f() = 0; 
    protected: 
     Base& operator(const Base&); 
} 

class Derived { 
    public: 
     virtual void f() {}; 
     Derived& operator=(const Derived& src) { 
      Base::operator=(src); // work 
      static_cast<Base&>(*this) = src; // didn't work 
     } 
}