legaler illegaler Zugriff? Kopierkonstruktor

Jud4s

Wieso ist folgender Code legal?

Point::Point(const Point& p) : x(p.x),
			       y(p.y) {}

Wenn in der Klassendeklaration

class Point {
	const int x;
	const int y;

public:
	Point(int,int);
	Point(const Point&);
	int get_x();
	int get_y();
};

steht, also sowohl x als auch y private sind (und wieso ist das die einzige Möglichkeit den Kopierkonstruktor zu implementieren? Wieso kann ich nicht die getter benutzen?)

danke für eure Antworten

Wieso ist folgender Code legal?

Die Frage gab es erst vor kurzem:
http://www.c-plusplus.net/forum/281468

Eisflamme

Hi,

weil Zugriffe auf private Member eines anderen Objekts derselben Klasse grundsätzlich erlaubt sind.
weil man in Elementinitialisierern keine Methoden aufrufen darf Tiefer gehendes dazu weiß ich leider nicht.

Die Klasse Point darf natürlich auf ihre eigenen Member zugreifen. Auch dann wenn sie privat sind. Damit sind sie von außen nicht zugreifbar, aber von innen natürlich schon.

Da du Point als konstantes Objekt übergibst, können so oder so auch nur konstante Funktionen ausgeführt werden. Also mach die Getter auch konstant. Das gehört übrigens zum guten Stil und du solltest dir das ohnehin angewöhnen.

class Point {
    const int x;
    const int y;

public:
    Point(int, int);
    Point(const Point&);

    int get_x() const; // konstant
    int get_y() const; // konstant
};

#include <iostream>

class Point
{
private:
	int x_;
	int y_;

public:
	Point(int x = 0, int y = 0) 
		: x_(x), y_(y) 
	{
	}

	Point(const Point& point) 
		: x_(point.getX()), y_(point.getY()) 
	{
	}

	void setX(int x) { x_ = x; }
	void setY(int y) { y_ = y; }

	void set(int x, int y) { setX(x); setY(y); }

	int getX() const { return x_; }
	int getY() const { return y_; }
};

void printPoint(const Point& point);

int main()
{
	Point p; // Standardkonstruktor

	printPoint(p);

	p = Point(10, 12);

	printPoint(p);

	p.setX(100);
	p.setY(20);

	printPoint(p);

	p.set(500, 12);

	printPoint(p);

	Point p2(p);

	printPoint(p2);

	return 0;
}

void printPoint(const Point& point)
{
	std::cout << point.getX() << ", " << point.getY() << std::endl;
}

Kompiliert in MSVC 2010.

Jud4s

ok, danke

besonders das mit den const gettern war lernenswert. (jetzt funktionieren auch die getter in der Elementinitliste)

Eisflamme schrieb:

weil man in Elementinitialisierern keine Methoden aufrufen darf Tiefer gehendes dazu weiß ich leider nicht.

Das, das du da ansprichst, nennt sich Initialisierungsliste, und man kann in dieser sehr wohl Methoden aufrufen.

Der Zugriffsmodifizierer private sagt, dass ein Zugriff von außen (außerhalb der eigenen Klasse) nicht erlaubt ist, und deine Methode bzw. Konstruktor gehört ja zu dieser Klasse, und ist somit kein Zugriff von außen.

lg

Eisflamme

Ok, mein Fehler.

Elementinitialisierungsliste oder eben Elementinitialisierer kenne ich aber synonym als Begriffe.