C - Pointer auf Speicher übergeben und manipulieren

C - Pointer auf Speicher übergeben und manipulieren (24 Beiträge, 327 Mal gelesen)

Du bist nicht angemeldet. [ Login/Registrieren ]

Ich hab wieder ein kleines, diesmal mehr kosmetisches Problem. (Workarround funktioniert, würde aber trotzdem wissen ob/wie das funktioniert)

also, hier mein (nicht) funktionierender code:


#include 
#include 
int mach5platz(int * pPlatz);
int mach5platz(int * pPlatz)
{
  int * test;
    test = malloc( sizeof(int) *5);
    *(test) = 999;
  //  pPlatz = test;  //<- funktioniert nicht
   *pPlatz = (int)test;
    return 0;
}
int main()
{
    int * pInt = NULL;
    int addr = 0;
    mach5platz(&addr);
    pInt = (int*) addr;
    printf("%d",*pInt);
    return 0;
}

So wie ich es machen möchte, klappts leider nicht.
Sondern nur über den Umweg wie oben gezeigt.
Und ich verstehe irgendwie nicht warum das nicht so funktioniert

Was soll in pPlatz dann schlussendlich sein?
Momentan ists ja die Adresse des Pointers -> *pPlatz = (int)test;
pPlatz = test; => wäre ja eig die Adresse von pPlatz auf die von test zu setzen.

Ja klar, das sollte ich natürlich auch hinschreiben!

Ich will in der funktion Platz "machen"
in meiner "richtigen" Funktion wird darin eine datei geöffnet und in den "gemallocten" Platz geladen.

Leider klappt das nur so, wie von mir gelöst (unschön und umständlich!)
und nicht so wie im kommentar(und ohne nachträglichen typecast+kopie)

pPlatz = test; => wäre ja eig die Adresse von pPlatz auf die von test zu setzen.

Da hast du auch wieder recht!

Ich will ja eigentlich folgendes machen:
in der funktion platz machen und auf den ptr den ich mitübergebe "schreiben"


int mach5platz(int * pPlatz)
{
    pPlatz = malloc( sizeof(int) *5);
    *(pPlatz+0) = 999;
    return 0;
}
int main()
{
    int * pInt = NULL;
    mach5platz(pInt);
    printf("%d", *pInt);
    return 0;
}

nur das geht ja leider gaaar nicht

12.11.2008, 22:14 Uhr - Editiert von RoHS, alte Version: hier

Ja weil du

1) nicht NULL initialsieren musst
2) es keine Var "test" gibt...

Dieser Beitrag bezieht sich auf eine ältere Version des beantworteten Postings!

das ist noch ein fehler drinnen ich editiere es gleich

Ach wieder mal

Da ist aber viel falsch/komisch:

int main()
{
    int * pInt = NULL;         // gut ein ptr auf 0
    int addr = 0;              // ein integer mit 0 initialisiert
    mach5platz(&addr);         // die Adresse des int word übergeben
    pInt = (int*) addr;        // DANGER!: int* ist nicht immer
                               // gleich groß wie int! (zb 64Bit Os)
                               // Also Inhalt eines Int als Adresse zu
                               // verwenden ist eine Todsünde
    printf("%d",*pInt);        // gib den Wert aus auf den pInt zeigt

    return 0;
}

int mach5platz(int * pPlatz)   // <- pPlatz ist Addresse auf addr von oben
{
    int * test;                // ein uninitialisierter ptr
    test = malloc( sizeof(int) *5);  // ok ein int array mit Größe 5
    *(test) = 999;             // ok in index 0 schreiben wir 999
  //  pPlatz = test;           // naja der compiler frisst es schon

// du biegst den ptr pPlatz auf eine neue Adresse. Der hat halt vorher
// auf addr gezeigt, und nun zeigt er auf test. addr veränderst du damit
// nicht!

   *pPlatz = (int)test;        // jetzt schreibst du in addr rein. also die
                               // Adresse von test als wert int addr

    return 0;
}

Richtige Lösung im nächsten Post...
--
Gibts noch Leute, die die Signatur nicht blocken?
C++, Mono, C#, Java, XML, Open Source developer
Ubuntu - Linux for Human Beings

das ist ja auch das hatschere workarround

int main()
{
    int* addr  = NULL;         //

    mach5platz(&addr);          // Adresse auf ptr übergeben

    printf("%d",*addr);        // gib den Wert addr[0] aus auf den addr zeigt

    return 0;
}

int mach5platz(int ** pPlatz)   // <- pPlatz pointer auf pointer
{
    int * test;                // ein uninitialisierter ptr
    test = malloc( sizeof(int) *5);  // ok ein int array mit Größe 5
    *(test) = 999;             // ok in index 0 schreiben wir 999

    *pPlatz = test;
    return 0;
}

