Rückgabezeichen[]/string aus einer Funktion [duplicate]

Ich bin ziemlich neu in der Programmierung in C und versuche derzeit, eine Funktion zu erstellen, die ein String-/Char-Array zurückgibt und einer Variablen zuweist.

Bisher habe ich beobachtet, dass die Rückgabe eines char * die häufigste Lösung ist. Also habe ich versucht:

char* createStr() {
    char char1= 'm';
    char char2= 'y';
    char str[3];
    str[0] = char1;
    str[1] = char2;
    str[2] = '\0';
    char* cp = str;
    return cp;
}

Meine Frage ist, wie ich diese Rückgabe verwende char* und weisen Sie das char-Array, auf das es zeigt, einem char zu[] Variable?

Ich habe es versucht (alle führten zu Noob-Drowning-Fehlern):

1. char* charP = createStr();
2. char myStr[3] = &createStr();
3. char* charP = *createStr();

Beachten Sie, dass Sie die Variable nicht dynamisch zuweisen, was so ziemlich die darin enthaltenen Daten bedeutet strin Ihrer Funktion, gehen am Ende der Funktion verloren.

Du solltest haben:

char * createStr() {

    char char1= 'm';
    char char2= 'y';

    char *str = malloc(3);
    str[0] = char1;
    str[1] = char2;
    str[2] = '\0';

    return str;

}

Wenn Sie dann die Funktion aufrufen, muss der Typ der Variablen, die die Daten empfängt, mit dem der Funktionsrückgabe übereinstimmen. Sie sollten also haben:

char *returned_str = createStr();

Es ist erwähnenswert, dass der zurückgegebene Wert freigegeben werden muss, um Speicherlecks zu vermeiden.

char *returned_str = createStr();

//doSomething
...

free(returned_str);

Wenn Sie a zurückgeben möchten char* von einer Funktion, stellen Sie sicher, dass Sie malloc() es. Stack-initialisierte Zeichenarrays machen bei der Rückgabe keinen Sinn, da der Zugriff auf sie nach der Rückkehr von dieser Funktion ein undefiniertes Verhalten ist.

ändern Sie es zu

char* createStr() {
    char char1= 'm';
    char char2= 'y';
    char *str = malloc(3 * sizeof(char));
    if(str == NULL) return NULL;
    str[0] = char1;
    str[1] = char2;
    str[2] = '\0';
    return str;
}

Sie können ein statisches Array in Ihrer Methode verwenden, um den Verlust Ihres Arrays zu vermeiden, wenn Ihre Funktion endet:

char * createStr() 
{
    char char1= 'm';
    char char2= 'y';

    static char str[3];  
    str[0] = char1;
    str[1] = char2;
    str[2] = '\0';

    return str;
}

Bearbeiten: Wie Toby Speight erwähnte, ist dieser Ansatz nicht Thread-sicher, und auch das Aufrufen der Funktion führt zu einem Überschreiben von Daten, das in einigen Anwendungen unerwünscht ist. Sie müssen also die Daten in einem Puffer speichern, sobald Sie von der Funktion zurückkehren. (Da es sich jedoch nicht um eine Thread-sichere Methode handelt, können gleichzeitige Aufrufe in einigen Fällen immer noch Probleme verursachen, und um dies zu verhindern, müssen Sie die Sperre verwenden. Erfassen Sie sie beim Aufrufen der Funktion und geben Sie sie nach dem Kopieren frei. Ich ziehe es vor, dies nicht zu verwenden Ansatz, weil es chaotisch und fehleranfällig ist.)

char* charP = createStr();

Wäre richtig, wenn Ihre Funktion richtig wäre. Leider geben Sie einen Zeiger auf eine lokale Variable in der Funktion zurück, was bedeutet, dass es sich um einen Zeiger auf undefinierte Daten handelt, sobald die Funktion zurückkehrt. Sie müssen eine Heap-Zuweisung wie malloc für die Zeichenfolge in Ihrer Funktion verwenden, damit der zurückgegebene Zeiger eine Bedeutung hat. Dann müssen Sie daran denken, es später freizugeben.

Das Einfügen von “string.h” macht die Sache einfacher. Eine einfachere Möglichkeit, Ihr Problem anzugehen, ist:

#include <string.h>
    char* createStr(){
    static char str[20] = "my";
    return str;
}
int main(){
    char a[20];
    strcpy(a,createStr()); //this will copy the returned value of createStr() into a[]
    printf("%s",a);
    return 0;
}