[C++] Membri private di una classe ed accessibilità (solo in lettura)

[vendettaaaaa]

Ciao,
tanto per disobbedire a !fazz stavo giochicchiando con le classi...e ho incontrato un errore in compilazione.
Ho due classi: una per definire un punto, che ha come membri private double x e double y:

class Point
{
public :
	Point();
	Point(double, double);
	double GetX();
	double GetY();
	void SetPos(double, double);
	double Distance(Point*);
	~Point();

private :
	double x;
	double y;
};

la funzione Distance(Point*) calcola la distanza tra l'oggetto istanziato ed un altro oggetto della stessa classe Point:

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

E così funziona; other è un puntatore ad un oggetto di classe Point, quindi per accedere ai suoi membri x e y uso l'operatore ->, ovvero (*other).
Prima domanda: è normale che possa accedere direttamente ad x e y anche se sono private, indipendentemente se voglio scrivere o leggere tali variabili?

Ora, ho fatto una classe Circle che viene costruita con 2 parametri: un Point* e un double (il raggio):

class Circle
{
public:
	Circle();
	Circle(Point*, double);
	~Circle();
	void SetCircle(Point*, double);
	Point* GetCenter();
	double GetRadius();
	double Area();
	double Perimeter();

private:
	double radius;
	Point* center;
};

Circle::Circle(Point* point, double r)
{
	this->radius = r;
	center = new Point(point -> GetX(), point->y);
}

perchè l'operazione in rosso mi da "error: y is inaccessible" se in Distance potevo farlo? Ho cercato su cplusplus.com e company ma non ho trovato nulla.

Dopo aver scritto il messaggio m'è venuto in mente che forse in Distance posso perchè quella funzione è all'interno della classe Point, e other appartiene a quella classe, mentre il costruttore di Circle è una classe a sè stante, può essere?

[GByTe87]

Banalmente, le istanze di una classe possono accedere a tutti i membri (anche privati) delle altre istanze della stessa classe.

Qua lo spiegano un po' meglio di me.

[vendettaaaaa]

Originariamente inviato da GByTe87

Banalmente, le istanze di una classe possono accedere a tutti i membri (anche privati) delle altre istanze della stessa classe.

Qua lo spiegano un po' meglio di me.

Ah ok allora la mia intuizione era più o meno azzeccata...ma allora sto "private" non è così blindato dopotutto
Grazie del link! Lo leggerò attentamente!

[lishi]

Originariamente inviato da vendettaaaaa

Ah ok allora la mia intuizione era più o meno azzeccata...ma allora sto "private" non è così blindato dopotutto
Grazie del link! Lo leggerò attentamente!

Lo scopo è blindarne implementazione, non i valori.

Ecco spiegato meglio il concetto.

Mettiamo che esista una classe

class pippo{
private:
int fattiIFattiTuoi;
public:
pippo();
pippo( const pippo& p );

}

Come faresti implementare il costruttore di copia se non potessi accedere a fattiIfattiTuoi?

Dovresti prevedere un GetFattiIFattiTui() che non fa nulla altro che ritornare il valore.

Solo che magari questo membro non serve a nulla per un eventuale utilizzatore della classe. Come detto Nascondere implementazione non il valore.

[vendettaaaaa]

Originariamente inviato da lishi

Lo scopo è blindarne implementazione, non i valori.

Ecco spiegato meglio il concetto.

Mettiamo che esista una classe

class pippo{
private:
int fattiIFattiTuoi;
public:
pippo();
pippo( const pippo& p );

}

Come faresti implementare il costruttore di copia se non potessi accedere a fattiIfattiTuoi?

Dovresti prevedere un GetFattiIFattiTui() che non fa nulla altro che ritornare il valore.

Solo che magari questo membro non serve a nulla per un eventuale utilizzatore della classe. Come detto Nascondere implementazione non il valore.

Uhm ok credo di esserci qua: si usa private per evitare di manipolare l'implementazione di un attributo della classe (cioè double x non può essere trasformato in int x, oppure double x non può essere inizializzato in maniera differente da come pensato nella classe; si può solo accedere al suo valore, ok?), ma ho ripensato un attimo al post #2 e non mi torna una cosa:

Originariamente inviato da GByTe87

le istanze di una classe possono accedere a tutti i membri (anche privati) delle altre istanze della stessa classe

Un'istanza di una classe è un oggetto di quella classe, giusto? Ho sempre letto "when a class is istantiated an object of that class is created".
Se è così, allora perchè il costruttore di center, che appartiene alla classe Point, non riesce ad accedere ai membri privati di un'altra istanza (point) ma della stessa classe (Point)?

center = new Point(point -> GetX(), point -> y);

Cosa mi sfugge?

[GByTe87]

Originariamente inviato da vendettaaaaa

Un'istanza di una classe è un oggetto di quella classe, giusto? Ho sempre letto "when a class is istantiated an object of that class is created".
Se è così, allora perchè il costruttore di center, che appartiene alla classe Point, non riesce ad accedere ai membri privati di un'altra istanza (point) ma della stessa classe (Point)?

center = new Point(point -> GetX(), point -> y);

Cosa mi sfugge?

Perchè, in questo caso, non è il costruttore della classe che sta cercando di accedere al membro privato di point.

[MaxN]

Circle e Point sono due classi distinte. Poichè y in Point è private, solo le member functions (o metodi se preferisci) della classe Point possono manipolarla direttamente.

Altre classi, anche se discendenti, non possono accederci direttamente.

L'unico modo per permettere ad una funzione di Circle di leggere direttamente (-> y o .y) un membro di Point, è di dichiararlo public, o, nel caso di classe discendente da Point, protected.

[vendettaaaaa]

Originariamente inviato da GByTe87

Perchè, in questo caso, non è il costruttore della classe che sta cercando di accedere al membro privato di point.

...finisci la frase!
A me pare che il costruttore Point(double, double) cerchi di tirar fuori il secondo double dall'oggetto point usando l'operatore ->

[GByTe87]

Originariamente inviato da vendettaaaaa

...finisci la frase!
A me pare che il costruttore Point(double, double) cerchi di tirar fuori il secondo double dall'oggetto point usando l'operatore ->

Quello è l'errore; il costruttore di Point riceve un double, non un puntatore ad un oggetto di tipo Point.
Il codice che si occupa di deferenziare il puntatore all'oggetto point e ad accedere al suo membro privato... è il costruttore di Circle.

[vendettaaaaa]

Originariamente inviato da GByTe87

Quello è l'errore; il costruttore di Point riceve un double, non un puntatore ad un oggetto di tipo Point.
Il codice che si occupa di deferenziare il puntatore all'oggetto point e ad accedere al suo membro privato... è il costruttore di Circle.

Ecco, così ho capito benissimo, grandi!
Pensavo che point->y avesse il significato di "return y" e che quindi fosse l'oggett point (di classe Point, quindi potendolo fare) che si occupasse direttamente dell'estrazione del valore, invece è la funzione di classe Circle che va a cercare il valore puntato...eccellente