Bug sur une classe C ++ personnalisée

Question

J'ai besoin d'aide pour trouver le problème en utilisant une classe c ++ personnalisée pour gérer les positions 3D. Voici le code pertinent de la 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;
  }

Je l'utilise ici comme ceci:

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

Où nodo [i] est un Punto * et que la compilation est bonne, mais lorsque j'essaie de le faire:

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

Le compilateur dit:

  

Dans la fonction membre void   mdTOT :: pintarElementosFrontera () ':   erreur: opérandes de types invalides    Punto * 'et Punto *' en binaire    opérateur + '

Answer 1

Le premier compile bien parce que vous pouvez soustraire des pointeurs en C / C ++, mais pas en ajouter. Mais dans tous les cas, il ne fait pas ce dont vous avez besoin - il n’utilise pas votre opérateur surchargé. Comme vos opérateurs sont définis dans une classe, vous devez opérer sur des instances de classe et non sur des pointeurs. Alors, changez quelque chose comme

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

Autre chose - vous devez utiliser des références de classe, et non des valeurs, dans la définition de l'opérateur. Ex.

 Punto& operator+(const Punto& p) {

EDIT. Pour simplifier le code, vous pouvez créer une fonction d’accesseur, comme suit:

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

et votre code devient aussi propre que

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

Le NodoRef peut être défini dans votre classe fem ou à l’extérieur. Assurez-vous simplement que l’objet fem est actif dans la portée où vous utilisez NodoRef.

Answer 2

La première version fonctionne car "" - ". fait arithmétique normale de pointeur dans ce cas, il n’utilise aucun de vos opérateurs surchargés. " + " n'est pas défini sur les pointeurs normaux, vous obtenez donc une erreur. Pour qu’il utilise la version surchargée, déréférencez le premier pointeur:

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

Le déréférencement des deux pointeurs devrait également fonctionner car vous avez les deux types de surcharge, mais vous devez modifier les définitions de votre opérateur pour utiliser les références const dans ce cas:

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

Ainsi, les objets ne sont pas copiés à chaque fois que vous utilisez " + ".

En gros, vous voulez faire quelque chose comme ça:

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

Mais surcharger une fonction libre opérateur + qui prend deux pointeurs et les ajoute de manière appropriée ne fonctionne pas, car au moins un des paramètres doit être de type d’énumération ou de classe . Il n'y a pas de surcharge d'opérateur pour les types primitifs, et les pointeurs comptent comme tels.