3. Zuweisungsoperator

Zuweisungsoperator

  • R

    Ich versuce einen Zuweisungsoperator mit zugehöriger assign-Funkion zu schreiben. Ich erhalte aber folgende Fehlermeldungen:

    void Punkt3D::assign(const Punkt2D& a)
    {
    const Punkt3D * b = dynamic_cast<const Punkt3D *>(&a);
    assert(NULL != b);
    Punkt2D::assign(a);
    z_ = b.z_;
    }

    Punkt3D& Punkt3D::operator=(const Punkt3D& b)
    {
    Punkt3D::assign(b);
    return *this;
    }

    -`z_' is not a type
    -request for member of non-aggregate type before ';' token

    Wenn ich die assign-Funktion folgendermaßen schreiben, erhalte ich andere Fehlermeldungen:

    void Punkt4D::assign(const Punkt2D& a)
    {
    const Punkt4D& c = dynamic_cast<const Punkt4D*>(*a);
    assert(NULL != c);
    Punkt2D::assign(a);
    w_ = c.w_;
    }

    Punkt4D& Punkt4D::operator=(const Punkt4D& p)
    {
    Punkt4D::assign(p);
    return *this;
    }

    -no match for 'operator*' in '*a'
    -no match for 'operator!=' in '0 != c'

    Brauche bitte dringend Hilfe? Eine Erklärung der Fehlermeldungen wäre vor allem sehr hilfreich...

    0
  • C

    b ist ein pointer - zugriff auf die member der klasse, auf die dieser zeigt erhälst du folglich per -> operator

    void Punkt4D::assign(const Punkt2D& a)
{
const Punkt4D& c = dynamic_cast<const Punkt4D*>(*a);
assert(NULL != c);
Punkt2D::assign(a);
w_ = c.w_;
}

    derr umgekehrte fall, hier hast du referenzen und benutzt pointeroperationen.

    0
  • R

    Da bedank ich mich recht herzlich...

    0
  • R

    Hab es jetzt folgendermaßen umgeschrieben:

    void Punkt4D::assign(const Punkt2D& a)
{
    const Punkt4D* c = dynamic_cast<const Punkt4D*>(&a);
    assert(NULL != c);
    Punkt2D::assign(a);
    w_ = c->w_;
}

Punkt4D& Punkt4D::operator=(const Punkt4D& c)
{
    Punkt4D::assign(c);
    return *this;
}

    Jetzt sind die Fehlermeldungen weg, aber die Zuweisung erfolgt nicht???

    --CODETAGS BENUTZEN!

    0

  • Ein 2D-Punkt ist ein 4D-Punkt?

    Autocogito

    Bye, TGGC (Das Eine, welches ist.)

    0
  • R

    Das ganze sieht folgendermaßen aus:

    void Punkt2D::ausgeben(ostream& os) const{
    begrenzerAusgeben(os,start());
    komponentenAusgeben(os);
    begrenzerAusgeben(os,stop());
}
void Punkt2D::einlesen(istream& is){
    begrenzerEinlesen(is,start());
    komponentenEinlesen(is);
    begrenzerEinlesen(is,stop());
}
const int Punkt2D::x() const{
    return x_;
}
const int Punkt2D::y() const{
    return y_;
}
bool Punkt2D::gleich(const Punkt2D& p) const{
    return (x() == p.x() &&
            y() == p.y());
}
const char& Punkt2D::start(){
    return start_;
}
const char& Punkt2D::stop(){
    return stop_;
}
const char& Punkt2D::trenner(){
    return trenner_;
}
Punkt2D& Punkt2D::operator=(const Punkt2D& p){
    Punkt2D::gleich(p);
    return *this;
}
void Punkt2D::begrenzerAusgeben(ostream& os,char begrenzer) const{
    os << begrenzer;
}
void Punkt2D::komponentenAusgeben(ostream& os) const{
    os << x();
    begrenzerAusgeben(os,trenner());
    os << y();
}
void Punkt2D::begrenzerEinlesen(istream& is,char begrenzer){
    char c;
    do
    {
        is >> c;
    }
    while (c != begrenzer);
}
void Punkt2D::komponentenEinlesen(istream& is){
    is >> x_;
    begrenzerEinlesen(is,trenner());
    is >> y_;
}
// Initialisierung der statischen Memberkonstanten von Punkt2D
const char Punkt2D::start_ = '(';
const char Punkt2D::stop_ = ')';
const char Punkt2D::trenner_ = '|';
// freie Operatorfunktionen
ostream& operator<<(ostream& os,const Punkt2D& punkt){
    ostream::sentry vorUndNacharbeiten(os);
    if (vorUndNacharbeiten)
        punkt.ausgeben(os);
    return os;
}
istream& operator>>(istream& is,Punkt2D& punkt){
    istream::sentry vorUndNacharbeiten(is);
    if (vorUndNacharbeiten)
        punkt.einlesen(is);
    return is;
}
bool operator==(const Punkt2D& p1,const Punkt2D& p2){
    if (&p1 == &p2)
        return true;
    if (typeid(p1) != typeid(p2))
        return false;
    return p1.gleich(p2);
}
// Memberfunktionen von Punkt3D
void Punkt3D::komponentenAusgeben(ostream& os) const{
    Punkt2D::komponentenAusgeben(os);
    begrenzerAusgeben(os,trenner());
    os << z();
}
void Punkt3D::komponentenEinlesen(istream& is){
    Punkt2D::komponentenEinlesen(is);
    begrenzerEinlesen(is,trenner());
    is >> z_;
}
bool Punkt3D::gleich(const Punkt2D& p) const{
    const Punkt3D * p3d = dynamic_cast<const Punkt3D *>(&p);
    assert(("Unzulaessige Typumwandlung",p3d != NULL));
    return Punkt2D::gleich(p) && z() == p3d->z();
}
Punkt3D& Punkt3D::operator=(const Punkt3D& p){
    Punkt3D::gleich(p);
    return *this;
}
// Memberfunktionen von Punkt4D
void Punkt4D::komponentenAusgeben(ostream& os) const{
    Punkt3D::komponentenAusgeben(os);
    begrenzerAusgeben(os,trenner());
    os << w();
}
void Punkt4D::komponentenEinlesen(istream& is){
    Punkt3D::komponentenEinlesen(is);
    begrenzerEinlesen(is,trenner());
    is >> w_;
}
bool Punkt4D::gleich(const Punkt2D& p) const{
    const Punkt4D * p4d = dynamic_cast<const Punkt4D *>(&p);
    assert(("Unzulaessige Typumwandlung",p4d != NULL));
    return Punkt2D::gleich(p) && w() == p4d->w();
}
int Punkt4D::w() const{
    return w_;
}
Punkt4D& Punkt4D::operator=(const Punkt4D& p){
    Punkt4D::gleich(p);
    return *this;
}

    Und diese Zuweisung in der Main funktioniert nicht:
    Punkt2D & p7 = p5,
    & p8 = p6;
    p7 = p8;

    0
Anmelden zum Antworten