ich lese gerade den in diesem Forum für Neulinge empfohlenen C++ Kurs von Wolfgang Schröder und habe gerade die Übung des Kapitels über virtuelle Memberfunktoinen geschrieben Übung des Kapitels über virtuelle Memberfunktoinen (die Übung ist ganz unten auf der Seite.

Das war soweit auch kein Problem, allerdings hab ich folgendes noch nicht 100% verstanden:
Wenn ich von einer Basisklasse eine SubKlasse ableite, so erhält diese alle Eigenschaften und Memberfunktionen der Basisklasse.
Wird über private, protected und public nur das Zugriffsrecht auf die entsprechenden Member definiert, oder werden beispielsweise als private deklarierte Eigenschaften garnicht erst vererbt?
Soweit ich das verstanden hab werden sie vererbt, aber auf sie besteht eben dann kein Zugriff.
Arbeite ich allerdings mit virtuellen Funktionen und später mit einem Pointer vom Typ der Basisklasse, so kann ich doch auch auf die ursprügnlich als private deklarierten member zugreifen, wenn ich die entsprechende Anfrage immer an die Basisklasse weiterleite.

Ich hab die Übung folgendermassen geschrieben:
HEADER

#include <string>
#ifndef _MYWinBase_
#define _MYWinBase_
//-----WinBase------
class WinBase {
private:
	int width, height;
	int xpos, ypos;
protected:
	WinBase();
	WinBase(int xpos, int ypos, int height, int width);
public:
	virtual void PrintProperties (void) const;
	virtual ~WinBase()=0;
};

//-----Window-------
class Window: public WinBase {
protected:
	std::string beschriftung;
public:
	Window (std::string titel);
	Window (int xpos, int ypos, int height, int width, std::string titel);
	~Window ();
	void PrintProperties (void) const;
};

//-----Button-------
class Button: public Window {
private:
	int buttonID;
	static int idcounter;
public :
	Button (std::string titel);
	Button (int xpos, int ypos, int height, int width, std::string titel);
	~Button ();
	void PrintProperties (void) const;
};
#endif

und Definitionen + main-Fkt:

#include <iostream>
#include "test.h"

//____DEFINITIONEN___________
//-----WinBase------
WinBase::WinBase():width(200),height(100),xpos(10),ypos(10) {
}
WinBase::WinBase(int xpos, int ypos, int height, int width)
		  :width(width),height(height),xpos(xpos),ypos(ypos) {
}
WinBase::~WinBase() {
	std::cout<<"WinBase dtor\n";
}
void WinBase::PrintProperties() const {
	std::cout<<"Position: ("<<xpos<<","<<ypos<<")\n"
			 <<"Groesse: ("<<height<<","<<width<<")\n";
}

//-----Window-------
Window::Window(std::string titel):WinBase(),beschriftung(titel) {}
Window::Window(int xpos, int ypos, int height, int width, std::string titel)
		:WinBase(xpos, ypos,height,width),beschriftung(titel) {}
Window::~Window() {
	std::cout<<"Window dtor\n";
}
void Window::PrintProperties() const {
	WinBase::PrintProperties();
	std::cout<<"Beschriftung: "<<beschriftung<<"\n";
}

//-----Button-------
int Button::idcounter = 0;
Button::Button(std::string titel):Window(titel),buttonID(++Button::idcounter) {}
Button::Button(int xpos, int ypos, int height, int width, std::string titel)
	:Window(xpos, ypos,height,width,titel),buttonID(++Button::idcounter) {}
Button::~Button() {
	--Button::idcounter;
	std::cout<<"Button dtor\n";
}
void Button::PrintProperties() const {
	Window::PrintProperties();
	std::cout<<"Button-ID: "<<buttonID<<"\n";
}
//____ENDE_DEFINITIONEN______

int main()
{
	WinBase * p[2];
	Button tmpObj("moep");
	std::string titel("Fenstertitel");
	std::string titel2("Buttontitel");
	p[0] = new Window(10,10,200,100,titel);
	p[1] = new Button(50,50,100,50,titel2);
	p[0]->PrintProperties();
	p[1]->PrintProperties();

	delete p[0];
	delete p[1];

	std::cin.get();
}

Ich hoffe das war jetzt nicht zuviel code. Die Eigenschaften von WinBase (xpos,ypos, height und width) sind ja als private deklariert. Daher können Instanzen von Window oder Button nicht direkt darauf zugreifen, aber die PrintPropterties der jeweiligen Basisklasse aufrufen, bis ich eben in WindowBase ankomme. Diese kann dann die Eigenschaften ausgeben.

Um also die Frage auf den Punkt zu bringen: Die Eigenschaften ansich existieren für Instanzen von Window und Button, nur haben sie keinen Zugriff darauf? Oder seh ich da noch was falsch?

P.S.: Huch, hatte zu Testzwecken eben noch die Eigenschaften in WinBase als protected deklariert - sollte natürlich private sein.

Da ich aber die Eigenschaften (in meinem Beispiel) als private deklariert habe, kann z.b. eine Button-Instanz nicht auf diese Werte zugreifen.
Was ich mich jetzt frage ist, ob die Eigenschaften für ein Button-Objekt trotzdem abgespeichert werden (also trotz private-Deklaration), nur eben nicht abrufbar.
Wenn ich wie im Beispiel aber immer die Abfrage an die Basisklasse delegiere (bis zu der Basisklasse, in der die Eigenscahften deklariert weren), dann kann ich sie dort ja trotzdem ausgeben.

Mir ist klar, dass ich das so normalerweise nicht umsetzen würde sondern mit get- und set-Memberfunktionen arbeiten würde. Allerdings müssten dafür trotzdem in der WinBase Klasse die Eigenschaften als protected deklariert werden, da sonst auch die getter und setter ja keinen Zugriff darauf hätten.

Meine Frage eigentlich: Werden als private deklarierte Eigenschaften trotzdem vererbt, nur eben so, dass sie nicht abgerufen werden können? Der Button speichert ja trotzdem seine Position und Grösse, welche ja durch PrintProperties (welche eben immer weiter hoch-deligiert wird) ja ausgegeben werden können?

Meine Frage eigentlich: Werden als private deklarierte Eigenschaften trotzdem vererbt, nur eben so, dass sie nicht abgerufen werden können? Der Button speichert ja trotzdem seine Position und Grösse, welche ja durch PrintProperties (welche eben immer weiter hoch-deligiert wird) ja ausgegeben werden können?

Klar. Diese Eigenschaft ist dann aber Teil der Basisklasse.

Du kannst ja immernoch die Funktionen der Basisklasse über die abgeleitete Klasse aufrufen und dafür braucht es ja die Informationen.

Eine Klasse, welche von einer anderen erbt erweitert diese üblicherweise (abgesehen von Adaptern o.ä., wie z.B std::stack , welche lediglich ein wohl bekanntes Interface anbietet). Und da sie erweitert sind die Daten essentiell.

Zugriffsrechte ändern nichts am eigentlich generierten Code, sondern sind lediglich eine Information für dem Compiler, damit er unerlaubte Sachen gleich bemängeln kann. Zur Laufzeit wird es keine Informationen mehr dazu geben (vom Compiler abhängig, wäre aber imo sinnlos), ob eine Member public oder private war.