C++ Zugriff auf Objekte anderer Klassen in einer Memberfunktion

[Oche]

Tach Leute,

bin grad an einem Problem, das ich durch Recherche einfach nicht gelöst bekomme.

Der Titel oben besagt worum es sich bei meinem Problem handelt.

Ich poste mal den Code:

class Wand{
public:
double berechneFlaeche(Tuer, Fenster)
};

double Wand::berechneFlaeche(Tuer t, Fenster f){
//hier kommt noch Code rein...
}

int main(void){
Wand w;
Tuer t;
Fenster f;


return 0;
}

 

[Larius]

Also zumindest für mich ist jetzt nicht wirklich ersichtlich WAS genau du vor hast, nichtmal mit dem Thread Titel. Kannst du es etwas spezifizieren?

 

[Oche]

Ich habe 3 Klassen,
erstelle in der main() zwei Instanzen Tuer t und Fenster f der beiden Klassen Tuer und Fenster
und möchte in der Klasse Wand damit arbeiten.
Ist dies möglich?

 

[deSk]

Klar ist dies möglich und auch nicht wirklich schwer

in die Main erstellt du noch eine double Variable also
[src=cpp]
double wert = w.berechneFlaeche(t,f);
[/src]
jedoch verstehe ich nicht wieso du eine Klasse mit nur einer Instanzmethode erstellst , die Klasse ergibt für mich keinen Sinn. Eine kleine Funktion würde dafür auch ausreichen.
Nagut vlt. tust du sie ja noch erweitern =)

 

[BurnerR]

Der Kontext scheint mir etwas unklar. Du hast den Code vorgegeben und musst ergänzen, oder? Der ist doch nicht von dir, so wie das aussieht.
Oder wo ist das Problem mit deiner Methode
[src=cpp]
double berechneFlaeche(Tuer, Fenster);
[/src]
?


Ich persönlich finde es nicht so toll, jemandem, der nen recht lieblosen Beitrag (src tags??) hinklatscht seine vermeintlichen Hausaufgaben zu machen.

Aber mal davon abgesehen:
Meines erachtens würde man das eher mit Aggregation lösen:
[src=cpp]
class Wand{
public:
[...]
double berechneFlaeche();
bool addWindow(Koordinaten k);
bool addDoor(Koordinaten k);
[...] // u.a. getter/setter
private:
std::vector<Tuer> tuerListe;
std::vector<Fenster> fensterListe;
};
[/src]

 

[Oche]

Danke für eure Hilfe,

hab das Problem gelöst bekommen, war aber keine Hausaufgabe sondern Klausurvorbereitung.

Schönes Wochenende!

 

[BurnerR]

Es ist mMn höflich, die Lösung dann auch zu nennen. Sonst surft z.B. nächstes Jahr wegen der selben Frage hier her und findet keine Antwort.

 

[Oche]

[src=cpp]#include <iostream>

using namespace std;

class Rechteck{
public:
double hoehe;
double breite;
};

class Tuer : public Rechteck{

};

class Fenster : public Rechteck{

};

class Wand : public Rechteck{
public:
double berechne_Flaeche(Tuer, Fenster);
};

double Wand::berechne_Flaeche(Tuer t, Fenster f){
//Wandfläche = HöheWand * BreiteWand - HöheTür * BreiteTür - HöheFenster * BreiteFenster
return (hoehe*breite - t.hoehe*t.breite - f.hoehe*f.breite);
}

int main(void){
Wand w;
Tuer t;
Fenster f;

cout << "Eingaben fuer Wand, Tuer, Fenster:" << endl;
cout << "Hoehe = ? ";
cin >> w.hoehe;
cout << "Breite = ? ";
cin >> w.breite;
cout << "Hoehe = ? ";
cin >> t.hoehe;
cout << "Breite = ? ";
cin >> t.breite;
cout << "Hoehe = ? ";
cin >> f.hoehe;
cout << "Breite = ? ";
cin >> f.breite;

cout << "Wandflaeche = " << w.berechne_Flaeche(t, f) << endl;

return 0;
}
[/src]
die letzte Zeile vor return 0; war zu ergänzen um in der Klasse Wand Zugriff auf die Instanzen t und f zu erhalten.
Hatte anscheinend Probleme mit der Syntax.

 

