uwebaier - 36
Halbprofi
(offline)
Dabei seit 06.2005
124
Beiträge
|
|
Geschrieben am: 11.11.2007 um 22:46 Uhr
|
|
Also:
folgende Fehler:
Zitat: [C++ Fehler] Unit1.cpp(34): E2248 Standardkonstruktor zum Initialisieren des Arrayelements vom Typ 'Gasthof' nicht gefunden
[C++ Fehler] Unit1.cpp(141): E2285 Keine Übereinstimmung für 'Pension::operator =(Gasthof *)' gefunden
Hier gibts die Klassen:
OberKlasse:
Zitat: class Unterkunft
{
//Eigenschaften
private:
string dieKategorie;
string derName;
anschrift dieAdresse;
int dieAnzahlzimmer;
zimmer *dieZimmer;
int dieAnzahlsuchtreffer;
//Methoden
protected:
Unterkunft
(string, //Kategorie
string, //Name
anschrift, //Adresse
int, //Anzahlzimmer
zimmer *); //Zimmer
bool pruefe
(time_t, //Anreise
time_t, //Abreise
int); //Zimmernummer
string gibName() {return derName;};
string gibAdresse();
float gibPreis
(int, //Zimmernummer
int); //Nächte
int gibAnzBetten
(int); //Zimmernummer
public:
~Unterkunft();
string *suche
(time_t, //Anreise
time_t, //Abreise
int); //Betten
void loescheTreffer();
virtual string formatiere
(int, //Zimmernummer
int)=0; //Nächte
int gibAnzsuchtreffer() {return dieAnzahlsuchtreffer;};
};
Unterklasse:
Zitat: class Gasthof : public Unterkunft
{
//Eigenschaften
private:
bool einBuffet;
//Methoden
string gibBuffet();
public:
Gasthof
(string, //Name
anschrift, //Adresse
int, //Anzahlzimmer
zimmer *, //Zimmer
bool); //Buffet
~Gasthof() {};
string formatiere
(int, //Zimmernummer
int); //Naechte
};
Und weil ihr ja eh das auch sehen wollt:
Konstruktor Oberklasse:
Zitat: Unterkunft::Unterkunft
(string Kategorie,
string Name,
anschrift Adresse,
int Anzahlzimmer,
zimmer *Zimmer)
{
dieKategorie=Kategorie;
derName=Name;
dieAdresse=Adresse;
dieAnzahlzimmer=Anzahlzimmer;
zimmer *dieZimmer=new zimmer[Anzahlzimmer];
for (int i=0; i<Anzahlzimmer; i++)
{
*(dieZimmer+i)=*(Zimmer+i);
}
dieAnzahlsuchtreffer=0;
}
Konstruktor Unterklasse:
Zitat: Gasthof::Gasthof
(string Name,
anschrift Adresse,
int Anzahlzimmer,
zimmer *Zimmer,
bool Buffet)
:Unterkunft
("Gasthof",
Name,
Adresse,
Anzahlzimmer,
Zimmer)
{
einBuffet=Buffet;
}
Und hier noch wie der Spaß aufgerufen wird:
Zitat: Anzahlgasthoefe=2;
gasthof=new Gasthof[Anzahlgasthoefe];
//daten einlesen und so
for (int i=0; i<Anzahlgasthoefe; i++)
{
*(pension+i)=new Gasthof
(Name[i],
Adresse[i],
Anzahlzimmer[i],
Zimmer[i],
Buffet[i]);
}
Ich bin schon mal jedem Dank schuldig der das überhaupt liest, geschweige denn wer mir antwortet...
thx für jede Antwort
UT3 Sucks ^^
|
|
silver-cloud - 39
Halbprofi
(offline)
Dabei seit 07.2005
312
Beiträge
|
Geschrieben am: 11.11.2007 um 23:01 Uhr
Zuletzt editiert am: 11.11.2007 um 23:11 Uhr
|
|
Zitat:
gasthof=new Gasthof[Anzahlgasthoefe];
1 Fehler : new Gasthof versucht den Standartkonstruktor zu verwenden, den du _nicht_ hast. Du hast nur einen spezialisierten Konstruktor.
2 Fehler : bezieht sich auf die Klasse "Pension", der fehlt der = operator für ein konstrukt $pension = $(Gasthof*) (also das erzeugen einer Pension basierend auf einem Pointer auf Gasthof)
ansonsten wäre bei grobem überfliegen noch anzumerken: Destruktoren sollten bei vererbung als virtual deklariert werden. ^^
Du sollst nur soviel Zeit in eine Antwort verschwenden, wie der Anfragende in seinem Startpost.
|
|
uwebaier - 36
Halbprofi
(offline)
Dabei seit 06.2005
124
Beiträge
|
Geschrieben am: 12.11.2007 um 06:57 Uhr
Zuletzt editiert am: 12.11.2007 um 07:02 Uhr
|
|
Rückfrage 1:
Wie mache ich einen Standardkonstruktor???
(Bin noch nich so Bewandert in OOP ^^)
Rückfrage 2:
Wie muss ich die Objekte initialisieren??? ^^
Und zum 2ten Fehler, da hab ich wohl was falsches gepostet -.-
Hier gibts nochma wie der Spaß aufgerufen wird:
Zitat:
Anzahlgasthoefe=2;
gasthof=new Gasthof[Anzahlgasthoefe];
for (int i=0; i<Anzahlgasthoefe; i++)
{
*(gasthof+i)=new Gasthof
(Name[i],
Adresse[i],
Anzahlzimmer[i],
Zimmer[i],
Buffet[i]);
Sry wenns ich nich direkt den Durchblick hab, wär aber nett wenn mir jemand weiterhilft =)
UT3 Sucks ^^
|
|
wiedoo - 36
Fortgeschrittener
(offline)
Dabei seit 10.2005
90
Beiträge
|
|
Geschrieben am: 12.11.2007 um 08:54 Uhr
|
|
Zitat von uwebaier: Rückfrage 1:
Wie mache ich einen Standardkonstruktor???
(Bin noch nich so Bewandert in OOP ^^)
Rückfrage 2:
Wie muss ich die Objekte initialisieren??? ^^
Und zum 2ten Fehler, da hab ich wohl was falsches gepostet -.-
Hier gibts nochma wie der Spaß aufgerufen wird:
Zitat:
Anzahlgasthoefe=2;
gasthof=new Gasthof[Anzahlgasthoefe];
for (int i=0; i<Anzahlgasthoefe; i++)
{
*(gasthof+i)=new Gasthof
(Name[i],
Adresse[i],
Anzahlzimmer[i],
Zimmer[i],
Buffet[i]);
Sry wenns ich nich direkt den Durchblick hab, wär aber nett wenn mir jemand weiterhilft =)
Standardkonstruktor kannst doch einfach so machen:
Gasthof::Gasthof()
{
//hier deine standardwerte initialisieren
}
Bitte verbessern falls ich mich irre, wir haben auch erst vor kurzem mit OOP angefangen
while(!asleep()) sheep++;
|
|
wiedoo - 36
Fortgeschrittener
(offline)
Dabei seit 10.2005
90
Beiträge
|
|
Geschrieben am: 12.11.2007 um 09:00 Uhr
|
|
Wenn willst kann ich dir auch ein kleines Beispiel geben so wie ich es in der Schule gelernt hab
while(!asleep()) sheep++;
|
|
uwebaier - 36
Halbprofi
(offline)
Dabei seit 06.2005
124
Beiträge
|
|
Geschrieben am: 12.11.2007 um 16:41 Uhr
|
|
Ja komm, nur ma her son Beispiel
UT3 Sucks ^^
|
|
silver-cloud - 39
Halbprofi
(offline)
Dabei seit 07.2005
312
Beiträge
|
|
Geschrieben am: 12.11.2007 um 16:42 Uhr
|
|
ein Standardkonstruktor ist (wie richtig als Beispiel gezeigt) ein Konstruktor ohne Parameter. Wenn man gar keinen Konstruktor hat wird er selbständig erstellt.
ansonsten sieht er wirklich so aus klassenname::klassenname(){ /* xyz */ }
Du sollst nur soviel Zeit in eine Antwort verschwenden, wie der Anfragende in seinem Startpost.
|
|
uwebaier - 36
Halbprofi
(offline)
Dabei seit 06.2005
124
Beiträge
|
Geschrieben am: 12.11.2007 um 17:27 Uhr
Zuletzt editiert am: 12.11.2007 um 17:50 Uhr
|
|
Noch ne Frage zu deisem Standardkonstruktor:
Da muss ich den Eigenschaften standardwerte geben oder kann ich den zum Beispiel auch einfach so machen?
Konstruktor::Konstruktor() {}
Und wenn nicht, wie soll ich einen Pointer als Startwert setzen?
Und dann noch zu dem Problem 2, die Lösung hab ich nich ganz gepeilt =)
hier noch ma eroor und zugehöriger Text:
[C++ Fehler] Unit1.cpp(76): E2285 Keine Übereinstimmung für 'Gasthof::operator =(Pension *)' gefunden
for (int i=0; i<Anzahlgasthoefe; i++)
{
*(gasthof+i)=new Gasthof
(Name[i],
Adresse[i],
Anzahlzimmer[i],
Zimmer[i],
Buffet[i]);
}
Sorry für meine Schwerfälligkeit, aber Danke an jeden der mir Weiterhilft
UT3 Sucks ^^
|
|
wiedoo - 36
Fortgeschrittener
(offline)
Dabei seit 10.2005
90
Beiträge
|
|
Geschrieben am: 12.11.2007 um 18:56 Uhr
|
|
Also falls des Beispiel noch brauchst, habs grad hochgeladen. War mein erstes Praktikum in sachen OOP, von da her beinhaltets einfach nur nen simplen Standard- und Zuweisungskonstruktor und wie man die Objekte initialisiert, vll hilft es dir.
Hier klicken
while(!asleep()) sheep++;
|
|
uwebaier - 36
Halbprofi
(offline)
Dabei seit 06.2005
124
Beiträge
|
|
Geschrieben am: 12.11.2007 um 19:25 Uhr
|
|
Zitat von wiedoo: Also falls des Beispiel noch brauchst, habs grad hochgeladen. War mein erstes Praktikum in sachen OOP, von da her beinhaltets einfach nur nen simplen Standard- und Zuweisungskonstruktor und wie man die Objekte initialisiert, vll hilft es dir.
Hier klicken
Dein Beispiel ist klar, aber wie setze ich nem Pointer nen default-wert?
UT3 Sucks ^^
|
|
gaucho - 41
Halbprofi
(offline)
Dabei seit 10.2004
120
Beiträge
|
|
Geschrieben am: 13.11.2007 um 17:24 Uhr
|
|
Zitat von uwebaier: [C++ Fehler] Unit1.cpp(76): E2285 Keine Übereinstimmung für 'Gasthof::operator =(Pension *)' gefunden
Anzahlgasthoefe=2;
gasthof=new Gasthof[Anzahlgasthoefe];
for (int i=0; i<Anzahlgasthoefe; i++)
{
*(gasthof+i)=new Gasthof
(Name[i],
Adresse[i],
Anzahlzimmer[i],
Zimmer[i],
Buffet[i]);
}
gasthof ist ein Array. Das heißt es hat Elemente vom Typ Gasthof, In der Schleife versuchst Du nun aber einem Typ Gasthof (in diesem Fall "*(gasthof+i)") einen Zeiger auf einen Gasthof ("new Gasthof[Anzahlgasthoefe]") zuzuweisen, was nicht funktioniert.
Davon abgesehen meine ich, dass beim Erzeugen des neuen Arrays ebenfalls die Elemente initialisiert werden (über Standardkonstruktor). Somit hast Du also eine Anzahl von Objekten. Beim Versuch ein vorhandenes Objekt mit "=" zu überschreiben (Bsp: Objekt1=Objekt2) weiß C++ hier nicht, was es mit dem "=" anfangen soll, da dieser Operator für Deine Klasse offenbar nicht überladen ist. Wenn Du also willst, dass Du mit "=" Objekt2 auf Objekt1 abbildest, musst Du für Deine Klasse den Operator "=" überladen.
Zitat von uwebaier:
Dein Beispiel ist klar, aber wie setze ich nem Pointer nen default-wert?
Grundsätzlich solltest Du Dir angewöhnen Pointer bei der Deklaration auch gleich mit NULL zu initialisieren, um zu zeigen, dass der Pointer auf kein gültiges Objekt zeigt und damit initialisiert werden kann.
Beispiel für Deine Gasthöfe.
Gasthof* p_Gasthof = NULL; // Zeiger deklarieren
oder um gleich ein Objekt zuzuweisen:
Gasthof* p_Gasthof = new Gasthof();
|
|
uwebaier - 36
Halbprofi
(offline)
Dabei seit 06.2005
124
Beiträge
|
Geschrieben am: 13.11.2007 um 18:27 Uhr
Zuletzt editiert am: 13.11.2007 um 18:38 Uhr
|
|
ich hätte ja ne Idee:
Ich erstelle das Array von Gasthof mit dem Standardkonstruktor und rufe direkt danach in einer Schleife den spezialisierten Konstruktor auf...
Irgendwie ging das bei mir aber nich =(
Das ganze würde dann so aussehen:
Zitat:
Gasthof *Gasthoefe=new Gasthof[Anzahl]; //Initialisieren
for (int i=0; i<Anzahl; i++)
{
(Gasthoefe+i)->Gasthof(Werte[Anzahl]);
}
Nun geht der Spaß aber nicht, weil angeblich der spezialisierte Konstruktor kein Element von der Klasse sei...
UT3 Sucks ^^
|
|
Polaris
Experte
(offline)
Dabei seit 07.2006
1766
Beiträge
|
Geschrieben am: 13.11.2007 um 20:31 Uhr
Zuletzt editiert am: 13.11.2007 um 20:32 Uhr
|
|
Zitat von uwebaier:
Zitat:
Gasthof *Gasthoefe=new Gasthof[Anzahl]; //Initialisieren
for (int i=0; i<Anzahl; i++)
{
(Gasthoefe+i)->Gasthof(Werte[Anzahl]);
}
wie wäre es mit
Gasthof *Gasthoefe=new Gasthof[Anzahl];
for(std::size_t = 0; i < Anzahl; ++i) {
Gasthoefe[i] = Gasthof(**Werte für den KOnstruktor**);
}
ach ja am Ende:
delete [] Gasthoefe;
nicht vergessen 
PS: die Containerklassen der STL sind viel komfortabler als rohe Arrays
Patriotismus ist die Tugend der Bosheit! (Oscar Wilde)
|
|
gaucho - 41
Halbprofi
(offline)
Dabei seit 10.2004
120
Beiträge
|
Geschrieben am: 13.11.2007 um 21:22 Uhr
Zuletzt editiert am: 13.11.2007 um 22:08 Uhr
|
|
Zitat von Polaris:
wie wäre es mit
Gasthof *Gasthoefe=new Gasthof[Anzahl];
for(std::size_t = 0; i < Anzahl; ++i) {
Gasthoefe[i] = Gasthof(**Werte für den KOnstruktor**);
}
ach ja am Ende:
delete [] Gasthoefe;
nicht vergessen 
PS: die Containerklassen der STL sind viel komfortabler als rohe Arrays 
Gasthoefe[i] ist doch bereits ein Objekt vom Typ Gasthof. Was soll die Zuweisung da bringen ?
Ich würde es evtl. so lösen:
Gasthof **Gasthoefe=new Gasthof*[Anzahl];
for(int i = 0; i < Anzahl; ++i)
{
Gasthoefe[i] = new Gasthof();
}
Danach können die Attribute und Methoden über "->" aufgerufen werden:
Gasthoefe[0]->Attribut = 0;
Gasthoefe[0]->Methode();
Da hierbei dynamisch Speicher angefordert wird, müssen die einzelnen Zeiger im Array wieder freigegeben werden (delete) und der Array selbst dann natürlich auch (delete[])
Edit:
Wie ich festelle, funktioniert Deine Methode ebenfalls. Der Aufruf des Konstruktors für ein bestehendes Objekt ist mir allerdings trotzdem nicht ganz geheuer 
Zitat von uwebaier:
Gasthof *Gasthoefe=new Gasthof[Anzahl]; //Initialisieren
for (int i=0; i<Anzahl; i++)
{
(Gasthoefe+i)->Gasthof(Werte[Anzahl]);
}
Edit:
Oben angegebene Methode sollte funktionieren, wenn Du die Zuweisung wie folgt machst:
*(Gasthoefe+i) = Gasthof(Werte[Anzahl]);
bzw.
Gasthoefe[i] = Gasthof(Werte[Anzahl]);
Letzteres dürfte wohl deutlich lesbarer sein.
|
|
Polaris
Experte
(offline)
Dabei seit 07.2006
1766
Beiträge
|
Geschrieben am: 14.11.2007 um 17:01 Uhr
Zuletzt editiert am: 14.11.2007 um 17:02 Uhr
|
|
Zitat von gaucho:
Edit:
Wie ich festelle, funktioniert Deine Methode ebenfalls. Der Aufruf des Konstruktors für ein bestehendes Objekt ist mir allerdings trotzdem nicht ganz geheuer
Wird er gar nicht -.-.
Zitat: Gasthoefe[i] = Gasthof(**Werte für den Konstruktor**);
Das hier erstellt einfach (rechtsseitig) ein temporäres Stackobjekt, welches "Gasthoefe[i]" zu gewiesen wird. Falls er Felder etc. drin hat, muss er natürlich den Zuweisungsoperator überladen (Destruktor und Cpykonstruktoren sollten natürlich auch explizit definiert werden).
Das mit dem Konstruktoraufruf auf ein bestehendes Objekt hätte natürlich auch was (wenn auch recht abenteuerliches) -.- dafür müsste man den Destruktor allerdings zunächst explizit aufrufen, um an der Stelle das Objekt - mit korrekten Werten initialisiert - "neu zu erschaffen".
Sonst wäre glaube ich die einfachste Möglichkeit eine simple Initmethode.
Patriotismus ist die Tugend der Bosheit! (Oscar Wilde)
|
|