da ich beruflich bislang nur im .NET-Umfeld in C# entwickelt habe und nun privat gerne etwas C++ lernen möchte habe ich ein paar Anfängerfragen zu C++.

Derzeit stolpere ich dabei insbesondere über die Erstellung und Freigabe von Objekten. Vielleicht mag mir das jemand von euch leicht verständlich erklären:

1. Worin liegt in C++ der Unterschied ob ich eine Klasseninstanz mit dem Schlüsselwort "new" erzeuge oder ohne?

Beispiel:

MyObj CMyObj;

vs.:

MyObj = new CMyObj();

Wann wende ich welche Vorgehensweise an?

2. Worin liegt in C++ der Unterschied ob ich delete oder das SafeRelease-Template (welches in einem MSDN-Beispiel zu Direct2D gefunden habe) zur Freigabe von Objektinstanzen verwende?

Beispiel:

delete myObj;

vs.:

SafeRelease(myObj);

template <class T> void SafeRelease(T **ppT)
{
    if (*ppT)
    {
        (*ppT)->Release();
        *ppT = NULL;
    }
}

3. Warum wird in dieser konkreten Beispielmethode (die ich in einem Open-Source Projekt gefunden habe) "string" mittels delete[] freigegeben, list und count werden aber nicht freigegeben (ich vermute bei dem Integer-Typen das der Compiler erkennt das der Scope der Methode verlassen wird, aber warum ist dies bei "string" nicht so und bei "list" doch wieder)?

void DebugPrint(char *format, ...)
{
	int     count;
	va_list list;
	char*   string;
	va_start(list, format);
	count = _vscprintf(format, list);
	string = new char[count + 1];
	vsprintf_s(string,count+1,format,list);
	va_end(list);
	OutputDebugStringA(string);
	delete[] string;
}

Vielen Dank für alle Antworten im voraus,
Matze

1. Worin liegt in C++ der Unterschied ob ich eine Klasseninstanz mit dem Schlüsselwort "new" erzeuge oder ohne?

Durch "new" erzeugte Instanzen werden auf dem Heap angelegt und bleiben solange bestehen, bis sie mit delete gelöscht werden. Ohne "new" erzeugte Instanzen bleiben nur bis zum Ende des Gültigkeitsbereiches bestehen und werden dann automatisch zerstört.

2. Worin liegt in C++ der Unterschied ob ich delete oder das SafeRelease-Template (welches in einem MSDN-Beispiel zu Direct2D gefunden habe) zur Freigabe von Objektinstanzen verwende?

Wie man sieht, prüft SafeRelease erst, ob der Pointer des Objektes gültig ist, ruft dann die Methode Release auf und setzt den Zeiger auf 0.
Das hat mit Speicherverwaltung jedoch nichts zu tun, und ist vermutlich eine Direct3D Anweisung um Dinge (Texturen?) wieder freizugeben.

3. Warum wird in dieser konkreten Beispielmethode (die ich in einem Open-Source Projekt gefunden habe) "string" mittels delete[] freigegeben, list und count werden aber nicht freigegeben (ich vermute bei dem Integer-Typen das der Compiler erkennt das der Scope der Methode verlassen wird, aber warum ist dies bei "string" nicht so und bei "list" doch wieder)?

"string" ist ein Zeichenarray und wurde mit new ( string = new char[count + 1]; ) allokiert und liegt damit auf dem Heap und muss daher manuell via delete wieder freigegeben werden. "list" und "count" liegen auf dem Stack und werden daher, wie du schon richtig vermutet hast, beim Verlassen des Scopes zerstört.

1. Worin liegt in C++ der Unterschied ob ich eine Klasseninstanz mit dem Schlüsselwort "new" erzeuge oder ohne?

Wie mein Vorredner schon gesagt hat, werden die Objekte, die du ohne new anlegst auf den Stack* angelegt und beim verlassen des Scopes automatisch zerstoert, waehrend du mit new erstellte, die auf dem Heap* angelegt werden, manuell loeschen musst.
Schau dir einfach folgenden Code an:

#include <iostream>
#include <string>

class MyClass //CXxxx ist veraltete MFC-Notation
{
    std::string name;

public:
    MyClass(const std::string& name_) : name(name_) //Initialisierungsliste
    {
        std::cout << "MyClass \"" << name << "\" wurde erzeugt!\n";
    }

    ~MyClass()
    {
        std::cout << "MyClass \"" << name << "\" wird zerstoert :(\n";
    }
};

int main()
{
    MyClass obj1("obj1");
    MyClass* obj2 = new MyClass("obj2");

    delete obj2;
    MyClass* obj3 = new MyClass("obj3");
    MyClass* obj4 = new MyClass("obj4");

    MyClass* objTmp;
    {
        MyClass obj5("obj5");
        MyClass* obj6 = new MyClass("obj6");
        objTmp = obj6; //Damit wir es aussserhalb des Scopes noch freigegeben koennen
        MyClass* obj7 = new MyClass("obj7"); //Upps
    }
    delete objTmp; //delete obj6

    delete obj3;
    //delete obj4; //Upps, vergessen
}

