#include <iostream>

#include <cstdio>


using namespace std;


class fahrzeug

{

//private:

	//char name;

	//char marke;

	//double preis;

	//int kmh;

public:

	char name;

	char marke;

	double preis;

	int kmh;

	void virtual ausgabe_typ()= 0;

	void virtual ausgabe_daten()= 0;

};




class motorad:public fahrzeug

{

private:

	int ps;

	bool motor;

	int db;

public:

	void ausgabe_typ()

	{

		cout << marke;

	};

	void ausgabe_daten()

	{

		cout << ps;

		cout << motor;

		cout << db;

		cout << kmh;

	};

};


class AUTO:public fahrzeug

{

private:

	int ps;

	bool cat;

	char farbe;

public:

	void ausgabe_typ()

	{

		cout << marke;

	};

	void ausgabe_daten()

	{

		cout << ps;

		cout << cat;

		cout << farbe;

		cout << kmh;

	};

 };


main()

{

	fflush(stdin);

	//getcar();

}

das ist ein testprogramm und es geht einfach nicht das ich auf den privaten bereich meiner basisklasse zugreifen kann deswegen habe ich das alles in den publikbereich nochmal geschrieben und jetzt geht es, aber jetzt habe ich ja für jeden tür und tor geöffnet. das ist doch aber nicht sinn und zweck der sache, oder???

gibt es da keine andere lösung???

PS.: für die frechen kann ich nix, ich denk das sind die doppelpunkte, sorry

das ist ein testprogramm und es geht einfach nicht das ich auf den privaten bereich meiner basisklasse zugreifen kann

Genau dafür ist private ja auch gedacht. Wenn der Zugriff aus einer abgeleiteten Klasse erlaubt sein soll, kannst du protected benutzen.

PS.: für die frechen kann ich nix, ich denk das sind die doppelpunkte, sorry

Nicht entschuldigen, sondern Code-Tags benutzen. Das hat den Nebeneffekt, dass die Einrückung nicht verlorengeht. Ich hab das mal für dich korrigiert. Und auch dein Threadtitel ist richtig schlecht, sozusagen in den Top Ten der schlechten Threadtitel. Auch das habe ich korrigiert. Bitte beim nächsten Mal selbst und gleich richtig machen.

danke jetzt hab ich's

und mit dem wie thread das muss ich mal noch üben bin erst das 2. oder 3. mal in einem forum

aber dank dir trotzdem

mfg

Wenn du private Member ändern willst, dann schreib doch nen Konstruktor für die Basisklasse mit den jeweiligen zu änderten Eigenschaften.

Ruf den dann in der abgeleiteten Klasse auf.

Auch wenn es bei Vererbung der Logik widerspricht:

du könntest die Klasse als Friend definieren, dann kannste die Member auch ändern...

Hallo,

für das was du tun möchtest gibt es in C++ zusätzlich zu private und public noch die Zugriffsvariante protected. Auf diese Attribute und Methoden hat dann die Basisklasse und alle von ihr abgeleiteten Klassen Zugriff. Alle anderen müssen draußen bleiben.

Gruß

Nils

mit dem protected das hab ich mal probiert und siehe da es geht, am anfang ist halt alles zu viel auf einmal, man weiß zwar so a bissel was es gibt bzw. weiß wo es steht aber ich weiß noch nicht wann ich was einsetzen muss bzw. kann.

danke euch trotzdem für eure zeit / mühe

mfg

Wenn du private Member ändern willst, dann schreib doch nen Konstruktor für die Basisklasse mit den jeweiligen zu änderten Eigenschaften.

Ruf den dann in der abgeleiteten Klasse auf.

Auch wenn es bei Vererbung der Logik widerspricht:

du könntest die Klasse als Friend definieren, dann kannste die Member auch ändern...

Hallo,

wenn man keinen "Schreibzugriff" auf die Basisklasse hat, kann man auch mittels eines Speicherabbildes auf die privaten Member zugreifen. Der Nachteil ist aber die sehr enge Bindung zwischen Base und BaseImage, denn wenn sich bei Base etwas verändert, muss sich das Image anpassen, sonst funktioniert der reinterpret_cast nicht.

#include <iostream>

#include <string>


class base {

	public:

		base() : name("Hallo") {

		}


		virtual ~base() {

		}


	private:

		std::string name;

};


struct base_image {

	virtual ~base_image() {

	}


	std::string name;

};


class derived : public base  {

	public:

		derived() {

		}


		virtual ~derived() {

		}


		void print(std::ostream & out) const {

			base const * parent = static_cast<base const *>(this);

			base_image const * image = reinterpret_cast<base_image const *>(parent);

			out << image->name << std::endl;

		}

};


int main() {

	derived obj;

	obj.print(std::cout);


	return 0;

}

base_image const * image = reinterpret_cast<base_image const *>(parent);

Da fehlt IMHO ein Kommentar:

// BLUTIGER HACK

Nach dem Standard ist das undefiniertes Verhalten.

Nicht nur IYHO