3. Warum klappt´s net?

Warum klappt´s net?

  • P

    Hallo, ich habe folgendes Problem:

    Also hier erst mal der Code:

    int String::getLength(char* string) const {

    char *p;
    p = string;
    // p ans Ende des Strings setzen
    while (p[0] != '\0') {
    p++;
    }

    return int(p);
    }

    so, hier der Anfang einer anderen Methode:

    void String::replace(char* oldString, char* newString) {

    int len = getLength(value) + getLength(newString);
    char buffer[len];
    ...

    Also, folgende Fehler werden gemeldet, warum?

    c:\CppWork\Separator\Main.cpp(148) : error C2057: Konstanter Ausdruck erwartet
    c:\CppWork\Separator\Main.cpp(148) : error C2466: Reservierung eines Feldes der konstanten Groesse 0 nicht moeglich
    c:\CppWork\Separator\Main.cpp(148) : error C2133: 'buffer' : Unbekannte Groesse

    Die Strings die übergeben werden haben 100%ig eine Länge über 0 und "value" auch!

    0
  • ?

    > return int(p);
    .... in "p" steht nicht die Laenge deines Strings.. sondern die Adresse
    des Endes... das duerfte etwas zu gross werden 😉

    Als return wert musst du die Differenz zwischen Anfang und Ende nehmen !

    > Die Strings die übergeben werden haben 100%ig eine Länge über 0 und "value"
    > auch!
    Das sagst jetzt du... aber der Compiler hat davon keine Ahnung 😉
    Der Compiler muss (zur Compilezeit) wissen, welcher Wert du da dem String
    zuweisen moechtest. Da du das aber nicht weisst, musst du das Problem dynamisch loesen... (new / delete)

    0
  • S

    return int(p);

    wohl eher

    return int(p-string);

    Also, folgende Fehler werden gemeldet, warum?

    Zur Compilezeit ist eben noch nicht bekannt, was du später eingibst. Woher soll denn der Compiler wissen, dass du (nach dem Kompilieren!!!) nur Werte über 0 eingibst. Du musst wie SolariX schon sagte, den Speicher dynamisch reserviern, also:

    char *buffer = new char[len];
// ...alles weitere...
delete [] buffer;   // nicht vergessen, den Speicher wieder freizugeben

    Mfg, smasher1985

    0
  • S

    @smasher1985 ... Die Lösung posten ist nicht immer der beste Weg um jemandem zu helfen... ich hatte gehofft Pogo käme selbst auf den richtigen Code!

    0
  • S

    @Solaris: Entschuldige, dass ich dein pädagogisches Konzept zerstört habe 😉 ...nein, aber im Ernst, war blöd von mir...

    Mfg, smasher1985

    0
  • P

    Mhh, also man kann smasher nichts vorwerfen, ich denke ich wäre nicht wirklich auf diese Lösung gekommen, bin noch ein Anfänger und ehrlich gesagt sehe ich keinen großen Unterschied bei diesen beiden Codezeilen:

    char buffer[len];

    char* buffer = new char[len];

    So weit ich das weis, ist der einzige Unterschied zwischen den beiden Zeilen, dass der Speicher einmal auf dem Heap und einmal auf dem Stack reserviert wird.

    Das verstehe ich wohl noch nicht so ganz, ist die erste Zeile also nur eine Deklaration(also es wird kein Speicher reserviert?)?

    Danke für die Antworten!

    0
  • D

    um Buffer auf dem Stack anzulegen, muss seine Größe schon zur Kompilierzeit bekannt sein.
    das heißt bei

    char buf[len];

    muss len eine Kompilierzeitkonstante sein. Also entweder mit
    const int len = xxx; deklarieren oder mit #define, oder die Zahl direkt in den Code reinschreiben.
    aber sobald du sowas hast:

    int len = STANDARD_WERT;
cin >> len;

    musst du den Speicher dynamisch (= zur Laufzeit des Programms) anfordern.
    auch bei

    int len = x;
    0
Anmelden zum Antworten