Nachdem ich jetzt den ganzen Nachmittag damit verbracht habe den Fehler im meinem Programm zu suchen habe ich jetzt festgestellt, dass das Problem doch nichts mit Bibliotheken zu tun hat, wie ich das in meinem zuvor erstellten Thread behauptet habe.

Also: ich habe zum Testen diesen Code geschrieben:

class String{
private:
    char* c;
public:
    String(){
        c = new char[100];
    }

    ~String(){
        delete []c;
    }
};

void setString(String s){
}

int main(int argc, char* argv[]){
    setString(String());
    return 0;
}

Unerklärlicherweise wird der Destruktor ~String() 2 Mal ausgeführt: ein mal am Ende von setString und ein Mal am Ende von main. Das bedeutet natürlich ein Problem. Klar könnte ich verhindern dass c 2 Mal gelöscht wird, aber ich wüsste gerne warum der Destruktor 2 Mal läuft: es wird doch nur 1 Objekt erzeugt.

Das Witzige ist: wenn ich einen Copy-Constructor für String einfüge funktioniert es. An dieser Stelle würden die meisten wahrscheinlich sagen: klar, String() erzeugt ein Objekt, das für den Aufruf von setString kopiert wird. Und da der Default-Copy-Constructor eine flache Kopie macht ist das Ergebnis logisch. Aber jetzt kommt es: der Copy-Constructor (wenn ich einen einfüge) wird nie ausgeführt! Der normale Constructor und der Copy-Constructor laufen in Summe genau 1 Mal. Es wird also tatsächlich nur 1 Objekt erzeugt. Wieso läuft dann der Destruktor 2 Mal??

Und das beste ist: das ganze passiert nur wenn ich den VC++-Compiler verwende (wobei ich mit Visual Studio eine normale Win32-Konsolenapplikation erstellt habe). Bei Verwendung von gcc unter Linux und MacOS X sowie Turbo C unter Windows wird der Destruktor überall nur 1 Mal ausgeführt! Ich kann mir nicht vorstellen dass das ein Fehler im MS-Compiler ist, eher eine Einstellung. Denn so einen Code schreibt doch bald einmal wer...

Weiß jemand was laut Standard passieren sollte? Und sollte der Copy-Constructor laufen?

Danke im Voraus!

mfg

Das kann dir aber auch egal sein, sofern du nach dem delete Aufruf deinen Zeiger auf 0 setzt. Dann gibt es keinerlei Programmabstürze oder ähnliches.
Eine Speicherlücke entsteht dann auch nicht, weil der Speicher vorher ja ordnungsgemäß gelöscht wurde.

mfg

der Copy-Constructor (wenn ich einen einfüge) wird nie ausgeführt!

Kannst du den Kopierkonstruktor mal posten?

String(const String& s){
}

mfg

#include <cstring>

class String{
  //...
  const char* raw() const {
    return c;
  }
public:
  //...
  String(const String &s){
    c = new char[100];
    const char *str = s.raw();
    int len = std::strlen(str);
    std::strncpy(c, str, len);
  }
};

MfG

GPC

Vllt. solltest du den eher so schreiben

Dass meine Variante keinen Sinn macht ist mir klar. Aber nachdem er sowieso nie ausgeführt wird (habe durchdebuggt und eine Testausgabe gemacht) spielt das bei diesem Beispiel keine Rolle. Die Frage ist vielmehr wieso sich die Existenz des Copy-Constructors darauf auswirkt wie oft der Destruktor ausgeführt wird.

mfg

bei mir wird der destruktor auch 2 mal aufgerufen
und es kommt zum absturz....

Einmal wird das String() Objekt in main() zerstört und einmal das Objekt von SetString(String s)

Der Fehler ist, dass 2 Objekte bestehen und beide den selben Speicher zulöschen versuchen. Du musst den char* im Copy-Ctor und bei op= kopieren..

steff3 schrieb:

Der Fehler ist, dass 2 Objekte bestehen und beide den selben Speicher zulöschen versuchen. Du musst den char* im Copy-Ctor und bei op= kopieren..

Das wäre auch meine erste Idee gewesen. Tatsache ist aber, dass der Copy-Construktor (selbst wenn ich ihn implementiere) nie aufgerufen wird (das hat mit der Debugger und eine Testausgabe bestätigt). Daher kann es keine Rolle spielen was darin gemacht wird.

Warum der Copy-Construktor nie aufgerufen wird weiß ich auch nicht sicher. Meine Vermutung ist, dass das Objekt nicht zuerst erstellt und dann kopiert wird, sondern gleich von Anfang an am Stack der aufgerufenen Funktion erzeugt wird (wahrscheinlich eine Optimierung wenn man das String() direkt in den Aufruf schreibt). Jedoch dürfte dann der Destruktor nur 1 Mal laufen.

mfg

Alles andere wäre eine grobe Panne in der Implementierung der Sprache

EDIT:

Ich muss mich selbst korrigieren, der folgende Code:

#include <iostream>
using namespace std;

class String {
private:
  char* c;
public:
  String()
  {
    cout << "ctor" << endl;
    c = new char[100];
  }
  String(const String& o)
  {
    cout << "copy ctor" << endl;
  }
  String& operator=(const String& o)
  {
    cout << "op=" << endl;
  }
  ~String()
  {
    cout << "dtor" << endl;
    delete[] c;
  }
};

void setString(String s)
{
}

int main(void)
{
  setString(String());
  return 0;
}

wird von meinem g++ soweit herunteroptimiert, dass tatsächlich nur einmal der Constructor durchlaufen wird. Allerdings gilt dasselbe für den Destructor, insofern könnte es sich bei Dir tatsächlich um eine Macke im Compiler handeln.

Wenn ich mit String s; setString(s); ein Objekt erzeuge und übergebe wird korrekterweise Ctor, Copy Ctor, Dtor, Dtor ausgegeben...

mfg

Ok, und wieso wird mein Destruktor nur noch 1 Mal aufgerufen, jetzt wo mein Copy-Constructor korrekt ist?

Das nennt sich Optimierung - der Compiler rationalisiert die temporäre Variable weg, die für den Aufruf von SetString() benötigt wird und initialisiert deren Parameter direkt mit dem Default-Ctor.

(und da er nur ein Objekt erzeugt hat, benötigt er auch nur einen Dtor-Aufruf)