[C++]Classe Punto

[franbisc]

L'esercizio richiede di creare una classe punto(un punto dovrà avere coordinate x e y) i cui metodi permettono di ottenere e impostare la posizione,e di calcolare la distanza da un altro punto.Inoltre si deve permettere all'utente,nel main, di spostare ripetutamente uno dei due punti.Inoltre si deve mostrare sempre la posizione aggiornata dei due punti.
Io ho tentato di sviluppare almeno i primi punti dell'esercizio:spero che mi aiuterete a capire dove ho sbagliato fin'ora,e a sviluppare il resto.Ecco i tre file:

#ifndef POINT_H
#define POINT_H

class Point
{
public:
    Point();
    void getPosition();
    void setPosition(float&, float&);
    float calcolaDistanza(Point*);
private:
    float x;
    float y;
};

#endif // POINT_H

#include "point.h"
#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;


Point::Point()
{
    x=0; y=0;
}

void Point::setPosition(float& x, float& y)
{
    cout<<"Inserisci il valore dell'ascissa\n";
    cin>>x;
    cout<<"Inserisci il valore dell'ordinata\n";
    cin>>y;
    }

void Point::getPosition()
{
    cout<<"Il punto ha coordinate: ";
    cout<< setprecision(4)<< x << " " <<setprecision(4)<< y << endl;
}

float Point::calcolaDistanza(Point* other)
{
    float dx = x-other->x;
    float dy = y-other->y;
    return sqrt(dx*dx+dy*dy);
}

#include <iostream>
#include "point.h"
#include <cmath>
using namespace std;

int main()
{
   float ascissa,ordinata;
   Point punto1;
   punto1.setPosition(ascissa,ordinata);
   punto1.getPosition();
   punto2.setPosition(ascissa,ordinata);
   punto2.getPosition();

   punto1.calcolaDistanza(punto2);
    return 0;
}

[vict85]

Direi che non è un buon design. Non dovresti comunque mettere cout e cin nella funzioni di una classe. È brutto e inutile: il modo in cui si inseriscono i dati dovrebbe essere indipendentemente dalla classe.

Questa è OK

Point::Point()
{
    x=0; y=0;
}

anche se esiste un metodo più veloce all'interno della classe. Manca un costruttore che setta direttamente il punto.

*************************

Questa invece è proprio sbagliata:

void Point::setPosition(float& x, float& y)
{
    cout<<"Inserisci il valore dell'ascissa\n";
    cin>>x;
    cout<<"Inserisci il valore dell'ordinata\n";
    cin>>y;
    }

Per le seguenti ragioni:
1) non usare cout e cin
2) stai scrivendo su due float che non appartengono alla classe.

Andrebbe scritta (senza reference! e meglio con costanti)

void Point::setPosition(float const x_value, float const y_value)
{
    x = x_value;
    y = y_value;
}

*************************************

Per quanto riguarda questa direi che è sul limite dell'intuilità. Senza considerare che sarebbe stato più sensato fare al suo posto l'overload di << per usarlo con cout e scrivere cout << P;

void Point::getPosition()
{
    cout<<"Il punto ha coordinate: ";
    cout<< setprecision(4)<< x << " " <<setprecision(4)<< y << endl;
}

Vediamo ora come va messa a posto. In generale devi ritornare due valori. Quindi tanto vale usare due funzioni una per la x e una per la y. Altrimenti dovresti usare reference per i valori di ritorno ma mi sembra meno utilizzabile.

Quindi:

float const Point::get_x() const
{
    float const temp = x;
    return temp;
}

float const Point::get_y() const
{
    float const temp = y;
    return temp;
}

o anche, ma lo ritengo peggio,

float Point::get_x()
{
    return x;
}

float  Point::get_y()
{
    return y;
}

************************************

La prossima va abbastanza bene. Io non la metterei nella classe ma ne farei una classe esterna.

float Point::calcolaDistanza(Point* other)
{
    float dx = x - other->x;
    float dy = y - other->y;
    return sqrt(dx*dx+dy*dy);
}

Vediamo quindi come avresti dovuto farla meglio:

float const Point::calcolaDistanza(Point& const other) const
{
    float dx = x - other.get_x();
    float dy = y - other.get_y();
    dx *= dx;
    dy *= dy;
    float const temp = sqrt(dx+dy);
    return temp;
}

