Umwandeln

Hey Leutz,
ich habe ein Programm geschrieben, in dem ich anfangs schreibe:

char in[10000];
char *p =NULL;
p=funktionsname(in);

Ich übergebe also 'in' und habe in der Funktion auch den Returnwert 'in'. Im weiteren Verlauf möchte ich dann mit dem neuen 'in' weiter arbeiten. Und nun meine Frage:
Wie bekomme ich das was nach dem Funktionsaufruf in 'p' drin steht in 'in' hinein. Einfach schreiben in=p scheint ja nicht zu funktionieren.

CMatt

memcpy(in,p,sizeof(char)*10000);

So funktioniert es leider nicht. Wenn ich die funktion nicht aufrufe geht es mit dem normalen in, nachdem ich diese funktion aufrufe und auch memcpy nutze, stürzt das Programm mit dem neuen in ab...

CMatt

kann ich die funktion mal sehen?

char* ersetzen(char *such, char *neu, char *inp) 
{ 
    int len_re = 0; 
    int len_repl = 0; 
    int len_in = 0; 
    int len_new = 0; 
    char new_string[100] = {0}; 
    char *pdest; 
    int pos = 0; 

    len_re = strlen(such); 
    len_repl = strlen(neu); 

    if(len_re) 
    { 
        pdest = strstr(inp, such);    
        while(pdest) 
        { 
            memset(new_string, 0, strlen(new_string));    
            pos = pdest - inp + 1;    
            len_in = strlen(inp);    

            if(pos == 1) 
            { 
                strcpy(new_string, neu);    
                inp = inp + len_re;            
                strcat(new_string, inp);    
                inp = inp - len_re;            
            } 
            else    
            { 
                strncpy(new_string, inp, pos - 1);    
                strcat(new_string, neu);            

                if(pos + len_re - 1 != len_in) 
                { 
                    inp = inp + pos + len_re - 1;    
                    strcat(new_string, inp);        
                    inp = inp - pos - len_re + 1;    
                } 
            } 

            len_new = len_in - len_re + len_repl; 

            inp = (char*)malloc(len_new);    
            memset(inp, 0, sizeof(len_new));    
            strcpy(inp, new_string);            

            pdest = strstr(inp, such);        
        } 
    } 
    return inp;    
}

Hoffe du findest einen Fehler...

CMatt

1. da klafft ein dickes fettes memory leak mitten in deine code

inp = (char*)malloc(len_new);

Was ist wenn er das 2. mal da vorbei kommt? Du überschreibst dir den zeige und kannst kein free mehr aufrufen ( was du eh nicht machst). Immer vor dem malloc ein free aufrufen geht bei dir auch net, da inp im ersten durchlauf ja ein pointer auf nen stack-speicherblock ist (char in[10000]) --> Verwende ne eigene variable für den return Wert, initialisiere sie mit NULL und sollte sie vor dem malloc nicht 0 sein, mach ein free

2. du bekommst jetzt nen neuen speicherblock der mit malloc allokiert wurde. Sobald er nicht mehr benötig wird muss auch hier ein free eufgerufen werden (sehe nicht ob du das schon machst, aber nur zu errinerung)

3. Ändere die funktion mal in char* ersetzen(const char *such,const char *neu,const char *inp). Wenn du gleich auf die const's geachtet hättest, wär fehler 1 ger nicht erst passiert

char new_string[100]

was ist wenn dein input string länger als 100 zeichen ist?

5. da es sich um stings handelt, kannst ein strcpy(in,p) verwenden, das sollte dann nicht mehr abstürzen (das memcpy stürzte ab, da ein p ja nicht gleich lang ist die ein in, wird ja neu allokiert)

Uff ,
das sind ja gleich fünf Sachen auf einmal... und was kann ich am einfachsten, schnellsten machen dass es läuft? Sollte ich alle von dir angesprochenen Sachen ändern???

@CMatt: Kannst du mir evtl. mal eine überarbeitete Variante posten???

AJ

Das ganze kommt mir irgendwie bekannt vor: http://www.c-plusplus.net/forum/viewtopic.php?t=71837

Ja, (ich arbeite am selben Problem,) kann mir trotzdem jemand helfen???
Es muss doch eine einfache Lösung dafür geben...
char in[] = ????? (hier muss das p irgendwie umkonvertiert werden, Danke...)