4. Ich vertsehe die Zeiger nicht, Hilfe...

Ich vertsehe die Zeiger nicht, Hilfe...

  • S

    Hallo Zusammen,
    man liest ja immer wieder man soll um ein Array zurückgeben zu können einen Zeiger benutzen. Es will einfach nicht funktionieren...

    unsigned int *Checksum(int Telegrammlange, byte *Telegrammdaten){
   for(i = 0; i < Telegrammlange-3; i++) 
   crc = crc_calc(crc, Telegrammdaten[i]);

 array[0]=crc & 0x00FF; // Low-Byte 
 array[1]=(crc & 0xFF00) >> 8;// High-Byte
 return &array;
}

    und den Aufruf hab ich so versucht

    CRC_LOW = *Checksum(length,(byte*)&ResBlock);
CRC_LOW = *(Checksum(length,(byte*)&ResBlock)++);

    Ich denke da ist einiges falsch

    zudem kann ich das array nicht so initialisieren wie ich gern will!

    word array[];
/*wollte es so machen*/
 array[]={crc & 0x00FF,(crc & 0xFF00) >> 8};
/*geht aber nur so*/
 array[0]=crc & 0x00FF; // Low-Byte 
 array[1]=(crc & 0xFF00) >> 8;// High-Byte

    wäre super wenn mir jemand helfen könnte

    Gruß Carsten

    0
  • C

    Du kannst ein Array als Pointer weiterverarbeiten. Und du kannst auch Pointer mit dem Index-Operator [] ansprechen. ABER du kannst einen Pointer nicht zurückverwandeln in ein Array.
    (wäre also nicht schlecht, etwas zusammenhängenderen Code zu sehen, um dein Problem einzuschränken)

    PS: Die Initialisierungsliste ("word array[]={...};") kannst du nur beim Anlegen der Variablen verwenden, nicht für spätere Zuweisungen.

    0
  • S

    Danke dir zuächst
    ich versuche mich besser zu erklären.
    Was ich vor habe ist ein Array oder besser dessen Komponenten aus einer Fkt raus zurückzugeben und am anderen Ende diese Werte auf verschiedene Variablen aufzuteilen.
    Sprich ich habe in diesem Fall Low Byte und High Byte

    word crc; //word = unsigned int
byte array[];// byte = unsigned char
unsigned int *Checksum(int Telegrammlange, byte *Telegrammdaten){
   for(i = 0; i < Telegrammlange-3; i++) 
   crc = crc_calc(crc, Telegrammdaten[i]);

 array[0]=crc & 0x00FF; // Low-Byte 
 array[1]=(crc & 0xFF00) >> 8;// High-Byte
 return &array;
}

    nun habe ich es in ein Array von byte geschrieben..
    was meiner Meinung nach nicht zu schwierigkeiten führt?(wegen cast von word to byte)
    und nun dachte ich mir einfach das ich die Adresse vom ersten Element zurückgebe.

    CRC_LOW = *Checksum(length,(byte*)&ResBlock);
CRC_HIGH = *(Checksum(length,(byte*)&ResBlock)++);

    Und so am anderen Ende einfach einen Zeiger habe den ich inkrementiere und dereferenziere
    Und so die Elemente rausbekomme.....
    jetzt ist eben die Frage ob das überhaupt so geht wie ich es gemacht habe.
    Wenn nicht wie mans lösen könnte

    Gruß Carsten

    0
  • C

    Der Rückgabewert deiner Funktion ist eine temporäre Variable, den kannst du (afaik) nicht inkrementieren. Und selbst wenn, erhöht die zweite Anweisung den Zeiger erst, nachdem du den Wert ausgelesen hast. Was du machen könntest, wäre so etwas:

    byte* tmp = Checksum(length,(byte*)&ResBlock);
CRC_LOW = *tmp;
CRC_HIGH = *(tmp+1);

    (oder noch besser - du kannst deine beiden Werte gleich per Referenz zurückgeben:

    void Checksum(int len,const byte* data,byte*low,byte*high)
{
  ...
  low = crc & 0x00FF;
  high = (crc & 0xFF00) >> 8;
}

...
Checksum(length,(byte*)&ResBlock,&CRC_LOW,&CRC_HIGH);
    0
  • S

    ich danke dir vielmals,
    dass letztere ist wohl genau das was ich brauche
    Nur nochmal das ich es auch richtig verstehe

    ich definiere CRC_LOW und CRC_HIGH als ganz normale byte variablen
    -> Übergebe ich die Adresse der Variablen
    -> Unterfunktion macht einen Zeiger draus
    -> und in der Funktion wird dann die Rechnung direkt auf in den angegebenen Speicherplatz der beiden variablen geschrieben.

    Ich hab ja schon viel zu Call by Reference gelesen aber glaube jetzt erst verstanden

    Danke nochmal

    0
  • S

    und doch noch ne Frage:

    kann es sein das vor low und high noch ein dereferenzierer muss?

    SPRICH SO:
void Checksum(int len,const byte *data,byte *low,byte *high){
 *low = crc & 0x00FF; // Low-Byte 
 *high = (crc & 0xFF00) >> 8;// High-Byte */
}
STATT SO:
void Checksum(int len,const byte *data,byte *low,byte *high){
  low = crc & 0x00FF; // Low-Byte 
  high = (crc & 0xFF00) >> 8;// High-Byte */
}

    weil ohne das bekomme ich eine compiler warning: Illegal pointer operation '=', indirection level mismatch

    Gruß Carsten

    0
  • L

    Du hast es ziemlich gut erkannt 😉

    Nur nochmal zusammenfassend:

    int wert = 12;
int* zeiger = &wert; // von wert zu zeiger
int wert_kopie = *zeiger; // von zeiger zurück zu wert
*zeiger = 12; // auch zuweisen geht natürlich
    0
Anmelden zum Antworten