Klassendefinition

Hallo,
ich habe folgende Frage die ich nicht beantworten kann ich hoffe ihr könnt mir helfen?

class Hund{
private:
int gewicht;
int farbe;
};
class Kleinerhund:public Hund{
private:
int groesse;

Die Klasse Kleinerhund soll auf das Attribut gewicht der Klasse Hund zugreifen können. Welche Möglichkeiten kennen sie, diesen Zugriff zu ermöglichen?
Bewerten sie die Möglichkeiten.
Tipp: Sie sollten drei verschiedene Varianten nennen können.
Zwei hängen mit der Attriebutdeklaration zusammen, die dritte nicht.

Danke MFG stimon

DeathRow

class Hund{
private:
int gewicht;
int farbe;
};
class kleinerhund{
private:
hund getgewicht();

};

Hallo,
nein ich möchte die Varianten wissen mit der man das macht.

Danke

elise

//erstmal würde ich gewicht initialisieren
//der zugriff erfolgt dann über eine zugriffsfunktion
//nun ist aber die variable private,
//entweder, du setzt sie public, dann kannst du direkt zugreifen

class Hund{
public:	//schlechte variante mit public
	int gewicht;
private:	
	int farbe;

public:
	Hund(int g, int f) : gewicht (g), farbe(f){}
};

class Kleinerhund:public Hund{
private:
	int groesse; 
public:
	Kleinerhund (int g, int f, int gr) :Hund(g,f), groesse(gr) {}
};

//----------------------------

//oder zweite runde: du setzt sie protected, dann kannst du in der abgeleitetn 
//klasse nen zugriff schreiben

class Hund{
protected:
	int gewicht;	
private:	
	int farbe;

public:
	Hund(int g, int f) : gewicht (g), farbe(f){}

};

class Kleinerhund:public Hund{
private:
	int groesse; 
public:
	Kleinerhund (int g, int f, int gr) :Hund(g,f), groesse(gr) {}
	int getGewicht() const{
		return gewicht;
	}
};

int main(){
	Kleinerhund harry (3,4,5);
	cout<<harry.getGewicht();
}

//----------------------------
//oder am allerbesten löst du es ganz anders:
//mit dem zeiger der basisklasse auf ein abgeleitetes objekt

class Hund{
private:
	int gewicht;		
	int farbe;

public:
	Hund(int g, int f) : gewicht (g), farbe(f){}
	virtual ~Hund(){}
	int getGewicht() const{
		return gewicht;
	}
};

class Kleinerhund:public Hund{
private:
	int groesse; 
public:
	Kleinerhund (int g, int f, int gr) :Hund(g,f), groesse(gr) {}
};

int main(){
	Hund *harry=new Kleinerhund(3,4,5);
	cout<<harry->getGewicht();
}

bewertung machst du *g*

net 0

elise schrieb:

int main(){
	Hund *harry=new Kleinerhund(3,4,5);
	cout<<harry->getGewicht();
}

bewertung machst du *g*

delete vergessen bzw. 'new' unnötig und vor 'cout' std:: vergessen.
drei-minus würde ich sagen
*ggg*

elise

beruhige dich.

er muss ja auch noch was machen.. gesehen, dass ich ihm nur den ansatz gebe?

schließlich ist es seine hausaufgabe.

mehr gibts zu dir nicht zu sagen, net.

SideWinder

Ist auf jeden Fall nicht konsolenspezifisch -> Ich verschieb den Thread ins Standard-C++-Forum.

MfG SideWinder

C++ Forumbot

Dieser Thread wurde von Moderator/in SideWinder aus dem Forum DOS und Win32-Konsole in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Wir ein Objekt über einen Basisklassenzeiger verwaltet, so werden zwar die passenden virtuellen Methoden der abgeleiteten Klasse aufgerufen. Von
einer nicht virtuellen Methode wird stets die Version der Basisklasse ausgeführt?
Den virtuellen Destruktor

virtual ~Hund(){}

definiert man in der Basisklasse um ihn in der abgeleiteten Klasse Kleinhund zu überschreiben?

cu

Helium

Destruktoren werden auch automatisch generiert, um alle Member zu zerstören. Damit der Richtige gewählt wird (der des tatsächlichen Objekts, also der Laufzeittyp), macht man den Destruktor virtuell.
Immer wenn du erbst sollte der Destruktor virtuell sein.