typecast bei vererbung

StarCraftFeuerteufel

class base
{
  public:
    base();
    base(base const& src);
//...
} foo_base;

class derived : public base
{
  public:
    derived();
    derived(derived const& src);
//...
} foo_derived;

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

Bashar

Beide Formen sind äquivalent, in beiden Fällen wird ein neues base-Objekt aus dem gegebenen derived-Objekt konstruiert (Copy-Ctor, Slicing). Du willst wahrscheinlich nach base& casten.

StarCraftFeuerteufel

eine weitere frage ist noch, wenn ich in beiden klassen einen operator (z.B. *=) definiert habe und zwei objekte von type derived habe, wie kann ich sagen, dass er den operator aus der base-klasse anstatt dem aus der derived klasse nutzen soll? das zielt darauf ab, das der derived operator bei mir auf den base-operator aufsetzt. er macht also nur noch was zusätzliches ansonsten genau das gleiche wie der base-operator.

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;

Bashar

derived operator *= (derived const &rhs)
    {
         return base::operator*=(rhs); // würd ich sagen      
    };

StarCraftFeuerteufel

sorry, ich glaub der code war etwas falsch.

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

StarCraftFeuerteufel

ok, ich habs raus

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

muss es heißen.

hustbaer

wieso nicht einfach so?

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