Pointerübertragung wird nicht realisiert

[Anfänger (Gast)]

Hallo,

ich möchte eine Datenübertragung mit einem Pointer von Funktion A nach 
Funktion b realisieren - leider geht das schief :-(

Erzeuger:

uint8_t Fifo::Get(uint16_t *element) {
  if (read == write)
    {
        printf ("\n\r in get_false");
        return false;
    }
  printf ("\n\r Get: %d", *(buffer_ptr+(sizeof(uint16_t)*read)) );
  *element = *(buffer_ptr+(sizeof(uint16_t)*read));
  printf ("\n\r element in get: %d", *element);
  read = (read+1) & buffer_mask;
  return true;
}

Bekommer:

int main() {
    
    uint16_t counter;
    uint16_t *elem;

    
    printf ("\n\r Test ");
    
    for (counter=0; counter<10; counter++)
    {
     myfifo1.Put(counter);
     printf ("\n\r %d", counter);      
    }
    
    printf ("\n\n\r Anz. Elemente in fifo: %d", myfifo1.Anzahl() );
    
    for (counter=0; counter<5; counter++)
    {
        myfifo1.Get(elem);
        printf ("\n\r %d", *elem );
        printf ("\n\n\r Anz. Elemente in fifo: %d", myfifo1.Anzahl() );
    }
}

Dieser Bekommer mit *elem in "printf ("\n\r %d", *elem );" liefert Müll 
- ich verstehe nicht, warum das so ist.

Mach ich das so:

int main() {
    
    uint16_t counter;
    uint16_t elem;

    
    printf ("\n\r Test ");
    
    for (counter=0; counter<10; counter++)
    {
     myfifo1.Put(counter);
     printf ("\n\r %d", counter);      
    }
    
    printf ("\n\n\r Anz. Elemente in fifo: %d", myfifo1.Anzahl() );
    
    for (counter=0; counter<5; counter++)
    {
        myfifo1.Get(&elem);
        printf ("\n\r %d", elem );
        printf ("\n\n\r Anz. Elemente in fifo: %d", myfifo1.Anzahl() );
    }
}

dann klappt es auf einmal - aber ich kapiere nicht, warum das so ist.

Das hier müsste doch eigentlich das gleiche sein:

int var;
int *var_ptr;

var = 10;
*var_ptr = 10;

var_ptr = &var;
var = *var_ptr;

Wo ist mein Denkfehler? Die Funktion Get benötigt einen Pointer, weil 
das Herauslesenergebnis aus dem Fifo an der Pointerspeicherstelle 
aufbewahrt werden soll. Wenn ich nun in der Mainfunktion einen Pointer 
dahin übergebe, der dann die Speicherstelle definiert, dann müsste doch 
der Wert an diese Speicherstelle geschrieben werden. Und mit *var_ptr 
bzw. in der Mainfunktion *elem greife ich doch dann auf den Inhalt der 
Speicherstelle zu. Genauso mache ich es ja bei der Übergabe, wo ich in 
der Mainfunktionsvariante 2 reinschreibe:

myfifo1.Get(&elem), dass vorher wie var nicht als Pointer definiert 
wurde.

Ich hab da irgendwo einen Denkfehler bzw. etwas mit den Pointern noch 
nicht kapiert, komme da aber nicht drauf, was es sein könnte.

[gonso (Gast)]

Ich empfehle Dir, erstmal C-Grundlagen zu lernen, bevor Du Dich mit so 
komplexen Dingen befasst. Dir fehlt elementares Grundwissen, dass wir 
Dir hier nicht liefern können.

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Pointer immer initialisieren. Wahrscheinlich soll der auf counter 
zeigen:

    uint16_t *elem = &counter;

[Anfänger (Gast)]

Torsten Robitzki schrieb:
> Pointer immer initialisieren. Wahrscheinlich soll der auf counter
> zeigen:
>     uint16_t *elem = &counter;

Was meinst Du mit Initialisieren - einen Wert zuweisen - oder eine 
Variable zuweisen?

Würde das hier nicht klappen?

int *number;
*number = 10;

[Karl H. (kbuchegg)]

Anfänger schrieb:
> Torsten Robitzki schrieb:
>> Pointer immer initialisieren. Wahrscheinlich soll der auf counter
>> zeigen:
>>     uint16_t *elem = &counter;
>
> Was meinst Du mit Initialisieren - einen Wert zuweisen - oder eine
> Variable zuweisen?
>
> Würde das hier nicht klappen?
>
> int *number;
> *number = 10;

Nein das wuerde nicht klappen.
Nur weil du einen Pointer hast, hast du noch lange nicht den Speicher, 
in dem du den int speichern koenntest.

[Mitlesa (Gast)]

Anfänger schrieb:
> Würde das hier nicht klappen?
>
> int *number;
> *number = 10;

Nur sehr vielleicht.

Dein Pointer muss irgendwo hinzeigen.
Das tut er (noch) nicht.

Erst wenn du schreibst:

number = &irgendwas_auf_was_du_zeigenwillst;

[Karl H. (kbuchegg)]

Und gonso hat recht. Du bist an einem Punkt angelangt, an dem man nicht 
mehr einfach so rummachen kann.

Das hier

printf ("\n\r Get: %d", *(buffer_ptr+(sizeof(uint16_t)*read)) );

ist das deutlichste Zeichen, dass dir viele Grundlagen fehlen. Das ist 
grundlegend falsch.

Machs dir wenigstens nicht so kompliziert. Du kannst hier ruhig Array 
Syntax benutzen (und auch an allen anderen Stellen)

  printf ("\n\r Get: %d", buffer_ptr[read] );

Warum das funktioniert - tja. Genau das wären die fehlenden Grundlagen.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:
> Anfänger schrieb:
>> Torsten Robitzki schrieb:
>>> Pointer immer initialisieren. Wahrscheinlich soll der auf counter
>>> zeigen:
>>>     uint16_t *elem = &counter;
>>
>> Was meinst Du mit Initialisieren - einen Wert zuweisen - oder eine
>> Variable zuweisen?
>>
>> Würde das hier nicht klappen?
>>
>> int *number;
>> *number = 10;
>
> Nein das wuerde nicht klappen.
> Nur weil du einen Pointer hast, hast du noch lange nicht den Speicher,
> in dem du den int speichern koenntest.

Ein Pointer ist das PostIt an deiner Pinwand, auf dem steht: Der Brief 
liegt im Postkasten Nummer 4.

Du hast bis jetzt nur das PostIt. Du hast aber noch nicht den Postkasten 
und dessen Nummer aufs PostIt geschrieben.