Error en una clase de C ++ personalizada

Question

Necesito ayuda para encontrar el problema usando una clase de c ++ personalizada para administrar las posiciones 3D. Aquí está el código relevante de la clase

  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 estoy usando aquí así:

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

Donde nodo [i] es un Punto *, y se compila bien, pero cuando intento hacerlo:

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

El compilador dice:

  

En la función miembro void   mdTOT :: pintarElementosFrontera () ':   error: operandos de tipos inválidos    Punto * 'y Punto *' a binario    operador + '

Answer 1

El primero compila bien porque puedes restar los punteros en C / C ++, pero no agregarlos. Pero en cualquier caso, no hace lo que necesita, no utiliza su operador sobrecargado. Dado que sus operadores están definidos en una clase, necesita operar en instancias de clase, no en punteros. Por lo tanto, cambiar a algo como

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

Otra cosa: debe usar referencias de clase, no valores, en la definición del operador. Por ejemplo,

 Punto& operator+(const Punto& p) {

EDITAR. Para simplificar el código, puede crear una función de acceso, como esta:

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

y luego su código se vuelve tan limpio como

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

El NodoRef se puede definir en su clase fem o fuera. Solo asegúrate de que el objeto fem esté vivo en el ámbito donde usas NodoRef.

Answer 2

La primera versión funciona porque " - " hace aritmética de punteros normal en este caso, no utiliza ninguno de sus operadores sobrecargados. " + " no está definido en los punteros normales, por lo que recibe un error. Para hacer que use la versión sobrecargada, elimine la referencia al primer puntero:

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

La desreferenciación de ambos punteros también debería funcionar ya que tiene ambos tipos de sobrecargas, pero debe cambiar sus definiciones de operador para usar referencias const en este caso:

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

De esta manera, los objetos no se copian cada vez que usas " + " ;.

Básicamente quieres hacer algo como esto:

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

Pero la sobrecarga de una función libre operator + que toma dos punteros y los agrega de una manera adecuada no funciona, porque al menos uno de los parámetros debe ser de enum o tipo de clase . No hay sobrecarga de operadores para los tipos primitivos, y los punteros cuentan como tales.