Doppelpointer machen doch Spass!

--
Gibts noch Leute, die die Signatur nicht blocken?
C++, Mono, C#, Java, XML, Open Source developer
Ubuntu - Linux for Human Beings

12.11.2008, 22:15 Uhr - Editiert von Switi, alte Version: hier

Muss es denn ein Doppelpointer sein, sollte doch so auch gehen AFAIK, oder?

Nein muss sein.

Weil du in der Funktion sonst nie den Original Pointer in main änderst, sonder nur die Kopie die die Funktion als Argument bekommt.

Info: Alle Argumente in C werden ja immer über den Stack kopiert.

--
Gibts noch Leute, die die Signatur nicht blocken?
C++, Mono, C#, Java, XML, Open Source developer
Ubuntu - Linux for Human Beings

aso...

also wenn ich einen pointer übergebe, dann bekommt meine funktion eine lokale kopie des pointers - arbeitet aber mit den orginaldaten.
aber auf den originalpointer hat die funktion nachtürlich keinen zugriff.
und mit dem doppelpointer klappts dann

jop da hat er wohl recht (auch wenn ichs jetzt nicht ausprobieren kann

)

was schon funktioniert, ist den wert an dieser adresse zu ändern. die adresse selbst nicht, stimmt wohl.

Funktioniert!

Ajo nochmal vielen Dank für deine Hilfe vom letzten mal!

No Problem

--
Gibts noch Leute, die die Signatur nicht blocken?
C++, Mono, C#, Java, XML, Open Source developer
Ubuntu - Linux for Human Beings

Das mit den Doppelpointern ist echt heftig.

Leider habe ich noch keine Literatur gefunden in der das gut erklärt wird

Da hilft keine Literatur. Das musst einfach checken.

Probieren wir es mal halbwechs grafisch

Ein Pointer:

int* foo;
foo---------->Int_im_Memory

So bei einem Funktionsaufruf schaut das dann so aus

mach5Platz(int* bar);

foo---------->Int_im_Memory
bar--------------^ zeigt auf den gleichen Speicherbereich

--
Gibts noch Leute, die die Signatur nicht blocken?
C++, Mono, C#, Java, XML, Open Source developer
Ubuntu - Linux for Human Beings

Und wenn mach5Platz aber halt foo direkt modifizieren will, brauchst halt dann sowas:

bar------>foo------>Int_im_Memory

und voila: Das ist ein Doppelpointer
--
Gibts noch Leute, die die Signatur nicht blocken?
C++, Mono, C#, Java, XML, Open Source developer
Ubuntu - Linux for Human Beings

siehe: http://forum.geizhals.at/t604953,5134518.html#5134518

http://www.win-tux.de/c_014_008.htm#RxxobKap014008040028C21F04A18C

Hi !

Wenn ich mich hier nicht verlesen habe, vergewaltigst du C brutalst...

Nur mal schnell:

- Typischerweise hast oben die Deklarationen, dann main und dann die Funktionen (ja, ist Kosmetik)
- Ist es absicht, daß mach5platz nicht static ist ?
- Du machst ein malloc auf einen Pointer in der Länge von 5 ints - und weist es einem einzelnen int zu. Eher untypisch. Typischer wäre es, die einem Array zuzuweisen - oder einem Array of int*
- Du vermanscht Typen brutal und castest wildestens

int * pPlatz in der Funktionsdeklaration ist ein Pointer auf int.
Bei Aufruf übergibst einen Pointer auf int - eben den Pointer auf addr. Paßt
In der Funktion schreibst du in *pPlatz (also in addr) nun keinen Int - sondern einen Pointer auf ein Int(!) - der eben auf ein Int zeigt, das 5 enthält (am Heap)

Ist das so gedacht ?

Oder wolltest nicht eher

int mach5platz(int **pPlatz)
{
        *pPlatz = malloc(sizeof(int)*5);
        **pPlatz = 12;
        return 0;
}

int main()
{
        int * pInt;
        int *addr;

        mach5platz(&addr);
        printf ("%d\n", *addr);
        exit(0);
}

Fehlerbehandlung, free(), ... nicht vergessen

int *mach5platz() // funktion gibt Zeiger auf Integer zurück
{
  int *buf = malloc(...);  // anlegen
  *buf = 12; // ersten Integer beschreiben
  return buf;
}

int main()
{
  int *addr;

  addr = mach5platz();
  printf ("%d\n", *addr);
  exit(0);
}

Dieses Forum ist eine frei zugängliche Diskussionsplattform.
Der Betreiber übernimmt keine Verantwortung für den Inhalt der Beiträge und behält sich das Recht vor, Beiträge mit rechtswidrigem oder anstößigem Inhalt zu löschen.
Datenschutzerklärung