Eigene Stringklasse | Verständnissfragen

Xecutor

Servs zusammen,

ich war grad dabei eine eigene simple Stringklasse zu erstellen, da sie auch als Übungsaufgabe in unserem Semester vorgesehen war.
Es geht um folgendes, unser Professor hat folgende zwei Funktionen geschrieben:

char* MyString::copyString(char* dest, const char* str) const{
    char* newDest = dest;

    while((*newDest++ = *str++) != '\0');

    return newDest;
}

und

char* MyString::duplicateString(const char* str) const{
    unsigned int length = countStringLength(str) + 1;
    char* copy = new char[length];
    copyString(copy, str);

    return copy;
}

Er ruft dann im Konstruktor die duplicateString() Methode auf, um den String an die Klassenvariable string zu übergeben. Sieht dann folgendermaßen aus:

MyString::MyString(const char* str){
    string = duplicateString(str);
    stringLength = countStringLength(str);
}

Meine Frage nun, wieso die zwei Methoden copyString() und duplicateString()?
Vll ist auch nur die Namensgebung der Funktionen verwirrend, doch irgendwie will es mir nicht einleuchten, wieso er nicht eine Methode dafür nehmen kann.
Evt. kann mir einer von euch auf die Sprünge helfen, mit einer Vorgehensweise was genau passiert wenn man nun den Konstruktor aufruft.

Bin für jeden Tip, wie immer sehr dankbar

Xecutor

PS: Die Suche scheint irgendwie nicht zu funktionieren, ich krieg egal wonach ich suche :Keine Beiträge zu ihren Suchkriterium gefunden - oder ähnlich raus

enno-tyrant

evtl. will er den konstruktor nicht zumüllen
oder er will die funktion später noch nutzen, wer weiß, wer weiß ??

finix

copyString kopiert den Inhalt eines Strings/const char*, duplicateString alloziert Speicher bevor copyString aufgerufen wird.
Für die Stringkonstruktion brauchst du Speicher, für's zuweisen u.U. nicht...

Xecutor

Sprich ich könnte die beiden Methoden auch zu einer zusammenfassen, oder wäre das nicht sinnvoll ?

Folgender Code funktioniert leider nicht:

char* MyString::allocateString(const char* str) const{
    unsigned int length = countStringLength(str) + 1;
    char* copy = new char[length];

    while((*copy++ = *str++) != '\0');

    return copy;
}

Wo ist mein Denkfehler ? Wenn ich jetzt

MyString name = "Kuhschwanz";

mache, und den namen in der Konsole ausgeben will, kriege ich nur ²²²²²²² raus. Bissel strange, wie ich finde.

Xecutor

Killing me softly

Man könnte die beiden Methoden zusammenfassen, stimmt. Die Frage ist: macht es Sinn, eine Methode copyString() zu haben? Lautet die Antwort: ja, dann macht es auch Sinn diese Methode für dublicateString() zu verwenden. Spätestens, wenn du den gleichen Programmcode an 25 verschiedenen Stellen hast und bemerkst, das sich da ein Fehler eingeschlichen hat, wirst du den Vorteil erkennen

Zu deiner Methode allocateString():

char* copy = new char[length];     // copy zeigt auf die Speicheradresse 
                                   // deines reservierten Speichers, genau
                                   // diese Adresse musst du nachher mit 
                                   // return zurückgeben

while((*copy++ = *str++) != '\0'); // hier inkrementierst du copy d.h. bei
                                   // jedem Durchlauf wird die Adresse, auf
                                   // den copy zeigt um 1 Byte verschoben

return copy;                       // auf welche Adresse zeigt copy?
                                   // Antwort: auf die Adresse die sich hinter
                                   // deinem reservierten Speicher befindet - Autsch!

Xecutor

@killing my softly,

danke dir, durch deine Kommentare ist es mir nun um einiges klarer
Entweder ich belasse die 2 Methoden, was ja jetzt Sinn macht oder ich erweitere meine allocateString() Methode um einen weiteren Zeiger auf copy, und returne den dann.

char* MyString::allocateString(const char* str) const{
    unsigned int length = countStringLength(str) + 1;
    char* copy = new char[length];
    char* newCopy = copy;

    while((*copy++ = *str++) != '\0');

    return newCopy;
}

Xecutor