Rückgabe von Zeiger Arrays aus einer Funktion.



  • Hallo liebes Forum,

    ich bin ein absoluter neuling in sachen C Programmierung und benötige einmal eure Hilfe.

    Ich habe ein Programm geschrieben welches einen String einliesst und in eine Funktion schreibt.In dieser Funktion wird der String zerteilt und in einzelne Zeiger Arrays geschrieben.
    Allerdings schaffe ich es nicht diese an die Main zu übergeben.
    Wäre super wenn ihr mir helfen könntet.

    #include<stdio.h>
    #include<string.h>
    #define LEN 60
    
    int teilen(char*input, char*output1, char*output2, char*output3);
    
    int main(void)
    {
    
    char eingabe[LEN];
    char t1;
    char t2;
    char t3;
    
    printf("Bitte geben sie 3. Wörter ein:");
    fgets(eingabe,LEN,stdin);
    eingabe[strlen(eingabe)-1]='\0';
    
    teilen(eingabe,&t1,&t2,&t3);
    
    printf("%s\n",t1);
    printf("%s\n",t2);
    printf("%s\n",t3);
    
    return 0;
    }
    int teilen(char*input, char*output1, char*output2, char*output3)
    {
    
     output1 = strtok(input,"-.,:; ?!");           
     output2 = strtok(NULL,"-.,:; ?!");
     output3 = strtok(NULL,"-.,:; ?!"); 
    }
    

  • Global Moderator

    Da fehlt die Grundlage, wie man überhaupt etwas aus einer Funktion heraus bekommt. Schreib mal eine Funktion, die einen int auf den Wert 5 setzt:

    int i = 123;
    deine_funktion(&i);
    printf("%d", i);  // Das soll 5 ausgeben
    

    Wenn du das schaffst, erkennst du sicherlich einen deiner Fehler. Danach können wir uns darüber unterhalten, was bei Arrays besonderes zu beachten ist.



  • also t1, t2 und t3 sind keine arrays oder dynamisch angelegte speicherbereiche, sondern einfache variablen. wenn du das änderst und dann die zeichenketten hinter den rückgabewerten von strtok nach t1, t2 und t3 kopierst, müsste das eigentlich gehen.



  • Sollte so funktionieren.

    int funktion(int *eingabe)
    {
     *eingabe= 5;
    }
    
    int main(void)
    {
     int i = 123;
     funktion(&i);
     printf("%d",i);
     return 0;
    }
    


  • und wenn du jetzt statt int einen zeiger auf int zurückgeben möchtest, machst du das wie?


  • Global Moderator

    Genau. Wobei ich mich frage, warum das bei dir int funktion(int *eingabe) ist und nicht void funktion(int *eingabe) . Was hast du dir dabei gedacht?

    Zurück zu deinem Problem:
    Erster Schritt: Fällt dir bei *eingabe = ...; was auf, das anders ist als bei output1 = ...; ? Falls ja, dann mach das in deiner Funktion aus dem Eingangsbeitrag doch auch mal so.

    Zweiter Schritt: Nun möchtest du halt keine int s aus der Funktion zurück geben, sondern char* . Erstmal nehmen wir dein Testprogramm (mit meiner obigen Anmerkung bezüglich void):

    void funktion(int *eingabe)
    {
     *eingabe= 5;
    }
    
    int main(void)
    {
     int i = 123;
     funktion(&i);
     printf("%d",i);
     return 0;
    }
    

    Und jetzt ersetzen wir alle der beteiligten int durch char* (und die Integerliterale durch Zeichenketten, damit es auch funktioniert):

    void funktion(char* *eingabe)
    {
     *eingabe= "Welt";
    }
    
    int main(void)
    {
     char* i = "Hallo";
     funktion(&i);
     printf("%s",i);
     return 0;
    }
    

    Funktioniert, oder? Das ist das Muster, nach dem du deine Funktion schreiben kannst. Da braucht man auch keine Angst vor vielen * zu haben. char* ist ein ganz normaler Typ wie int auch. Entsprechend kann man natürlich auch Zeiger auf char* haben. Kein Problem.



  • Leider ist es genau das worauf ich nicht komme.
    Vielleicht habe ich auch einfach nur einen Denkfehler



  • Vielen Dank SeppJ

    Das macht es schon wesentlich verständlicher.
    Mit dem Thema Zeiger habe ich mich auch relativ schwer getan.
    Ich Probiere das ganze nochmal umzusetzen und melde mich dann nochmal.



  • Die Pointe dabei: statt 3 mal auf Pointer zu pointen geht auch eine Monstervariable mit 3*char drinne.

    #include <stdio.h>
    
    struct monster
    {
        char* a;
        char* b;
        char* c;
    };
    
    struct monster gimmmThatMonster()
    {
        struct monster m;
        m.a = "Hello";
        m.b = "Monster";
        m.c = "World";
        return m;
    }
    
    int main ()
    {
        struct monster m = gimmmThatMonster();
        printf ("%s %s %s\n", m.a, m.b, m.c);
    }
    


  • Hallo,

    ich habe hierzu mal ne Frage:
    ich habe die Funktion so geändert:

    void funktion(char* *eingabe)
    {
     *eingabe= "Das ist ein String, der viel laenger als vorher ist";
    }
    

    In Main habe ich den String auf "Hallo" gelassen.
    Meine Frage ist nun, wieso kann ein viel längerer String gespeichert werden, ohne Speicher zu holen???

    Habe mit C schon einiges gemacht, aber o gut wie nie Strings 😞

    Vielen Dank für eure Antworten.



  • HerrRatlose schrieb:

    Hallo,

    ich habe hierzu mal ne Frage:
    ich habe die Funktion so geändert:

    void funktion(char* *eingabe)
    {
     *eingabe= "Das ist ein String, der viel laenger als vorher ist";
    }
    

    In Main habe ich den String auf "Hallo" gelassen.
    Meine Frage ist nun, wieso kann ein viel längerer String gespeichert werden, ohne Speicher zu holen???

    Habe mit C schon einiges gemacht, aber o gut wie nie Strings 😞

    Vielen Dank für eure Antworten.

    String-Literale werden schon beim Build-Vorgang ins Binary integriert. Wenn du einen Pointer darauf pointen lässt, wird kein zusätzlicher Speicherplatz benötigt. Sie sind quasi immer da, auch wenn sie nicht mehr referenziert werden. Lade deine Exe mit einem Hex-Editor und schau es dir an.