Bug auf einer benutzerdefinierten C ++ Klasse

Question

Ich brauche auf der Suche nach dem Problem helfen, eine benutzerdefinierten c ++ Klasse zu verwalten 3D-Positionen verwenden. Hier ist der relevante Code aus der Klasse

  Punto operator+(Punto p){
    return Punto(this->x + p.x, this->y + p.y, this->z + p.z);
  }

  Punto operator+(Punto *p){
    return Punto(this->x + p->x, this->y + p->y, this->z + p->z);
  }

  Punto operator-(Punto p){
    return Punto(this->x - p.x, this->y - p.y, this->z - p.z);
  }

  Punto operator-(Punto *p){
    return Punto(this->x - p->x, this->y - p->y, this->z - p->z);
  }

  Punto *operator=(Punto p){
    this->x = p.x;
    this->y = p.y;
    this->z = p.z;
    return this;
  }

  Punto *operator=(Punto *p){
    this->x = p->x;
    this->y = p->y;
    this->z = p->z;
    return this;
  }

Ich verwende es hier wie folgt aus:

p = fem->elementoFrontera[i]->nodo[0] - fem->elementoFrontera[i]->nodo[1];

Wo nodo [i] ist ein Punto *, und es kompiliert in Ordnung, aber wenn ich versuche zu tun:

p = fem->elementoFrontera[i]->nodo[0] + fem->elementoFrontera[i]->nodo[1];

Der Compiler sagt:

  

In Memberfunktion void mdTOT::pintarElementosFrontera()': error: invalid operands of types Punto * 'und Punto*' to binary operator +'

Answer 1

Die erste feine kompiliert, weil Sie Zeiger in C / C ++ subtrahieren kann, aber keine Zeiger hinzufügen. Aber in jedem Fall tut es nicht, was Sie brauchen - es ist nicht Ihre überladenen Operator nicht verwendet. Da Ihre Operatoren in einer Klasse definiert sind, müssen Sie auf Klasseninstanzen arbeiten, nicht auf Zeiger. So ändern, um so etwas wie

Punto p = *(fem->elementoFrontera[i]->nodo[0]) + *(fem->elementoFrontera[i]->nodo[1]);

Eine andere Sache - Sie sollten Klassenreferenzen verwenden, nicht Werte, in Operator Definition. Z.

 Punto& operator+(const Punto& p) {

EDIT. Um den Code zu vereinfachen, können Sie eine Zugriffsfunktion, wie dies erstellen:

const Punto& NodoRef(int i, int j) {
  return *(fem->elementoFronteria[i]->Nodo[j]);
}

und dann Ihr Code wird so sauber wie

p = NodoRef(i,0) + NodoRef(i,1);

Die NodoRef kann in Ihrer fem Klasse oder außerhalb definiert werden. So stellen Sie sicher das Objekt fem im Umfang am Leben ist, wo Sie die NodoRef verwenden.

Answer 2

Die erste Version funktioniert, weil „-“ tut normale Zeigerarithmetik in diesem Fall ist es keinesfalls Ihre überladenen Operatoren nicht verwendet. „+“ ist nicht auf den normalen Zeiger definiert, so erhalten Sie einen Fehler. Damit es die überladene Version verwenden, dereferenzieren den ersten Zeiger:

p = *fem->elementoFrontera[i]->nodo[0] - fem->elementoFrontera[i]->nodo[1];

beide Zeiger Dereferenzierung sollte auch funktionieren, da Sie beide Arten von Überlastungen, aber Sie sollten Ihre Operator Definitionen ändern const Referenzen in diesem Fall zu verwenden:

Punto operator+(const Punto &p){
   ...
}

Auf diese Weise der Objekte jedes Mal, wenn „+“ nicht kopiert werden, verwendet werden.

Im Grunde wollen Sie so etwas wie dies zu tun:

const Punto operator+(Punto *left, Punto *right); // not allowed

Aber eine freie Funktion operator+ Überlastung, die zwei Zeiger nimmt und fügt sie in geeigneter Weise nicht funktioniert, weil mindestens einer der Parameter zu sein, der braucht enum oder Klassentyp . Es gibt keinen Operator für primitive Typen Überlastung und Zeiger zählen als solche.