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

[vendettaaaaa]

Ciao,
tanto per disobbedire a !fazz :D 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 (http://stackoverflow.com/questions/3832613/access-private-elements-of-object-of-same-class)lo spiegano un po' meglio di me. :asd:

[vendettaaaaa]

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

Qua (http://stackoverflow.com/questions/3832613/access-private-elements-of-object-of-same-class)lo spiegano un po' meglio di me. :asd:
Ah ok allora la mia intuizione era più o meno azzeccata...ma allora sto "private" non è così blindato dopotutto :D
Grazie del link! Lo leggerò attentamente!

[lishi]

Ah ok allora la mia intuizione era più o meno azzeccata...ma allora sto "private" non è così blindato dopotutto :D
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]

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:
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]

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. :D

[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]

Perchè, in questo caso, non è il costruttore della classe che sta cercando di accedere al membro privato di point. :D
...finisci la frase! :D
A me pare che il costruttore Point(double, double) cerchi di tirar fuori il secondo double dall'oggetto point usando l'operatore ->

[GByTe87]

...finisci la frase! :D
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]

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! :D
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 :D