in particolare è meglio usare un reference. Io ho preferito creare una variabile costante per il return ma andava abbastanza bene anche prima. Non sono però sicuro che other->x fosse permesso dato che x è privato. Ho quindi preferito usare le due funzioni get_x e get_y.

Come funzione esterna però ha dei vantaggi. Sarebbe stata scritta così:

float const Point::calcolaDistanza(Point& const P1, Point& const P2)
{
    float dx = P1.get_x() - P2.get_x();
    float dy = P1.get_y() - P2.get_y();
    dx *= dx;
    dy *= dy;
    float const temp = sqrt(dx+dy);
    return temp;
}

a questo punto la classe cambiava così (ho levato tutti i miei const che però sono molto utili):

   #ifndef POINT_H
    #define POINT_H

    class Point
    {
    public:
        Point();
        float Point::get_x();
        float Point::get_y();
        void Point::setPosition(float, float);
        float Point::calcolaDistanza(Point& other)
    private:
        float x;
        float y;
    };

    #endif // POINT_H

Anche se io l'avrei cambiata così...

   #ifndef POINT_H
    #define POINT_H

    class Point
    {
    public:
        Point();
        Point(float const , float const); // da implementare simile/identica a setPosition
        float const Point::get_x() const;
        float const Point::get_y() const;
        void Point::setPosition(float const, float const);
    private:
        float x;
        float y;
    };

    float const Point::calcolaDistanza(Point& const, Point& const);

    #endif // POINT_H

Per quanto riguarda i costruttori in realtà li avrei messi nella definizione finendo per farla diventare:

   #ifndef POINT_H
    #define POINT_H

    class Point
    {
    public:
        Point() : x(0), y(0) {};
        Point(float const x_value, float const y_value) : x(x_value), y(y_value) {};
        float const Point::get_x() const;
        float const Point::get_y() const;
        void Point::setPosition(float const, float const);
    private:
        float x;
        float y;
    };

    float const Point::calcolaDistanza(Point& const, Point& const);

    #endif // POINT_H

ed eliminando ovviamente il codice del costruttore dal file cpp...

[vict85]

Ovviamente con il codice che ho scritto devi spostare tutti i cout e i cin all'interno del main...

Quindi per esempio per settare il punto devi fare una cosa del tipo:

float x,y;
Point P;
cout<< "..." << endl;
cin >> x >> y;
P.setPosition(x,y);

oppure

float x,y;
cout<< "..." << endl;
cin >> x >> y;
Point P(x,y);

se hai creato il nuovo costruttore come ti ho scritto.

Ma a me sembra che tu non abbia compreso molto cosa sia una classe e come funzioni...

[franbisc]

Dato che questo è il primo esercizio sulle classi che tento di fare effettivamente ho dubbi sulla maggior parte delle cose.
Allora:

"vict85":
Questa invece è proprio sbagliata:

void Point::setPosition(float& x, float& y)
{
    cout<<"Inserisci il valore dell'ascissa\n";
    cin>>x;
    cout<<"Inserisci il valore dell'ordinata\n";
    cin>>y;
    }

Per le seguenti ragioni:
1) non usare cout e cin
2) stai scrivendo su due float che non appartengono alla classe.

Andrebbe scritta (senza reference! e meglio con costanti)

void Point::setPosition(float const x_value, float const y_value)
{
    x = x_value;
    y = y_value;
}

Io ho usato i reference proprio perchè avevo intenzione di modificare i float della classe,perchè col reference si ha un passaggio per indirizzo e non per valore.Mah,non avrò capito questa parte.Comunque non capisco l'utilità di usare i const per i parametri passati:insomma,sono appunto parametri passati,perchè mai si rischierebbe di modificarli?

"vict85":Senza considerare che sarebbe stato più sensato fare al suo posto l'overload di << per usarlo con cout e scrivere cout << P;

Cioè?Cos'è l'overload di << ? Alla fine qual è il metodo che mi permette di mostrare la posizione del punto?

"vict85":

float const Point::get_x() const
{
    float const temp = x;
    return temp;
}

float const Point::get_y() const
{
    float const temp = y;
    return temp;
}

Perchè dichiari costante una funzione che invece ha proprio lo scopo di modificare i campi della classe?Inoltre come fa la classe a sapere che chiamando questo metodo il valore di x e di y diventerà quello che ha immesso l'utente?

"vict85":

