Char Zeiger richtig übergeben



  • Morgen..

    habe folgendes Problem... möchte einen Char Zeiger an eine Funktion übergeben. In der Funktion wird dieser dann befüllt und in der Main soll dann der Inhalt ausgegeben werden. Was mache ich denn noch falsch?

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int test(char *inhalt) {
    	   char buffer[10];
       inhalt= buffer;
       strcpy(inhalt, "testwert");
    }
    
    int main(int argc, char **argv) {
    
    	char *zeiger;
    	test(zeiger);
    	printf("%d\n",zeiger);
    	return EXIT_SUCCESS;
    }
    


  • buffer existiert außerhalb Deiner Funktion nicht mehr, was Du machst, kann augenscheinlich aber sogar funktionieren und dann, wenn Du's am wenigsten erwartest, crashen.
    Also schön brav mit malloc() Speicher belegen, dann den Zeiger drauf an die Funktion übergeben und nach der Verwendung mit free() freigeben - alles klar?



  • wenn ich so schreibe müßte es ja auch gehen oder?

    strcpy(inhalt, "testwert");
    

    soll hier nur mal ein minimalistischen Problem sein. Sonst würde man das schon mit malloc und free machen.



  • Nein, entweder Du richtest buffer in der main ein, dann kannst Du gerne den Zeiger drauf übergeben.
    Aber es macht keinen Sinn
    - den funktionsinternen buffer- Zeiger zu übergeben, weil der Frame (und damit auch buffer) nach Verlassen der Funktion abgerissen wird.
    - mit strcpy auf einen Zeiger zu kopieren, der nicht mit malloc() Speicher zugeteilt bekommen hat. Nur wenn Du Glück hast, kippt die Kiste mit'm Segfault um.

    Was stört Dich daran, einfach ein paar Bytes per malloc() zu holen?



  • selbst wenn du in der funktion test den speicher mit malloc holst, wird es nicht funktionieren, weil char inhalt* eine andere adresse als *char zeiger; hat.
    entweder du übergibst einen zeiger auf einen zeiger als parameter

    int test(char **inhalt)
    {
        char* s = malloc ( ...
        if (s)
        {
    ...
        *inhalt = s;
    

    oder aber du gibst einen zeiger zurück.

    char* test()
    {
    ...
    

    dann gehts mit malloc.



  • Ich weiß ist ein paar Jahre her, aber ich muss mich mit Zeigern momentan auseinander setzen.

    Warum ist der folgende Code den nicht korrekt:

    int test(char *inhalt) {
       strcpy(inhalt, "testwert");
    }
    

    Ich kann mir nicht erklären was daran falsch ist ??

    Danke



  • @SubBurst

    An deinem Code direkt ist nichts fehlerhaft. Der Unterschied zwischen deinem Code und dem Code weiter oben ist, dass oben mit char buffer[10] Speicher auf dem Stack reserviert wird, der abgeräumt wird, sobald die Funktion wieder zurückkehrt. Das bedeutet, dass die aufrufende Funktion dann einen Zeiger bekommt, der mit ein bisschen Glück noch den String hat, aber garantiert ist dies nicht.

    Dein Code hingegen bekommt von der aufrufenden Funktion einen Speicherbereich zugewiesen, in den geschrieben werden soll. Dieser Speicher ist auch noch dann gültig, wenn die aufgerufene Funktion zurückgekehrt ist, denn der Speicher liegt in einem anderen Stackframe (oder vielleicht sogar auf dem Heap, das kann man nicht sagen, weil du nicht angegeben hast, wie der Speicher reserviert wird). Das Einzige, was dir passieren kann, ist dass du in der aufrufenden Funktion nicht genügend Speicher reserviert hast, aber sonst ist da kein Fehler.



  • Oder du zeigst ein Compilierbares minimales Beispiel, das den Fehler enthält.

    Dafür ist es aber nicht nötig einen fünf Jahre alten Thread wiederzubeleben, der so ähnlich ist.

    Ich denke, du rufst deine Funktion mit einem (Zeiger auf ein) Stringliteral auf.


Anmelden zum Antworten