Bug em classe um costume C ++

Question

Preciso de ajuda em encontrar o problema usando um personalizado classe C ++ para gerenciar 3D posições. Aqui está o código relevante da 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;
  }

Eu estou usando-o aqui como esta:

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

Onde nodo [i] é um Punto *, e ele compila bem, mas quando eu tento fazer:

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

O compilador diz:

Em função membro void mdTOT::pintarElementosFrontera()': error: invalid operands of types Punto * 'e Punto*' to binary operator +'

Answer 1

O primeiro compila bem, porque você pode subtrair ponteiros em C / C ++, mas não adicionar ponteiros. Mas em qualquer caso, não faz o que você precisa - não usar o seu operador sobrecarregado. Desde que seus operadores são definidos em uma classe, você precisa para operar em instâncias de classe, e não sobre ponteiros. Então, mude para algo como

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

Outra coisa - você deve usar referências de classe, e não valores, na definição de operador. Por exemplo.

 Punto& operator+(const Punto& p) {

EDIT. Para simplificar o código, você pode criar uma função de assessor, como este:

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

e, em seguida, o código torna-se tão limpa como

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

O NodoRef pode ser definido em sua classe fem, ou fora. Apenas certifique-se o objeto fem está vivo no escopo onde você usar o NodoRef.

Answer 2

A primeira versão funciona porque "-" faz aritmética ponteiro normal, neste caso, ele não usa qualquer um dos seus operadores sobrecarregados. "+" não é definido em ponteiros normais, de modo a obter um erro. Para torná-lo usar a versão sobrecarregada, dereference o primeiro ponteiro:

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

Dereferencing ambos os ponteiros também deve funcionar desde que você tem ambos os tipos de sobrecargas, mas você deve alterar as suas definições de operador usar referências const neste caso:

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

Desta forma, os objetos não são copiados cada vez que você usar "+".

Basicamente você quer fazer algo como isto:

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

Mas a sobrecarga de um operator+ função gratuito que leva dois ponteiros e adiciona-los de forma adequada não trabalha, porque pelo menos uma das necessidades de parâmetros a ser de enum ou tipo de classe . Não há sobrecarga de operador para tipos primitivos, e ponteiros contam como tal.