calling operators of base class... safe?

Is following pattern ok/safe ? Or are there any shortcomings ? (I also use it for equality operators)

Derived& operator=(const Derived& rhs)
{
    st开发者_JS百科atic_cast<Base&>(*this) = rhs;
    // ... copy member variables of Derived
    return *this;
}

This is fine, but it's a lot more readable IMHO to call the base-class by name:

Base::operator = (rhs);

Yes, it's safe.

A different syntax to do the same thing could be:

Base::operator=( rhs );

That's better to use

Base::operator=(rhs);

because if your base class have a pure virtual method the static_cast is not allowed.

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
        }
}