[theSplit]

Lerne auch gerade C/C++ - aber musst du nicht erst einmal die Klassen mittels "new", also "Wand w = new Wand" als Instanzen diser Klassen setzen ?

 

[Oche]

@theSplit:
Wieso?
ich will die Instanz doch nicht dynamisch erzeugen, brauch doch nur eins.
Erzeugt man das nicht in dem Fall mit new, wenn man nicht weiß wie viele man braucht, also zur Laufzeit?

 

[theSplit]

Wenn ich richtig verstehe, erzeugt das "new" als Keyword/Schlüsselwort eine Instanz einer Klasse die vorher deklariert wurde.
Also dass dann erst mit der Klasse gearbeitet werden kann.

 

[Oche]

Ich hab jedenfalls noch nie davon gehört, bzw es noch nie benutzen müssen.
Aber vielleicht brauch ich es ja irgendwann mal

 

[Asseon]

iirc erzeugt new die klasse im HEAP ohne landet sie im stack, dessen Größe zur linktime festgelegt wird und ich meine meist bei 1 MiB liegt.
der HEAP dagegen ist unter normalen Umständen nur durch den vorhandenen RAM begrenzt.

 

[Kugelfisch]

Korrekt.

Das [kw]new[/kw]-Schlüsselwort alloziert Speicher im Heap für eine Objektinstanz, legt dort eine mit dem angegebenen Konstruktor erzeugte Instanz der Klasse ab, und liefert einen Pointer darauf zurück (daher wäre die korrekte Syntax auch [kw]Foo *f = new Foo(23,42)[/kw], d.h. [kw]f[/kw] ist ein Zeiger auf den Typ [kw]Foo[/kw]). Wichtig ist dabei anzumerken, dass der Speicher auch dann reserviert bleibt, wenn der Pointer nicht mehr existiert (C++ bietet keine Garbage Collection und keine Referenzzähler für Objekte), d.h. wenn das Objekt nicht später explizit mittels des [kw]delete[/kw]-Operators freigegeben wird, wird der Speicher erst freigegeben, wenn das Programm beendet wird (Memory Leak).
Eine Initialisierung eines Objektwerts wie z.B. [kw]Foo f(23,42)[/kw] (oder auch [kw]Foo f[/kw], was zu [kw]Foo f()[/kw] äquivalent ist, d.h. den Konstruktor ohne Parameter aufruft) erzeugt eine Objektinstanz auf dem Stack. Diese wird spätestens automatisch gelöscht, wenn der entsprechende Stack Frame zerstört wird, z.B. am wenn der Funktion zurückgesprungen wird. Übrigens können auch aus anderen Gründen temporär Objektinstanzen auf dem Stack erzeugt werden, etwa wenn eine Methode oder ein überladener Operator eines Objekts ein Objekt als Wert zurückliefert.

Die maximale Stackgrösse ist u.a. abhängig vom Betriebssystem und von der Konfiguration. Unter GNU/Linux wird sie durch das `stack size`-ulimit bestimmt - in aktuellen Distributionen sind Standardwerte zwischen 8 und 10 MiB gebräuchlich. Unter Windows wird sie tatsächlich vom Linker in den PE-Header geschrieben.

 

[BurnerR]

Wichtig ist dabei anzumerken, dass der Speicher auch dann reserviert bleibt, wenn der Pointer nicht mehr existiert (C++ bietet keine Garbage Collection und keine Referenzzähler für Objekte), d.h. wenn das Objekt nicht später explizit mittels des delete-Operators freigegeben wird, wird der Speicher erst freigegeben, wenn das Programm beendet wird (Memory Leak).

Dazu sei ergänzend angemerkt, dass die STL zu diesem Zweck smart pointer bereit stellt, durch welche diese Problematik vermieden wird. Die Deklaration sähe dann z.B. so aus:
[src=cpp]
std::unique_ptr<Wand> w(new Wand);
[/src]
Das sieht auf den ersten Blick vielleicht unnötig kompliziert aus, hat aber den Vorteil, dass der belegte Speicher automatisch freigegeben wird sobald der Zeiger nicht mehr existiert.

 

[accC]

Plx plx, mehr Threads: klick