C kopieren char * zu char[]

Hallo, ich bin versucht zu kopieren char * Zeiger auf ein char [] - array.

dies ist mein code bisher

char * string_add(char * base, char * toAdd)
{
    char * string=malloc(strlen(base)+streln(toAdd)+1);
    sprintf(string,"%s%s",base,toAdd);
    char returnString[strlen(string)+1]; 
    //here comes my problem:
    memcpy(returnString,string,strlen(string)+1);
    //want to add free(string) here
    return returnString;
}

Möchte ich so eine Funktion zum speichern von code. Ich möchte nicht, sich nach jedem allozierten Speicher. Ich habe auch versucht

memcpy(&returnString,string,strlen(string)+1);

sowie einige Varianten mit strcpy und strncpy. Aber Folgendes problem besteht:

wenn rufe ich die Funktion zweimal wie:

int main(int argc, char * argv[])
{
    char * str1=string_add(argv[1],"-test1"); 
    char * str2=string_add(argv[1],"-test2"); 
    printf("%s, %s", str1,str2);
}

die Ausgabe wie:

abc-test2, abc-test2

Wie kann ich dies erkennen?

Vielen Dank im Voraus!

Die Sie zurückgeben der Adresse von einem automatischen Variablen returnString. Müssen Sie sich nicht mehr als die string Puffer. Setzen Sie einfach string[strlen(base) + strlen(toAdd)] = 0 (oder verwenden Sie den Rückgabewert von sprintf zu wissen, wie lange string ist, oder speichern Sie strlen(base) + strlen(toAdd) bevor Sie malloc) und return string.
aber wenn ich return string ich frei später das Ergebnis. Dies ist, was ich vermeiden möchte.
man kann nicht wirklich vermeiden. wenn du die Möglichkeit hast von C++, dann können Sie mit smart Pointern, aber in C ist, müssen Sie entweder preallocate, oder verwalten Sie Ihre malloced Speicher
auch wenn Sie nicht return string haben Sie immer noch, Sie zu befreien. So wie es jetzt ist, Ihren code ein Speicherleck hat.

InformationsquelleAutor SevenOfNine | 2013-08-18

2

in C, müssen Sie sich nach der malloced Speicher, das char-array erklären Sie ist auf dem Stapel, und verschwunden sein, nachdem die Funktion, nur das malloc Speicher rumhängen. und ja, Sie werden um ihn zu kümmern und ihn zu säubern.
- ja, aber ich versuche zu erstellen, diese Funktion, so dass ich don ' T haben, sich nach jedem string den ich erschaffe. Ich will ihn gerne: Rufen Sie das und Holen Sie sich ein array[] mit alles aufgeräumt ist schon
- Sie können nicht tun, was Sie wollen, sehr leicht ( und möglicherweise überhaupt nicht abhängig von der Anwendung ). Ihr Problem ist, dass ein char[] nur live im Rahmen der Funktion (es sei denn, seine Globale).
- ist es schlechter Stil, um eine var global, wenn ich es brauche in jeder Funktion?
- ja, sehr schlecht, und hindert, die Dinge wie multi-threading
InformationsquelleAutor Keith Nicholas
0

Ich gehe davon aus, dass der zweite Aufruf der Funktion überschreibt den Inhalt der Zwischenablage erstellt, indem der erste Anruf.

Meinem Verständnis, Sie versuchen, Sie zu verketten von zwei Zeichenketten.

Einen Blick in diese Antwort.

Grundsätzlich, da die Länge der strings ist nicht bekannt, zur compile-Zeit, Sie müssen zum zuweisen dynamischer Speicher, während nicht zu vergessen, um free es, nachdem Sie fertig sind der Handhabung der neuen string.
- Ich mache das, aber ich das ist nicht mein Ziel.
InformationsquelleAutor Novak

