[C++] - Ridefinizione Operatori->HELP()

[milazzo.g]

Buonasera, come sempre mi rivolgo a tutti voi e ringrazio tutti in anticipo. Chiedevo aiuto sul seguente problema: avendo una mia classe dichiarata in un header come:

namespace Geometrics{
    class Point{
        public:
            //... costruttori, distruttore, etc...
            const Point *operator=(const Point *_p);
            void set_x(double _x);
            void set_y(double _y);
            double get_x();
            double get_y();
            //... altre funzioni...
        private:
            double *x;
            double *y;
    };
}

e imprementata in un sorgente come:

//...
const Geometrics::Point *Geometrics::Point::operator=(const Geometrics::Point *_p){
    this->set_x(_p->get_x());
    this->set_y(_p->get_y());
}
void Geometrics::Point::set_x(double _x){
    *(this->x) = _x;
}
void Geometrics::Point::set_y(double _y){
    *(this->y) = _y;
}
double Geometrics::Point::get_x(){
    return *(this->x);
}
double Geometrics::Point::get_y(){
    return *(this->y);
}
//...

vorrei che, quando dichiaro due puntatori ad oggetto:

//... dichiarazioni, main(), etc..
Geometrics::Point *p1 = new Geometrics::Point(1.1, 1.1);
Geometrics::Point *p2 = new Geometrics::Point(2.2, 2.2);

assegnando p2 a p1

p1 = p2;

venisse chiamato l'operatore da me ridefinito... Ma chiaramente ciò non accade! ...
se invece esplicitamente chiamo l'operatore con questa sintassi:

p1->operator=(p2);

tutto viene eseguito alla perfezione... Gentilmente chiedo quindi, c'è qualcosa che dimentico nel codice? Ringrazio di nuovo in anticipo chiunque abbia voglia di darmi una spiegazione,
Saluti,
Giuseppe

[maluz1]

non hai messo il return nell'overload dell'operatore

[MItaly]

L'operatore che hai definito opera su oggetti di tipo Geometrics::Point, ma tu stai facendo un assegnamento tra puntatori a Geometrics::Point (e l'assegnamento tra puntatori non è ridefinibile, per ovvi motivi). Se vuoi che l'assegnamento funzioni effettualo tra due oggetti:

Geometrics::Point *p1 = new Geometrics::Point(1.1, 1.1);
Geometrics::Point *p2 = new Geometrics::Point(2.2, 2.2);
*p1=*p2;

O, molto meglio:

Geometrics::Point p1(1.1, 1.1);
Geometrics::Point p2(2.2, 2.2);
p1=p2;

dato che non mi pare abbia alcun senso allocare questi due oggetti nell'heap (se vieni da Java, in C++ new si usa molto più di rado).

[milazzo.g]

(e l'assegnamento tra puntatori non è ridefinibile, per ovvi motivi). Se vuoi che l'assegnamento funzioni effettualo tra due oggetti:

Pensavo fosse possibile ridefinirlo! Grazie infinite, cambio tutto quindi con

const Point &operator=(const Point &_p);
//...
const Geometrics::Point &Geometrics::Point::operator=(const Geometrics::Point &_p){
    this->set_x(_p.get_x());
    this->set_y(_p.get_y());
    return *this;
}

e utilizzo come:

*p1 = *p2;