MyClass "obj1" wurde erzeugt!
MyClass "obj2" wurde erzeugt!
MyClass "obj2" wird zerstoert :(
MyClass "obj3" wurde erzeugt!
MyClass "obj4" wurde erzeugt!
MyClass "obj5" wurde erzeugt!
MyClass "obj6" wurde erzeugt!
MyClass "obj7" wurde erzeugt!
MyClass "obj5" wird zerstoert :(
MyClass "obj6" wird zerstoert :(
MyClass "obj3" wird zerstoert :(
MyClass "obj1" wird zerstoert :(

Und hier siehst du auch das Dilemma: obj4 und obj7 werden zwar allokiert, aber nie wieder freigegeben. Memory-Leak. Deswegen: Nimm kein new , wenn du nicht musst, und wenn dus tust, dann nimm einen Smart-Pointer. Und fuer dynamische Arrays gibts std::vector .

* Der Standard kennt keinen Stack und Heap. Wie das intern geregelt ist, haengt vom Compi und Betriebssystem ab. IdR macht man das auf heute gaengigen Platformen ueber Stack und Heap.

Matze1974 schrieb:

1. Worin liegt in C++ der Unterschied ob ich eine Klasseninstanz mit dem Schlüsselwort "new" erzeuge oder ohne?

Mach dir klar, dass es in C++ drei Speicherbereiche gibt:
- Statischer Speicher
- Automatischer Speicher (aka Stack)
- Freispeicher (aka Heap)

C++ zwingt dir hier keine Indirektion auf. In C# liegen Objekte von Klassentypen immer im Heap und was du in der Hand hältst ist nur eine Referenz, die selbst irgendwo im Speicher liegt, typischerweise auf dem Stack oder in einem anderen Objekt. In C++ kannst du direkt mit Objekten hantieren, ohne Umweg über einen Zeiger oder eine Referenz. Das ist dann so ähnlich wie mit den Typen, die man unter C# "value types" nennt.

Die direkte Verwendung von new/delete ist verpönt, weil man sich dadurch viel zu schnell Speicherlecks und ähnliche Probleme einhandelt. Siehe weiter unten für Alternativen.

Matze1974 schrieb:

2. Worin liegt in C++ der Unterschied ob ich delete oder das SafeRelease-Template (welches in einem MSDN-Beispiel zu Direct2D gefunden habe) zur Freigabe von Objektinstanzen verwende?

Wie schon gesagt wurde, ist ->Release() irgend eine System- oder Design-spezifische Funktion, wahrscheinlich COM-Kram, hat also mit allgemeiner Speicherverwaltung weniger zu tun. So eine SafeDelete-Funktion ist eigentlich nur ein Anzeichen dafür, dass die Autoren nicht soweit gedacht haben, eine Resource wie die eines COM-Objekts in ein geeignetes Objekt zu verpacken, was sich automatisch darum kümmert. Unter modernen Gesichtspunkten ist SafeDelete für'n Arsch, COM hin oder her.

Matze1974 schrieb:

3. Warum wird in dieser konkreten Beispielmethode (die ich in einem Open-Source Projekt gefunden habe) "string" mittels delete[] freigegeben, list und count werden aber nicht freigegeben (ich vermute bei dem Integer-Typen das der Compiler erkennt das der Scope der Methode verlassen wird, aber warum ist dies bei "string" nicht so und bei "list" doch wieder)?

void DebugPrint(char *format, ...)
{
	int     count;
	va_list list;
	char*   string;
	va_start(list, format);
	count = _vscprintf(format, list);
	string = new char[count + 1];
	vsprintf_s(string,count+1,format,list);
	va_end(list);
	OutputDebugStringA(string);
	delete[] string;
}

Das hat wieder mit den 3 Speicherberechen zu tun. Die Variablen count, list und string liegen im automatischen Speicher. Sie werden also automatisch weggeräumt, wenn die Funktion beendet ist. string ist aber ein Zeiger und das worauf er zeigt hat der Autor mit new angelegt. string zeigt also auf einen im Freispeicher allozierten Bereich. Der Freispeicher ist gerade dazu da, dass man selbst die Kontrolle über die Lebenszeit verschiedener darin lebende Objekte entscheiden kann, also muss man die Dinger auch explizit wieder entfernen. Allerdings würde das Programm im modernen C++ Stil trotzdem ganz anders aussehen:

void DebugPrint(char *format, ...)
{
	int     count;
	va_list list;
	vector<char> string;
	va_start(list, format);
	count = _vscprintf(format, list);
	string.resize(count+1);
	vsprintf_s(&string[0],count+1,format,list);
	va_end(list);
	OutputDebugStringA(&string[0]);
}

Natürlich ist das mit den Ellipsen (...) auch ne blöde und fehleranfällige Idee und gehört eigentlich nicht in modernes C++ rein. Aber hier ist die Sache mit der Speicherverwaltung schön hinter einem vector versteckt. Der Vektor lebt auch im automatischen Speicher und fühlt sich für die im Freispeicher allozierten Elemente verantwortlich. Das heißt, wenn das vector-Objekt aus dem automatischen Speicher geschmissen wird, räumt er auch selbstständig die Elemente aus dem Freispeicher wieder weg. Sowas nennt sich RAII (resource acquisition is initialization) und ist ein Grundpfeiler von guten C++ Programmen.

Es ist wahrscheinlich keine gute Idee, zu glaube, dass C++ so aussehen sollte, wie es dir die Microsoft C++ Beispiele zeigen. So oft habe ich da persönlich auch nicht reingeguckt, aber das, was ich sah, sah leider grottig aus. Merk dir, dass wenn du es für nötig hältst delete, new[] oder delete[] zu verwenden, du wahrscheinlich etwas falsch machst. Neben den extremst praktischen Container-Klassen (vector ist eine davon) gibt es auch in C++11 noch sehr praktische "Schlauzeiger" (smart pointer): unique_ptr und shared_ptr, die auch mit dem RAII-Gedanken entworfen worden. Man könnte sicherlich das ->Release() in dem Beispiel, was du dir angeguckt hast, einen unique_ptr übernehmen lassen, so das man sich selbst darum nicht mehr kümmern muss.