# String ersetzen in C



## Thomas Darimont (8. Januar 2004)

Servus!

Ich wollte mal ein wenig in fremden Gewässern fischen ;-)

Wie müsste denn eurer Meinung nach eine C-Funktion aussehen, die 
in einem gegebem char* ab einer bestimmten Stelle einen char* einfügt?

Sprich ich wil eine strReplace Funktion implemtieren ...

char* myStrReplace(char* str, char* strRep, int index){


};

wie müsste das ganze denn ausschauen?
Ausnahmen lassen wir mal aussen vor (zb. das der Ersetz-String größer ist als 
der ursprüngliche String)
Ich suche eine "elegante" Pointer Lösung, mit einer Schleife ginge das zwar auch, das ist aber nicht das, was ich suche.

Danke im vorraus.

Gruß Tom


----------



## Maximka (8. Januar 2004)

char* myStrReplace(char* str,const char* strRep, int index){
   strcpy(str+index,strRep);
   return str;
};
dann nur noch die ausnahmen behandeln und fertig

oder habe ich dich nicht ganz richtig verstanden?


----------



## Thomas Kuse (8. Januar 2004)

Möchtest Du eine search & replace Funktion oder begnügst Du Dich mit der Lösung von Maximka?


----------



## chibisuke (8. Januar 2004)

> Wie müsste denn eurer Meinung nach eine C-Funktion aussehen, die
> in einem gegebem char* ab einer bestimmten Stelle einen char* einfügt?



Hmm was jetzt? einfügen oder ersetzen?


```
Ersetzen währe das hier:

char* myStrReplace(char* str, char* strRep, unsigned int index) {
    char* ret;
    if(str == NULL || strRep == NULL || index > strlen(str)) return NULL;//Fehler abfangen
    ret = (char*)realloc(strdup(str),min(strlen(str), strlen(strRep) + index) + 1);
    if(ret == NULL) return NULL //ups, out of memory
    memcpy(&ret[index],strRep, strlen(strRep));
    return ret;
}

So ähnlich funktioniert einfügen:
char* myStrReplace(char* str, char* strRep, unsigned int index) {
    char* ret;
    if(str == NULL || strRep == NULL || index > strlen(str)) return NULL;//Fehler abfangen
    ret = (char*)realloc(strdup(str),strlen(str) + strlen(strRep) + 1);
    if(ret == NULL) return NULL //ups, out of memory
    memcpy(&ret[index],strRep, strlen(strRep));
    memcpy(&ret[index + strlen(strRep)], &str[index + 1], strlen(str) + index);
    return ret;
}
```

Hab das jetzt nur mal eben auf die schnelle hingekritzelt um zu demonstrieren wie es aussehen könnte, ob die funktion so wirklich einwandfrei arbeitet, kann ich ohne test nicht sagen, kann sein das n irgendwo bei den kopien zeichen verloren gehen oder so...


```
char* myStrReplace(char* str,const char* strRep, int index){
strcpy(str+index,strRep);
return str;
};
```

also DAS führt bei längeren strings zu 0xC0000005 und das wollen wir ja alle nicht ;-) Des weiteren führt dies zweifellos zu einem Compiler Error.

Ich hab noch nie einen Pointer und ein int addiert ohne Typecast ;-)
wenn dann müsste die zeile eher so aussehen:


```
strcpy(&str[index], strRep);

alternativ:
strcpy((char*)((unsigned long) str + (unsigned) index), strRep);
```


----------



## Thomas Darimont (8. Januar 2004)

Servus!

Vielen vielen Dank für die Lösungansätze!

Nur noch eine Frage sind die Lösungen alle in ANSI C, wenn nein,
wie würde diese Lösung aussehen?

Gruß Tom


----------



## Fabian H (8. Januar 2004)

> _Original geschrieben von chibisuke_
> Ich hab noch nie einen Pointer und ein int addiert ohne Typecast


Ui, was ist dann das?

```
#include <stdio.h>

int main( int argc, char *argv[] )
{
    char *psTmp = "lala, teststring";
    int iMove = 4;
    
    printf( "%s\n", psTmp + iMove );
}
```
Oder das:

```
#include <stdio.h>

void movePointer( char *a_psString, int iMove )
{
    printf( "%s\n", a_psString + iMove );
}

int main( int argc, char *argv[] )
{
    char *psTmp = "lala, teststring";
    
    movePointer( psTmp, 4 );
}
```
Oder das:

```
#include <stdio.h>

void printPointer( char *a_psString )
{
    int i, iLen = strlen( a_psString );
    for ( i=0; i<iLen; a_psString++ ) {
        printf( "%s\n", a_psString );
        i++;
    }
}

int main( int argc, char *argv[] )
{
    char *psTmp = "lala, teststring";
    
    printPointer( psTmp );
}
```


----------



## chibisuke (8. Januar 2004)

Dann haste wohl entweder einen Compiler der Pointer als unsigned long verarbeitet auch ohne typecast...

Anyway, man sollten prinziell nicht pointer direkt bearbeiten, wenn es sich vermeiden läst, denn die Gefahr das ein pointer dann auf nicht "genähmigten" speicher zeigt, ist ziemlich groß.

Die funktionen sind alle samt ANSI-C kompatibel, bedenke aber bei den von mir bezeigten das du den speicher später wieder freigeben musst
(ein free() auf dem zurückgegebenen pointer), sonst gibts speicherlecks.

Die andere funktion, bearbeitet den originalstring, das heißt du musst 1.) dafür sorgen das genug platz ist, 2.) darf der speicher nicht schreibgeschützt sein, (das machen manche compiler mit statischen strings)


----------

