Copy-Konstruktor

Ein Kopierkonstruktor (auch Copy-Konstruktor) ist in der Informatik ein spezieller Konstruktor, der eine Referenz auf ein Objekt desselben Typs als Parameter entgegennimmt und die Aufgabe hat, eine Kopie des Objektes zu erstellen.

Beispiel

Beispiel in C++ (gekürzt):

class Zeichenkette
{
private:
  char* m_memory;
 
public:
  Zeichenkette() : m_memory(NULL) {} // Standardkonstruktor
 
  Zeichenkette(const char* value) // Konstruktor
  {
    m_memory = new char[strlen(value) + 1]; // Speicher der richtigen Länge reservieren
    strcpy(m_memory, value);  // Den String aus value in den reservierten Speicher kopieren
  }
 
  // Kopierkonstruktor:
  // hat in C++ immer die Signatur "Klassenname(const Klassenname&)"
  Zeichenkette(const Zeichenkette& rhs) // Üblicherweise rhs: "Right Hand Side"
  {
    m_memory = new char[strlen(rhs.m_memory) + 1];
    strcpy(m_memory, rhs.m_memory);
  }
};

Aufruf

Der Kopierkonstruktor wird bei der Initialisierung eines Objektes mittels eines anderen Objekts desselben Typs aufgerufen. In C++ wird dieses andere Objekt als einziger Parameter dem Konstruktor übergeben. Es erfolgt in der Deklaration des Objektes die Zuweisung des anderen Objektes oder das Objekt wird als Wertparameter an eine Funktion oder Methode übergeben.

Beispiel in C++:

 void tueNichts(Zeichenkette z); // Funktionsprototyp der ein Wertobjekt übernimmt
 
 Zeichenkette name("Dulz"); // Erstelle eine Zeichenkette
 
 Zeichenkette namensKopie = name; // Kopierkonstruktor, Zuweisungssyntax
 Zeichenkette zweiteKopie(name);  // Kopierkonstruktor, Aufrufsyntax
 tueNichts(name);                 // Kopierkonstruktor, Übergabe an Funktion per Wert
 
 Zeichenkette keinKopierkonstruktor;
 keinKopierkonstruktor = name;  // Fehler: Hier verlangt C++ nach einem überladenen Zuweisungsoperator.
 
 void tueNichts(Zeichenkette z)
 {
   // z besitzt eine eigene Kopie des Namens "Dulz" im Speicher
 }

Verwendung

Einige Programmiersprachen, wie beispielsweise C++, stellen einen vordefinierten Kopierkonstruktor zur Verfügung, der einfach die Elementvariablen des zu kopierenden Objektes in die des zu initialisierenden Objektes kopiert. (In anderen Programmiersprachen, z. B. Java, muss der Kopierkonstruktor explizit programmiert werden.) Manchmal ist das allerdings nicht ausreichend. Sind unter den Elementvariablen nämlich Handles auf Ressourcen und gibt das bereits existente Objekt die Ressourcen frei, so ist das Handle in dem per Standard-Kopierkonstruktor erstellten Objekt ungültig und seine Verwendung kann dann zu Programmabstürzen führen.

Im Beispiel enthält jede Instanz von Zeichenkette ihren eigenen Speicher, der beim Aufruf des Kopierkonstruktors reserviert wird. Wenn jede Kopie eines Objektes exklusiven Zugriff auf ihre Ressourcen hat, d. h. sie nicht mit anderen Objekten teilen muss, spricht man von einer tiefen Kopie (engl. deep copy). Andernfalls spricht man von einer flachen Kopie (engl. shallow copy). Eine flache Kopie produziert der Compiler mit dem vordefinierten Kopierkonstruktor automatisch. Ist in der Klasse Zeichenkette kein Kopierkonstruktor definiert, der eine tiefe Kopie erstellt, würden nach einer Kopie zwei Objekte einen Zeiger auf denselben Speicherblock haben, da die Adresse einfach kopiert werden würde. Ein Objekt weiß dann aber nicht, ob das andere bereits delete auf dem Speicherblock aufgerufen hat. Sowohl ein Zugriff auf den Speicher als auch ein erneutes delete würden dann zu einem Absturz des Programmes führen. Folgendes Beispiel illustriert dies.

Beispiel in C++ (gekürzt):

class ZeichenketteF 
{
public:
  ZeichenketteF() : m_memory(NULL) {} // Standardkonstruktor
  ZeichenketteF(const char* value)    // Konstruktor
  {
    m_memory = new char[strlen(value) + 1]; // Speicher der richtigen Länge reservieren
    strcpy(m_memory, value);                // Den String aus value in den reservierten Speicher kopieren
  }
  // die Klasse ZeichenketteF übernimmt den Standard-Kopierkonstruktor
 
private:
  char *m_memory;
};
 
void scheitere()
{ 
  ZeichenketteF name("Wolfgang");
 
  // anonymer Block für neuen Gültigkeitsbereich:
  {
    ZeichenketteF kopie(name); // Nun wird eine so genannte [[flache Kopie]] erstellt.
    // Sowohl name.m_memory als auch kopie.m_memory zeigen nun auf denselben Speicher!
  } // automatischer Destruktoraufruf für kopie, gibt Speicher, auf den m_memory zeigt, frei
    // das Objekt name verweist weiter auf - einen nun freigegebenen - Speicherbereich
 
} // automatischer Destruktoraufruf für name. 
  // Der Versuch, denselben Speicherblock erneut freizugeben, führt (vielleicht nur) zu einem Absturz

Kosten tiefer Kopien

Wie am Beispiel unter Aufruf sichtbar, finden tiefe Kopien statt, daraus folgt eine gewisse Last. Zur Vermeidung unnötiger Last empfehlen sich zwei Varianten der oben dargestellten Kopier-Strategie.

• Ressourcen mittels Referenzzählung in verschiedenen Instanzen gemeinsam zu nutzen; viele Implementierungen der Klasse String machen hiervon Gebrauch.
• konstante Referenzen als Parameter in Funktionen und Methoden zu übernehmen, in all den Fällen, in denen auf Parameter nur lesend zugegriffen wird.

Der Kopierkonstruktor selbst zeigt in seinem Prototyp wie man unnötige tiefe Kopien von Objekten vermeidet, auf die man nur lesend zugreifen muss: Er übernimmt eine konstante Referenz, denn sonst müsste er ja (implizit) aufgerufen werden, bevor er aufgerufen wird! Die Signatur "Klassenname(const Klassenname&)" ist auch deshalb typisch.

Fazit

Am Beispiel des Kopierkonstruktors kann man sehr schön die Komplexität der C++-Programmiersprache zeigen, Sprachelemente bedingen und stützen einander. Man kann selten eines in Verwendung nehmen, ohne gleichzeitig einer Menge anderer zu bedürfen.

Siehe auch

Konstruktoren und Destruktoren