Bug su una classe C ++ personalizzata

Question

Ho bisogno di aiuto per trovare il problema usando una classe c ++ personalizzata per gestire le posizioni 3D. Ecco il codice pertinente della classe

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

Lo sto usando qui in questo modo:

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

Dove nodo [i] è un Punto *, e si compila bene, ma quando provo a fare:

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

Il compilatore dice:

  

Nella funzione membro nullo   mdTOT :: pintarElementosFrontera () ':   errore: operandi di tipi non validi    Punto * 'e Punto *' in binario    operatore + '

Answer 1

Il primo viene compilato correttamente perché è possibile sottrarre i puntatori in C / C ++, ma non aggiungere i puntatori. Ma in ogni caso non fa quello che ti serve - non usa il tuo operatore sovraccarico. Poiché i tuoi operatori sono definiti in una classe, devi operare su istanze di classe, non su puntatori. Quindi, cambia in qualcosa del tipo

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

Un'altra cosa: dovresti usare riferimenti di classe, non valori, nella definizione dell'operatore. Per es.

 Punto& operator+(const Punto& p) {

EDIT. Per semplificare il codice, è possibile creare una funzione di accesso, come questa:

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

e quindi il tuo codice diventa pulito come

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

Il NodoRef può essere definito nella tua classe fem o fuori. Assicurati solo che l'oggetto fem sia vivo nell'ambito in cui usi NodoRef.

Answer 2

La prima versione funziona perché " - " fa l'aritmetica normale del puntatore in questo caso, non usa nessuno degli operatori sovraccarichi. & Quot; + " non è definito sui normali puntatori, quindi viene visualizzato un errore. Per farlo usare la versione sovraccarica, fai riferimento al primo puntatore:

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

Anche il dereferenziamento di entrambi i puntatori dovrebbe funzionare poiché si hanno entrambi i tipi di sovraccarico, ma in questo caso è necessario modificare le definizioni dell'operatore per utilizzare i riferimenti const:

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

In questo modo gli oggetti non vengono copiati ogni volta che usi " + " ;.

Fondamentalmente vuoi fare qualcosa del genere:

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

Ma il sovraccarico di una funzione gratuita operator + che accetta due puntatori e li aggiunge in modo appropriato non funziona, perché almeno uno dei parametri deve essere enum o tipo di classe . Non vi è alcun sovraccarico da parte dell'operatore per i tipi primitivi e i puntatori contano come tali.