Grundsätzlich Speicher, der NICHT malloc'ed NICHT bestehen nach einer routine enden. Sie können möglicherweise verwenden Sie die globalen vars, aber das würde complexify eine einfache Aufgabe, d.h. zwei strings verketten.

char * string_add(char * base, char * toAdd)
{
    char *string_ptr = malloc(strlen(base)+streln(toAdd)+1);

    sprintf(string_ptr, "%s%s", base, toAdd);

    //string_ptr points to heap storage that is permanent
    return string_ptr;
}

//in main() ....

char *s1 = string_add("A", "B");
//s1 points to storage on the heap as: "AB\0"
//
free(s1);  //OR allow system to clean-up when main() exits

InformationsquelleAutor JackCColeman

0

In der Funktion
```
char * string_add(char * base, char * toAdd)
{
    char * string=malloc(strlen(base)+streln(toAdd)+1);
    sprintf(string,"%s%s",base,toAdd);
    char returnString[strlen(string)+1]; 
    //here comes my problem:
    memcpy(returnString,string,strlen(string)+1);
    //want to add free(string) here
    return returnString;
}
```
Definieren Sie returnString[] aber es lebt nur in dem Gültigkeitsbereich der Funktion. So ändern Sie die Logik hinter dem Gebrauch und der Erklärung der returnString[]
- ja, ich Stimme zu. Wenn ich dies Tue, zum Beispiel char * test="blabla" ich nicht nennen free(test) ich zurückkehren will einen char, die ich nicht haben, zum kostenlosen!
InformationsquelleAutor Oscerd
0

Also gibt es etwas falsch mit dem code. First off Sie tun:
```
char * string=malloc(strlen(base)+streln(toAdd)+1);
```
falsch ist, geht davon aus, dass jeder char ist 1 byte, die es hängt von der Plattform ab. Was ist besser zu tun ist:
```
char * string=malloc((strlen(base)+streln(toAdd)+1) * sizeof(char));
```
plus malloc wird teuer in Bezug auf CPU-Zeit und Sie nicht befreien. Tun, was Sie tun in diesem code muss nicht die malloc selbst. Nur dazu:
```
char returnString[strlen(base) + strlen(toAdd) + 1];
```
Sekunde alle, sollten Sie deal mit den strings anders. Was Sie tun können ist dieses:
```
strcpy(returnString,base);
strcat(returnString,toAdd);
```
oder. Das beste, was zu tun, für so etwas ist, deklarieren Sie in der main-str1 und str2, malloc Ihnen in main, übergeben Sie den Zeiger auf den Zeiger auf die Funktion. Die Funktion kopieren/Katze die Daten wie ich oben zeigte. und dann auf fertig stellen. Jetzt brauchen Sie nicht, um befassen sich mit Rückkehr-Typen und alle, die innere mallocing und Mist wie, dass. Sie nur den Umgang mit zwei mallocs in Haupt-und 2 freien ist im wesentlichen, nachdem Sie Sie verwenden. Hier ist der pseudo-code:
```
int main(int argc, char *argv[])
{
    char * str1 = (char *) malloc((sizeof(argv[1]) + sizeof("-test1")) * sizeof(char));
    //do same for str2
    copyString(&str1,argv[1],"-test1");
    //do same for str2
    //print
    //free like this:
    free(str1);
    //do same for str2
    return 0;
}
```
nun, hier ist die copyString Funktion:
```
void copyString(char ** returned, char * base, char * add)
{
    strcpy(returned,base);
    strcat(returned,add);
} 
```
- char ist definiert als 1-byte-Breite von der Norm, aber selbst wenn es nicht sizeof definiert sich der char, byte Breite. sizeof(char) ist garantiert 1.
- Ja, es wird immer 1 sein, aber es ist eine gute übung, in die Gewohnheit, dies zu tun. Da auf verschiedenen Systemen sizeof(int) oder sizeof(double) für Beispiel abweichen. Es macht auch den code besser lesbar.
InformationsquelleAutor Ion

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.