ersetzen



  • variablen:

    char *str,*buffer;
    

    der rest:

    strcpy(str,Temp2);
               while(*str)
                    {
                     if(*str=='(')
                       {
                        *buffer++='\\';
                        *buffer++='(';
                       }
                     else if(*str==')')
                       {
                        *buffer++='\\';
                        *buffer++=')';
                       }
                     else
                       {
                        *buffer++=*str;
                       }
                        ++*str;
                       }
                        *buffer=0;
                        strcpy(Temp2, buffer);
    

    mfg saroll 🤡🤡🤡



  • Ja und wo zählst du jetzt wieviel platz buffer benötigt und wo hat buffer seinen Speicherplatz?

    Der arme Puffer hat keinen Speicherplatz 🤡

    MfG SideWinder



  • *heul*
    ich kenn mich nicht mehr aus 😞 😞 😞 😞

    und wie geb ich dem blöden buffer speicherplatz??
    mit dem malloc zeug??
    oder gehts auch einfacher??



  • mach so

    /* 
    entweder du nimmst eine fixe groesse wie hier oder du schreibst eine funktion die zählt wie viele zeichen ausgetauscht werden und dann ist halt 
    der buffer um die Anzahl dieser zeichen groesser als der string
    
    buffer = (char*) malloc (sizeof(src_string) + count);
    
    machs aber am anfang mit fixer groesse
    */
    
    char buffer[50];
    
    void tausche_aus(src_string, buffer); // Funktionsaufruf
    


  • Unser Algorithmus sieht grundsätzlich so aus:

    Zeichen ansehen
        if Zeichen == bestimmtesZeichen then
            Zeichen = neuesZeichenTeil1
            verschiebe_buffer_ab_zeichen_nach_hinten(str)
            Zeichen+1 = neuesZeichenTeil2 // wenn wir nicht verschieben würden, würde hier etwas verloren gehen
        else
            Zeichen = altesZeichen
    Nächstes Zeichen ansehen
    

    Schwierig umzusetzen ist in C das verschieben, da ein Array zu einem Zeitpunkt immer nur eine fixe Größe hat und sich nicht dynamisch vergrößert. Wir könnten alles um eins nach hinten verschieben, bloß wohin mit dem letzten Zeichen?

    Also arbeiten wir in C anders, wir legen uns einen TempBuffer an (bei Shade buffer) der die Größe hat die wir benötigen:

    // Speichergröße "berechnen"
    BenoetigterPlatz = 0
    
    Zeichen ansehen
        if Zeichen == bestimmtesZeichen then
            BenoetigterPlatz += 2
        else
            BenoetigterPlatz += 1 // BenotiegterPlatz++
    Nächstes Zeichen ansehen
    
    // Speicherplatz holen (TempBuffer anlegen), C-Code:
    char* buffer = new char [BenoetigterPlatz + 1]; // + 1 ist deshalb nötig, weil C immer noch ein 0 am Ende eines Strings haben will und das wollen wir auch einfügen
    
    // Shades Algorithmus
    DerzeitigesZeichen = 0
    
    Zeichen ansehen
        if Zeichen == bestimmtesZeichen then
            buffer[DerzeitigesZeichen] = neuesZeichenTeil1
            buffer[DerzeitigesZeichen] = neuesZeichenTeil2
            DerzeitigesZeichen += 2
        else
            buffer[DerzeitigesZeichen] = Zeichen
            DerzeitigesZeichen += 1
    Nächstes Zeichen ansehen
    
    // 0 anfügen, damit es ein "echter" C-String wird:
    buffer[DerzeitigesZeichen] = 0
    
    // Damit der User aber nicht ab jetzt mit buffer arbeiten muss sondern weiterhin mit str arbeiten kann hängen wir den String jetzt um:
    
    // Alter String kann gelöscht werden, C-Code
    delete [] str
    
    // Alten String auf neuen String zeigen lassen, C-Code
    str = buffer
    

    Hoffentlich war das verständlich und fehlerfrei 🙂

    MfG SideWinder



  • Statt new und delete natürlich malloc und free benützen 🙂

    *C++ geschädigt bin*

    MfG SideWinder



  • ne, du, irgendwie hab ich das nicht verstanden 😞
    ich bin und bleib dumm...

    mfg trauriger saroll 🤡



  • Wo haperts denn genau? 😞

    MfG SideWinder



  • ich versuch das jetzt noch einmal codetechnisch umzusetzen...
    die logik hab ich ja verstanden (also bin ich doch nicht so dumm)

    mfg saroll



  • so, hier is mein neuer code...
    aber irgendwie will das ding nicht so wie ich will

    for(i;i<strlen(Temp2);)
                  {if(str[i]=='(')
                     {buffer[i]='\\';
                      buffer[i+1]='(';
                      i+=2;
                      buffer = (char*) malloc (sizeof(buffer) + 2);
                     }
                  else if(str[i]==')')
                         {buffer[i]='\\';
                          buffer[i+1]=')';
                          i+=2;
                          buffer = (char*) malloc (sizeof(buffer) + 2);
                         }
                  else
                     {buffer[i]=str[i];
                      i++;
                     }
                  }
    

    mfg saroll 🤡🤡🤡

    ps.: immer noch das selbe prob wie vorhin



  • for(i;i<strlen(Temp2);)
    

    du musst i mit 0 initialisieren

    buffer = (char*) malloc (sizeof(buffer) + 2);
    

    und du versuchst den buffer mit malloc zu erweitern das wird nicht gut gehen entweder du verwendest realloc (beim ersten Aufruf verhält sich realloc wie malloc)
    gib dem buffer zu Beginn mal eine konstante groeße ist einfacher 😉



  • so, ich hab dem buffer ne konstante gegeben und es rennt jetzt auch
    aaaber er spuckt mir am ende irgendwelchen sch** aus...
    das find ich voll nicht in ordnung 😞 😞

    mfg saroll

    ps:
    noch einmal der code

    for(i=0;i<strlen(Temp2);)
                  {if(str[i]=='(')
                     {buffer[i]='\\';
                      buffer[i+1]='(';
                      i+=2;
                     }
                  else if(str[i]==')')
                         {buffer[i]='\\';
                          buffer[i+1]=')';
                          i+=2;
                         }
                  else
                     {buffer[i]=str[i];
                      i++;
                     }
                  }
    


  • realloc() ist vielleicht für den Anfang tatsächlich logischer als einen Zweitbuffer zu verwenden.

    gib dem buffer zu Beginn mal eine konstante groeße ist einfacher

    Dafür kannst du die Funktion in die Tonne werfen.

    MfG SideWinder



  • naja wahrscheinlich hast du vergessen den string abzuschließen.
    c-artige strings haben ja am Ende eine binaere null '\0' kennst du sicher.
    du musst also den buffer mit einer null abschließen dann müsste es funktionieren

    buffer[i] = 0;
    // oder halt so
    *buffer = 0;
    


  • SideWinder schrieb:

    Dafür kannst du die Funktion in die Tonne werfen.

    ja ist eh klar, ich meinte natürlich nur fürn anfang wenns programm dann einmal läuft kann ers ja ersetzen



  • Ist das Problem jetzt eigentlich schon gelöst, oder happerts noch wo?



  • hallo!!

    das problem ist gelöst, ich mache es zwar statisch aber es reicht so 😉
    danke an alle die geholfen haben 🤡🤡

    mfg saroll 🤡🤡


Anmelden zum Antworten