Per quanto riguarda i costruttori in realtà li avrei messi nella definizione finendo per farla diventare:

   #ifndef POINT_H
    #define POINT_H

    class Point
    {
    public:
        Point() : x(0), y(0) {};
        Point(float const x_value, float const y_value) : x(x_value), y(y_value) {};
        

Non ho mai visto la scrittura x(0),y(0) : equivale ad assegnare x e y a 0?
Il secondo costruttore in pratica sostituirebbe del tutto il metodo che permette di impostare la posizione?

[claudio862]

"vict85":
Andrebbe scritta (senza reference! e meglio con costanti)

void Point::setPosition(float const x_value, float const y_value)
{
    x = x_value;
    y = y_value;
}

Come mai meglio con costanti? x_value e y_value sono passati per valore, la funzione non può comunque modificare i valori originali. Anzi potrebbe aver bisogno di modificarli al suo interno, usando const si dovrebbero usare altre variabili temporanee.

float const Point::get_x() const
{
    float const temp = x;
    return temp;
}

float const Point::get_y() const
{
    float const temp = y;
    return temp;
}

o anche, ma lo ritengo peggio,

float Point::get_x()
{
    return x;
}

float  Point::get_y()
{
    return y;
}

Qual è l'utilità di usare un valore temporaneo?

Non sono però sicuro che other->x fosse permesso dato che x è privato. Ho quindi preferito usare le due funzioni get_x e get_y.

Se la implementi come funzione membro della classe Point sì. Dall'interno di una classe puoi accedere alle sue variabili private, di qualsiasi istanza.

a questo punto la classe cambiava così (ho levato tutti i miei const che però sono molto utili)

In generale sì, usare const dove possibile riduce la possibilità di modifiche impreviste e quindi bug. Ma per esempio per i valori di ritorno delle funzioni a cosa servirebbe usare const?

"Mifert4":Dato che questo è il primo esercizio sulle classi che tento di fare effettivamente ho dubbi sulla maggior parte delle cose.
Allora:

Io ho usato i reference proprio perchè avevo intenzione di modificare i float della classe,perchè col reference si ha un passaggio per indirizzo e non per valore.Mah,non avrò capito questa parte.

Quello che hai fatto tu è: dichiarare x, y nella funzione main(), passarli come parametri a punto1.setPosition(), dove vengono modificati con i valori inseriti dall'utente. Ma le variabili dell'oggetto punto1 non vengono modificate.
La procedura corretta, come ha già spiegato vict85, è avere una funzione per assegnare alle variabili x, y della classe Point dei valori arbitrari. Il vantaggio è che quei valori puoi prenderli da tastiera, da un file, scriverli direttamente nel codice… e assegnarli usando la stessa funzione.

Cioè?Cos'è l'overload di << ? Alla fine qual è il metodo che mi permette di mostrare la posizione del punto?

È un sistema per usare direttamente una classe personalizzata con gli stream.

#include <iostream>

...

std::ostream & operator<<(std::ostream & stream, const Point & point)
{
    stream << point.get_x() << ", " << point.get_y();
    return *stream;
}

...

// Ora puoi fare questo:
Point p;
std::cout << p << std::endl;

Non ho mai visto la scrittura x(0),y(0) : equivale ad assegnare x e y a 0?

Sì, è una lista di inizializzazioni. Con il vantaggio che permette di inizializzare le costanti.

class Point
{
public:
    Point(float x, float y)
    : xc(x), yc(y)
    {
        xc = x; // Questo non puoi farlo, xc è const
    }

private:
    const float xc;
    const float yc;
};

[franbisc]

ragazzi,scusate,ma non riesco ancora a raccapezzarmi.
Ho apportato queste modifiche:

#ifndef POINT_H
#define POINT_H

class Point
{
public:
    Point();
    Point(float,float);
    float getX();
    float getY();
    void setPosition(float,float);
    float calcolaDistanza(Point& other);
private:
    float x;
    float y;
};

#endif // POINT_H

#include "point.h"
#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;


Point::Point()
{
    x=0; y=0;
}

float const Point::getX()  const
{
   return x;
}

float const Point::getY() const
{
   return y;
}

float Point::calcolaDistanza(Point* other)
{
    float dx = x-other->x;
    float dy = y-other->y;
    return sqrt(dx*dx+dy*dy);
}
[/code

[code]#include <iostream>
#include "point.h"
#include <cmath>
using namespace std;

int main()
{
   float ascissa,ordinata;
   Point P1,P2;
   cout<<"Inserisci l'ascissa\n";
   cin>>ascissa;
   P1.getX(ascissa);
   cout<<"Inserisci l'ordinata\n";
   cin>>ordinata;
   P1.getY(ordinata);

   cout<<"Inserisci l'ascissa\n";
   cin>>ascissa;
   P2.getX(ascissa);
   cout<<"Inserisci l'ordinata\n";
   cin>>ordinata;
   P2.getY(ordinata);


   P1.calcolaDistanza(P2);

    return 0;
}

Non riesco ancora a capire qual è il metodo che permette di mostrare sempre la posizione aggiornata dei punti,se ho capito come va usato il metodo "calcolaDistanza",e perchè mi dà ancora errori.

[vict85]

Io metto tutto costante anche un po' per abitudine. Mettere a const una funzione interna (il const dopo le parentesi) serve invece a segnalare che la funzione non apporta modifiche alla classe. Può quindi facilitare il lavoro del compilatore. Sulla funzione di ritorno l'utilità è limitata a meno che tu non ritorni un reference (in questo caso eviti il ritorno per valore pur mantenendo l'impossibilità di accedere ad un valore privato). Metterlo invece sugli argomenti della funzione serve per segnalare al compilatore che una variabile è read_only. Se il compilatore sa che una variabile non cambia può usare metodi che non sono possibili altrimenti.

Comunque non hai bisogno di prendere come argomenti i dati private di una classe. Le funzioni interne ne hanno accesso diretto (come se fossero valori globali) mentre quelle esterne non possono accederle in ogni caso.

Che errore ti dà esattamente il compilatore?

P.S: Il main va scritto così..

int main()
{
   float ascissa, ordinata;
   Point P1, P2;
   cout<<"Inserisci l'ascissa\n";
   cin>>ascissa;
   cout<<"Inserisci l'ordinata\n";
   cin>>ordinata;
   P1.setPosition(ascissa, ordinata);
   cout << "(" <<  P1.getX()  << ", " << P1.getY() << ")" << endl;

   cout<<"Inserisci l'ascissa\n";
   cin>>ascissa;
   cout<<"Inserisci l'ordinata\n";
   cin>>ordinata;
   P2.setPosition(ascissa, ordinata);
   cout << "(" <<  P2.getX()  << ", " << P2.getY() << ")" << endl;

   cout << P1.calcolaDistanza(P2) << endl;

   return 0;
}

Altrimenti entrambi sono a (0,0)... getX e getY ritornano semplicemente x e y... Non li settano in nessun modo

[claudio862]

"Mifert4":ragazzi,scusate,ma non riesco ancora a raccapezzarmi.

Non riesco ancora a capire qual è il metodo che permette di mostrare sempre la posizione aggiornata dei punti,se ho capito come va usato il metodo "calcolaDistanza",e perchè mi dà ancora errori.

L'implementazione della classe va quasi bene, l'unico errore è la funzione calcolaDistanza() che nel header ha come parametro un riferimento Point &, mentre nel sorgente ha come parametro un puntatore Point *, mentre deve essere lo stesso (ed è meglio il riferimento, costante):

class Point
{
...
    float calcolaDistanza(const Point & other) const;
...
}

...
float Point::calcolaDistanza(const Point & other) const
{
    float dx = x - other.x;
    float dy = y - other.y;
    return sqrt(dx*dx+dy*dy);
}
...

Ho anche aggiunto il modificatore const dopo la lista degli argomenti. Così facendo indico che la funzione calcolaDistanza() non modifica le variabili interne della classe Point, permettendo così di usare quella funzione anche con oggetti costanti. Andrebbe aggiunta anche alle funzioni getX() e getY(), ma non a setPosition(), che invece modifica le variabili della classe.

Il main() invece è sbagliato. Provo riscriverlo ed a commentarlo passo passo:

int main()
{
    float ascissa,ordinata;
    Point P1,P2;

    cout<<"Inserisci l'ascissa\n";
    cin>>ascissa;
    cout<<"Inserisci l'ordinata\n";
    cin>>ordinata;
    // Ora le variabili ascissa, ordinata contengono i valori inseriti dall'utente.

    // Assegniamo questi valori al punto P1:
    P1.setPosition(ascissa, ordinata);
    // Ora le variabili interne al punto P1 sono quelle inserite dall'utente.
    // Puoi controllare:
    cout << "Il punto P1 è: " << P1.getX() << ", " << P1.getY() << endl;

    // Facciamo lo stesso con il punto P2:
    cout<<"Inserisci l'ascissa\n";
    cin>>ascissa;
    cout<<"Inserisci l'ordinata\n";
    cin>>ordinata;
    P2.setPosition(ascissa, ordinata);

    // Ora calcoliamo la distanza di P2 da P1.
    float distanza = P1.calcolaDistanza(P2);

    cout << "La distanza tra P1 e P2 è " << distanza << endl;

    return 0;
}

Per curiosità, stai studiando su un libro? Altrimenti ti consiglio Pensare in C++, traduzione italiana del famoso Thinking in C++, liberamente scaricabili.

[claudio862]

"vict85":Io metto tutto costante anche un po' per abitudine. Mettere a const una funzione interna (il const dopo le parentesi) serve invece a segnalare che la funzione non apporta modifiche alla classe. Può quindi facilitare il lavoro del compilatore.

Quello sì, mi chiedevo perché anche gli argomenti delle funzioni sono costanti. Se sono tipi primitivi passati per valore non ne vedo alcuna utilità (né alcuna controindicazione, tranne non poterli riutilizzare come variabili all'interno della funzione, ma non mi sembra così importante).

Sulla funzione di ritorno l'utilità è limitata a meno che tu non ritorni un reference (in questo caso eviti il ritorno per valore pur mantenendo l'impossibilità di accedere ad un valore privato).

Questo invece è sbagliato. Così facendo restituisci il riferimento alla variabile temporanea, che cessa di esistere quando termina la funzione (credo ricada in un undefined behaviour). Il programma seguente infatti genera un warning:

struct Point {
    const float & getX() const     {
        return this->x;
    }
    const float & getBadX() const {
        float temp = this->x;
        return temp; // Qua restituisci il riferimento a temp.
        // Qua temp cessa di esistere ed il riferimento non è più valido.
    }
    float x;
};

d.cpp: In member function 'const float& Point::getBadX() const':
d.cpp:6: warning: reference to local variable 'temp' returned

[vict85]

"claudio86":Se la implementi come funzione membro della classe Point sì. Dall'interno di una classe puoi accedere alle sue variabili private, di qualsiasi istanza.

Hai ragione. Non so da dove mi è venuto il dubbio ... Comunque non lo implementerei come funzione membro perché è una funzione simmetrica nei due elementi e necessita i due punti in sola lettura. E poi perché trovo sia meglio non appesantire l'interfaccia di una classe. Ma questi sono solo preferenze stilistiche.
In ogni caso i puntatori servono principalmente quando potrebbe essere utile usare nullptr. Per gli usi normali è meglio usare i reference (eventualmente costanti ).

[vict85]

Ma hai provato a lanciare un programma? Quello che succede è in pratica come se ritornassi a valore ma senza copia. Perché dovresti avere un reference alla variabile temporanea?

Questo a me non dà nessun errore o warning:

#include <iostream>

class Pair
{
  public:
    Pair() : _x(0), _y(0) {};
    Pair(float const x, float const y) : _x(x), _y(y) {};
    inline float x()
    {
      return _x;
    };
    inline float y()
    {
      return _y;
    };
  private:
    float _x;
    float _y;
};

class Point
{
  public:
    Point() : _xy(0,0) {};
    Point(float const x, float const y) : _xy(x,y) {};

    Pair const & getPosition() const
    {
      return _xy;
    };
  private:
    Pair _xy;
};

int main()
{
  Point P(3,5);
  Pair xy;

  xy = P.getPosition();

  std::cout << xy.x() << " " << xy.y() << std::endl;
  return 0;
}

Anche se certo l'esempio è un po banale.

[claudio862]

"vict85":Ma hai provato a lanciare un programma? Quello che succede è in pratica come se ritornassi a valore ma senza copia. Perché dovresti avere un reference alla variabile temporanea?

Ok, c'è stato un malinteso, scusami. Quando tu hai risposto:

"vict85":Io metto tutto costante anche un po' per abitudine. Mettere a const una funzione interna (il const dopo le parentesi) serve invece a segnalare che la funzione non apporta modifiche alla classe. Può quindi facilitare il lavoro del compilatore. Sulla funzione di ritorno l'utilità è limitata a meno che tu non ritorni un reference (in questo caso eviti il ritorno per valore pur mantenendo l'impossibilità di accedere ad un valore privato)

Io ho interpretato la parte in grassetto come risposta alla domanda "Qual è l'utilità di usare un valore temporaneo?" relativa ai tuoi esempi:

"vict85":

float const Point::get_x() const
{
    float const temp = x;
    return temp;
}

float const Point::get_y() const
{
    float const temp = y;
    return temp;
}

o anche, ma lo ritengo peggio,

float Point::get_x()
{
    return x;
}

float  Point::get_y()
{
    return y;
}

Invece stavi ancora parlando dell'utilità generale di const.

Però in effetti a quella domanda non hai risposto. Perché ritieni meglio il primo metodo?

[franbisc]

"claudio86":Per curiosità, stai studiando su un libro? Altrimenti ti consiglio Pensare in C++, traduzione italiana del famoso Thinking in C++, liberamente scaricabili.

Si,ho solamente il capitolo sulle classi del "C++ Fondamenti di programmazione" dei Deitel,il Pensare in c++ ho provato a leggerlo ma l'ho ritenuto troppo "fuorviante" e prolisso e soprattutto difficile da seguire per un neofita

[vict85]

"claudio86":
Invece stavi ancora parlando dell'utilità generale di const.

Però in effetti a quella domanda non hai risposto. Perché ritieni meglio il primo metodo?

A parte il const della funzione che ha ovvi vantaggi, immagino solo un vezzo stilistico

[vict85]

"Mifert4":[quote="claudio86"]Per curiosità, stai studiando su un libro? Altrimenti ti consiglio Pensare in C++, traduzione italiana del famoso Thinking in C++, liberamente scaricabili.

Si,ho solamente il capitolo sulle classi del "C++ Fondamenti di programmazione" dei Deitel,il Pensare in c++ ho provato a leggerlo ma l'ho ritenuto troppo "fuorviante" e prolisso e soprattutto difficile da seguire per un neofita[/quote]

Un po' prolisso lo è, difficile non penso. Personalmente l'ho sempre considerato per neofiti. Ci sono libri molto più difficili.

[franbisc]

Grazie ,come sempre siete la mia salvezza.
Anche se mi restano dubbi su alcuni punti,ad esempio:il secondo costruttore dove li prende i valori da assegnare ad x e y?

[vict85]

"Mifert4":Grazie ,come sempre siete la mia salvezza.
Anche se mi restano dubbi su alcuni punti,ad esempio:il secondo costruttore dove li prende i valori da assegnare ad x e y?

Esattamente come setposition... Mi sa che ti sei persa qualche principio sulle classi.

Tu hai delle variabili e funzioni private che sono visibili e accessibili dalla altre funzioni della classe (per loro sono come delle variabili globali). Oltre a queste devono prendere alcune variabili dall'esterno come ogni altra funzione.

Quindi nella classe:

class A {
public:
   A();
   A(float b);
   float f(int c);
private:
   float a;
};

Il costruttore A è una funzione che ha come argomento una variabile di tipo float chiamata b e può scrivere su a. Similmente f può leggere e scrivere a oltre che usare l'argomento c di tipo int.

[claudio862]

"Mifert4":Grazie ,come sempre siete la mia salvezza.
Anche se mi restano dubbi su alcuni punti,ad esempio:il secondo costruttore dove li prende i valori da assegnare ad x e y?

Quando tu definisci un oggetto stai implicitamente chiamando il suo costruttore. Se ci sono diversi costruttori allora puoi scegliere quale chiamare:

#include <string>

class Point
{
public:
    // 4 costruttori diversi:
    Point() : x(0), y(0) {}
    Point(float x, float y) : x(x), y(y) {}
    Point(const Point & other) : x(other.x), y(other.y) {}
    Point(const std::string & text)
    {
        // Codice che ottiene le due coordinate da una stringa di testo.
    }

private:
    float x;
    float y;
};

int main()
{
    Point p1; // Costruttore 1, inizializza p1.x = 0 e p1.y = 0
    Point p2(4, 6); // Costruttore 2, inizializza p2.x = 4 e p2.y = 6
    Point p3(p1); // Costruttore 3 (costruttore di copia), inizializza p3.x = p1.x e p3.y = p1.y
    Point p4("1,5"); // Costruttore 4, legge la stringa ed inizializza p4.x = 1 e p4.y = 5

    // I costruttori si possono anche chiamare esplicitamente
    Point p5 = Point(5, 6);
    // O con l'operatore new
    Point * p6 = new Point("6,7");

    // P.S.
    // Per fare questo invece devi definire l'operatore di assegnamento
    // (che probabilmente affronterai in seguito).
    //p1 = p5;
}

[franbisc]

Ok,capito