Konstruktor?

ak133

Hallo
unten habe ich ein kleines Quellcode der sich auf zeigerdefiniertes Objekt Erzeugung bezieht.
Nun hab ich irgendwo mal gelesen, dass da was auch mit Konstruktor sein soll. Dann hab ich mir bisschen über Konstruktoren durch gelesen aber nun versteh ich da den zusammen hang nicht :S
Kann mir das jemand erklären anhand dieses Quellcodes(siehe unten)

void ErstellMitarbInfo()
{	
	MitarbInfo *mitarbPtr;  
        mitarbPtr = new MitarbInfo;

        mitarbPtr->m_gehalt = 2000.0;

        delete mitarbPtr; 
}

Freu mich über jede Hilfe danke

SeppJ

new MitarbInfo;

ruft (unter anderem) den Konstruktor von MitarbInfo auf. Mehr kann man dazu nicht sagen. Was ist eigentlich deine Frage?

ak133

Also meine Frage war, wenn es ein Konstruktor in dem Programm gibt, dann wo in dem Quellcode und was macht er genau ?
Und in welchem Zusammenhang stehen die zu einander zeigerdefiniertes Objekt Erzeugung und Konstruktoren?

mfg ak133

SeppJ

ak133 schrieb:

Also meine Frage war, wenn es ein Konstruktor in dem Programm gibt, dann wo in dem Quellcode und was macht er genau ?

Der Konstruktor wird immer dann aufgerufen, wenn ein neues Objekt erstellt wird, auf welche Weise auch immer. Das kann mit new geschehen oder auch wenn lokale Objekte erstellt werden. Das geschieht ganz automatisch, man braucht sich selbst nicht darum zu kümmern. Was der Konstruktor macht, hängt von dir ab. Wenn du keinen Konstruktor erstellst, wird automatisch einer erzeugt. Dieser ruft einfach die Konstruktoren aller Basisklassen und aller Member auf. In vielen Fällen ist das auch schon alles was man will. Will man mehr, muss man selber einen Konstruktor schreiben. Die Basisklassen und Member werden dabei aber trotzdem automatisch erzeugt, man braucht sich nicht selber darum zu kümmern (man kann jedoch gegebenenfalls beeinflussen, mit welchen Parametern sie erzeugt werden).

Und in welchem Zusammenhang stehen die zu einander zeigerdefiniertes Objekt Erzeugung und Konstruktoren?

Ich verstehe diesen Satz nicht.

Wenn du ein Objekt dynamisch erstellst wie in deinem Beispiel mit new, dann wird wie gesagt der Konstruktor durch das new aufgerufen.

Wenn du eine Klasse hast die selber einen (oder mehrere) Zeiger hält, dann ist dies einer der am häufigsten vorkommenden Gründe, warum man sich einen Konstruktor selber schreibt. Denn wenn ein Zeiger konstruiert wird, zeigt er noch auf nichts (zumindest auf nichts gültiges), man will aber gewöhnlich, dass er auf etwas zeigt. Daher schreibt man dann einen Konstruktor der Speicher anfordert und den Zeiger darauf zeigen lässt. (In diesem Fall sollte man auch mindestens noch einen Destruktor schreiben um den Speicher wieder freizugeben und in der Regel auch einen Kopierkonstruktor und einen Zuweisungsoperator).

ak133

Super danke schön das war jetzt alles schön und deutlich erklärt!

mfg ak133

ak133

oh entschuldigung noch eine Frage,
du meintest man braucht noch ein Destruktor um den Speicher wieder frei zu geben.
War das jetzt auf mein Programm bezogen? Weil in meinem Programm, wird doch da der Speicher mit delete wieder frei gegeben.

no_code

ak133 schrieb:

oh entschuldigung noch eine Frage,
du meintest man braucht noch ein Destruktor um den Speicher wieder frei zu geben.
War das jetzt auf mein Programm bezogen? Weil in meinem Programm, wird doch da der Speicher mit delete wieder frei gegeben.

kannst dir schenken wird am ende der function eh wieder frei gegeben

ak133

also ich meine der wird mit delete wieder frei gegeben?

no_code schrieb:

kannst dir schenken wird am ende der function eh wieder frei gegeben

also entweder wars falsch oder ich hab mich unklar ausgedrückt

zwutz

wenn du im Konstruktor Speicher anforderst (also der selbst wieder ein new stehen hast) dann musst du auch dafür sorgen, dass dieser Speicher wieder freigegeben wird, wenn er nicht mehr gebraucht wird. Also üblicherweise ein delete im Destruktor (der wird automatisch aufgerufen, wenn dein Objekt zerstört wird, in deinem Fall durch das delete)

In deinem Code-Stück aber soweit erstmal irrelevant

SeppJ

ak133 schrieb:

oh entschuldigung noch eine Frage,
du meintest man braucht noch ein Destruktor um den Speicher wieder frei zu geben.
War das jetzt auf mein Programm bezogen? Weil in meinem Programm, wird doch da der Speicher mit delete wieder frei gegeben.

Delete ruft auch den Destruktor auf. Das war aber nicht auf dein Beispiel bezogen, sondern auf den Fall, wo man selber in einer Klasse Speicher anfordert:

class foo
{
 private:
  int *bar;
 public:
  foo(): bar(new int){}    // Hier wird im Konstruktor Speicher angefordert
  ~foo():{delete bar;}     // Und den muss man ja auch irgendwo wieder freigeben
}

int main()
{
// Auf diese Weise wird der Speicher automatisch verwaltet. Egal ob man mit new delete arbeitet:
 foo *x = new foo;    // Speicher für ein neues foo wird angefordert, der Konstruktor fordert zudem auch Speicher für einen int an
 delete x;            // Und der speicher auf den x zeigt wird freigegeben, gleichzeitig wird auch der Speicher auf den x.bar zeigt durch den Destruktor von foo freigegeben.

// Das geht natürlich auch mit lokalen Objekten:
 {
  foo y;   // Speicher für y und über den Konstruktor auch für einen int
 }  // Und beim Verlassen des Gültigkeitsbereichs wird alles wieder freigegeben
}

Beachte aber, dass dieses Beispiel nicht vollständig ist. Man muss sich bei dieser Konstruktion auch unbedingt noch um korrektes Verhalten beim
Kopieren kümmern (also Kopierkonstruktor und Zuweisungsoperator selber schreiben).