// Lösung zum überladenen Zuweisungsoperator

// Dateien einbinden
#include <iostream>
#include <cstring>

using std::cout;
using std::endl;

// Klassendefinition
class CString
{
    char *pString;          // String
    short stringNum;        // akt. String-Nummer
    static short count;     // laufende String-Nummer
public:
    // ctor
    CString();
    CString(const char *const psT);
    CString(const CString& source);
    // dtor
    ~CString();
    // Strings zuweisen
    CString& operator = (const char *const pS);
    CString& operator = (const CString& source);
    // Strings addieren
    void AddString(const char *const pS);
    void AddString(const CString& add);
    // String ausgeben
    void Print() const;
};
// Statische Eigenschaft definieren!
short CString::count;

// Definition der Memberfunktionen
// 1. Konstruktor
CString::CString()
{

    // char-Feld mit einem Element anlegen
    pString = new char[1];
    // String als leeren String kennzeichnen
    pString[0] = 0;
    // Stringzähler erhöhen
    count++;
    // Und aktuelle Nummer merken
    stringNum = count;
}
// 2. Konstruktor
CString::CString(const char *const pS)
{
    // Speicherplatz für String anfordern
    // Die abschliessende binäre 0 dabei nicht vergessen!
    pString = new char[strlen(pS)+1];
    // String umkopieren
    strcpy(pString,pS);
    // Stringzähler erhöhen
    count++;
    // Und aktuelle Nummer merken
    stringNum = count;
}
// 3. Konstruktor (Kopierkonstruktor)
CString::CString(const CString& source)
{
    // Gleicher Ablauf wie beim vorherigen ctor
    pString = new char[strlen(source.pString)+1];
    strcpy(pString,source.pString);
    count++;
    stringNum = count;
}
// Destruktor
CString::~CString()
{
    // Speicher für char-Feld freigeben!
    delete [] pString;
    count--;
}
// Weist einem String Objekt einen char-String zu
CString& CString::operator = (const char *const pS)
{
    // Alten String löschen
    delete [] pString;
    // Neuen String anlegen
    pString = new char[strlen(pS)+1];
    strcpy(pString,pS);
    return *this;
}
// Weist einem String Objekt ein anderes String Objekt zu
CString& CString::operator = (const CString& source)
{
    // Zuweisung auf sich selbst abprüfen
    if (&source == this)
        return *this;
    // Alten String löschen
    delete [] pString;
    // Neuen String anlegen
    pString = new char[strlen(source.pString)+1];
    strcpy(pString,source.pString);
    return *this;
}
// Fügt den über den char-Zeiger übergebenen String hinzu
void CString::AddString(const char *const pS)
{
    char *pTemp;    // Hilfszeiger

    // Zuerst Speicher für neuen String reservieren
    pTemp = new char[strlen(pString)+strlen(pS)+1];
    // Dann den ursprünglichen String umkopieren
    strcpy(pTemp,pString);
    // und nun den neuen String hinzufügen
    strcat(pTemp,pS);
    // Jetzt erst den ursprünglichen Speicher freigeben
    delete [] pString;
    // und Zeiger auf neuen Speicherbereich setzen
    pString = pTemp;
}
// Fügt den über die String-Referenz übergebenen String hinzu
void CString::AddString(const CString& add)
{
    char *pTemp;    // Hilfszeiger

    // Gleicher Ablauf wie vorherige Memberfunktion
    pTemp = new char[strlen(pString)+strlen(add.pString)+1];
    strcpy(pTemp,pString);
    strcat(pTemp,add.pString);
    // Jetzt erst den ursprünglichen Speicher freigeben
    delete [] pString;
    // und Zeiger auf neuen Speicherbereich setzen
    pString = pTemp;
}
// Ausgabe des Strings
void CString::Print() const
{
    cout << stringNum << ".String: " << pString << endl;
}

// main() Funktion
int main()
{
    // Zwei String Objekte definieren
    CString myString1("bla bla bla...");
    CString myString2("und sonstiger Nonsens");

    // Beide Strings ausgeben
    cout << "\nAusgangs-Strings\n";
    myString1.Print();
    myString2.Print();

    // Nun neue Texte den Strings zuweisen
    myString1 = "Dieser Text wird dupliziert";
    myString2 = myString1;

    // Beide Strings ausgeben
    cout << "\nNach Zuweisung\n";
    myString1.Print();
    myString2.Print();
}