Hi Leute,
Zuerst mal zum Grundsätzlichen:
gibt es einen Unterschied zwischen:
int i; und int& i;
MyClass mc; und MyClass& mc;
und wo ist der Unterschied zwischen:
MyClass mc; und MyClass mc();
Nun zum Objektorientierten:
Wenn ich folgende Klassen habe:
class MyOtherClass {
public:
MyOtherClass() { }
};
class MyClass {
private:
MyOtherClass m_moc;
public:
MyClass(MyOtherClass moc) : m_moc(moc) { }
MyOtherClass getIt() { return m_moc; }
};
und dann folgende main Methode:
int main() {
MyOtherClass moc;
MyClass* mc = MyClass(moc);
MyOtherClass* moc2 = &mc->getIt(); //Wegen dieser Zeile schmeißt das Programm
//zur Laufzeit einen Fehler, warum?(1)
delete moc2; //Oder auch wegen dieser. (1)
delete mc;
/**
* Nun zu einem anderen Versuch:
*/
MyOtherClass moc2;
MyOtherClass moc3;
MyClass mc2(moc2);
moc3 = mc2.getIt(); //Was passiert hier mit dem Objekt, welches
//bisher in moc3 gespeichert war? (2)
}
(1): Oder darf ich moc2 nicht deleten, weil der return von mc->getIt() eine Referenz ist und auf einem anderen Speicher liegt? Wenn dies stimmt, würde ja nach delete mc; der Pointer moc2 einfach irgendwohin zeigen oder? Also müsste ich ihn auch nicht mehr deleten. Oder aber, was für mich logischer wäre, ich muss/darf/kann moc3 nicht deleten weil das Objekt eben in einem anderen Speicher liegt und daher einfach nicht deleted werden kann, sondern mit Außlaufen der Funktion main() wird das Object einfach gelöscht. Wenn der Pointer außerhalb der main() deklariert worden wäre, würde er dann halt irgendwohin zeigen. (Abgesehen davon, dass nach Auslaufen der main() das Programm beendet wird, aber mal rein theoretisch.)
(2): Meiner Meinung nach bleibt es im Speicher bis die main() ausläuft, aber wenn nun mein Prog ein Server wäre und der länger laufen würde und so etwas öfters vorkommen würde, dann würde er doch den ganzen Speicher voll schreiben oder nicht?
Aber wie soll ich das dann sonst realisieren? Ich hätte einfach gerne eine Referenzvariable (in diesem Fall moc3), die das Ergebnis einer getter-Anweisung zugewiesen bekommt. Aber da ich ja eine Referenzvariable immer sofort initialisieren muss und MyOtherClass moc3 = mc2.getIt(); nicht möglich ist, kann ich das doch nicht anders machen oder doch?
Und dann habe ich noch eine Frage: Wenn ich jetzt ein Objekt von einer Methode bekomme, dass nicht im dem Speicher liegt, wo z.b.: ein Objekt liegen würde, welches mit new MyClass(); initialisiert worden ist, und ich einen Pointer habe, der außerhalb der Funktion liegt, in welche das Objekt zurückgegeben wurde, wie kann ich jetzt den Pointer so auf das Objekt zeigen lasse, dass es nach Auslaufen der Funktion immer noch existiert?
Hier ein Beispiel (Mit Hilfe der oben definierten Klassen):
MyOtherClass* p_moc;
void meineFunction() {
MyOtherClass moc;
MyClass mc(moc);
mc.getIt(); //Wie bekomme ich den Rückgabewert diese Methode in
//meinen Pointer p_moc rein, sodass der Pointer
//auch nach dem Auslaufen von meineFunction() noch
//auf ein existierendes Objekt zeigt?
*p_moc = mc.getIt(); //Dies würde ja einen Fehler erzeugen, da p_moc
//auf keinen reservierten Speicher zeigt.
p_moc = new MyOtherClass();
*p_moc = mc.getIt(); //Wird hier das vorherige Objekt überschrieben?
//Oder gibt es für die zeile mit dem new eine
//Alternative, mit der ich den Speicher zwar
//reserviere, jedoch kein Objekt initialisiere,
//damit ich dann ein Objekt "reinladen" kann?
}
Und eine letzte Frage hätte ich noch:
Wenn ich in C++ ein Objekt einer Klasse in einem Pointer seiner Basisklasse habe, gibt es eine Möglichkeit herrauszufinden von welchem Typ das Objekt wirklich ist?
In Java gibts da ja die Möglichkeit:
if(myObject instanceof MyClass) {
...
}
Gibt es so etwas auch in C++?
Ich hoffe jemand hat meine Fragen verstanden und kann mir bei diesen dämlichen Problemen helfen!
mfg
Stampede
