ich möchte gerne wissen ob es zwischen den beiden folgenden anweisungen einen nennenswerten unterschied gibt?

foo_base = (base)foo_derived; //hier sollte ja nur eine reduzierung von derived auf base stattfinden, oder?
foo_base = base(foo_derived); //ruft er hier den copy-konstrukter auf oder 'reduziert' der die derived-klasse einfach nur auf die base-klasse

class base
{
  public:
    base();
    base(base const& src);
    base operator *= (base const &rhs);
//...
} foo_base;

class derived : public base
{
  public:
    derived();
    derived(derived const& src);
    derived operator *= (derived const &rhs)
    {
      //hier soll der operator *= aus der base-klasse verwendet werden
    };
//...
} foo_derived;

class derived : public base
{
  public:
    derived();
    derived(derived const& src);
    derived &operator *= (derived const &rhs)
    {
      //hier soll der operator *= aus der base-klasse verwendet werden
      //sowas wie *this base::operator *= derived
      //aber da meckert er bei mit rum wenn ich sowas schreib
      //weiter anweisungen
      return *this;
    };
};

(*this).base::operator *=(derived);

muss es heißen.

foo& operator =(foo const& other)
{
    static_cast<base&>(*this) = other;
}

solange der operator = nicht virtual ist (was er IMO nie sein sollte) sollte das dasselbe bewirken.

EDIT: ok, operator *= in den fall (und nicht operator =), ändert aber nix /EDIT