-
        

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 13

Thema: Array und Zeiger

  1. #1
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    18.05.2007
    Beiträge
    329

    Array und Zeiger

    Anzeige

    Hallo,

    mein C-Umstieg macht Fortschritte, jedoch habe ich noch 1 Problem:

    in einem Array

    uint8_t Speed_array[8]={ 0,0,0,0,0,0,0,0} ;

    bekomme ich 4 Wordvariablen angeliefert, jetzt setze ich Zeiger1 auf die Position 0:

    uint8_t *Speed_left = &Speed_array[0];

    und will jetzt die Wordvariable schreiben:

    uint16_t x

    x = *Speed_left

    Was ist falsch?

    Günter

  2. #2
    Erfahrener Benutzer Robotik Einstein Avatar von Felix G
    Registriert seit
    29.06.2004
    Ort
    49°32'N 8°40'E
    Alter
    34
    Beiträge
    1.780
    Warum verwendest du ein Array vom Typ uint8_t, wenn du darin eigentlich 16Bit Werte speichern möchtest?
    So viele Treppen und so wenig Zeit!

  3. #3
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    18.05.2007
    Beiträge
    329
    weil die Werte byteweise über I2C reinkommen

  4. #4
    Erfahrener Benutzer Robotik Einstein Avatar von Felix G
    Registriert seit
    29.06.2004
    Ort
    49°32'N 8°40'E
    Alter
    34
    Beiträge
    1.780
    In diesem Fall könntest du sowas machen:

    x = ((uint16_t*)Speed_array)[0]

    Damit verwendest du das Array so, als wäre es ein uint16_t Array. So sparst dir den zusätzlichen Pointer, und du kannst 0,1,2,3 als Indizes verwenden (statt 0,2,4,6 wie bei der anderen Variante)


    edit:
    oder wie wär's damit...
    Code:
    uint8_t Speed_array[8];
    uint16_t* Speed_array16 = (uint16_t*)Speed_array;
    
    x = Speed_array16[0];
    Das macht im Endeffekt das gleiche, aber du musst nicht bei jedem Zugriff einen Typecast machen, sondern nur einmal.
    So viele Treppen und so wenig Zeit!

  5. #5
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    18.05.2007
    Beiträge
    329
    Sieht toll aus, könntest du das bitte näher erklären, ich stehe auf dem Schlauch.

  6. #6
    Erfahrener Benutzer Roboter Experte Avatar von BurningWave
    Registriert seit
    22.12.2007
    Ort
    nahe Stuttgart
    Alter
    23
    Beiträge
    656
    Im Wesentlichen ist Speed_array16 ein Zeiger, der auf das 1. Element von Speed_array zeigt. Hier wird das Array deklariert: uint8_t Speed_array[8];
    und hier der Zeiger: uint16_t* Speed_array16 (Zeiger wegen dem *). Speed_array ohne Indexoperator ([]) ist ein Zeiger auf das 1. Element seiner Elemente. Dieser Zeiger wird in uint16_t gecastet und die Adresse dem Zeiger Speed_array16 zugewiesen. (uint16_t*) ist der Cast. Jetzt kannst du über x = Speed_array16[0]; auf den Speicherbereich, also die Elemente von Speed_array zugreifen ohne jedesmal zu casten.
    meine Homepage: http://www.jbtechnologies.de
    Hauptprojekte: Breakanoid 2 - Sound Maker

  7. #7
    Erfahrener Benutzer Robotik Einstein Avatar von Felix G
    Registriert seit
    29.06.2004
    Ort
    49°32'N 8°40'E
    Alter
    34
    Beiträge
    1.780
    Naja, für den Compiler ist ein Array im Endeffekt auch nichts Anderes als ein "normaler" Pointer, nur daß in diesem Pointer eben die Basisadresse eines Arrays steht.
    Umgekehrt bedeutet das, man kann den []-Operator mit jedem beliebigen Pointer verwenden, selbst dann wenn dieser eigentlich garkein Array ist (denn dem Compiler ists egal).


    Nehmen wir an es gäbe den []-Operator nicht, wie würde man dann auf ein Element eines Arrays zugreifen?
    Man müsste, ausgehend von der Basisadresse des Arrays und der Nummer des Elements eben die Adresse dieses Elements berechnen.

    Bei 8-Bit Typen ist das sehr simpel, man muss nur die Basisadresse und die Nummer des Elements addieren, fertig ist die Adresse des Elements.

    array[63] entspricht dann quasi *(array + 63)

    Bei anderen Typen muss zusätzlich deren Größe berücksichtigt werden, also z.B. *(array + 63 * sizeof(uint16_t)) bei 16 Bit.



    Der []-Operator sagt dem Compiler also nur, daß er - passend zum Typ des verwendeten Pointers - die Adresse eines bestimmten Elements berechnen soll.


    In meinem Beispiel erzeuge ich einen uint16_t Pointer, und setze ihn auf die Basisadresse des vorhandenen uint8_t Arrays. Wenn ich dann mittels [] darauf zugreife, behandelt der Compiler diesen Pointer genauso wie ein uint16_t Array
    So viele Treppen und so wenig Zeit!

  8. #8
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    18.05.2007
    Beiträge
    329
    Code:
    uint8_t Speed_array[8]={ 0,0,0,0,0,0,0,0} ;
    uint16_t* Speed_array16 = (uint16_t*)Speed_array; 
    uint16_t Speed_left;
    uint16_t Speed_right;
    Speed_left = Speed_array16[0];
    Speed_right = Speed_array16[1];
    leider kommen hier Compilierungsfehler, mache ich noch was falsch?

  9. #9
    Erfahrener Benutzer Robotik Einstein Avatar von Felix G
    Registriert seit
    29.06.2004
    Ort
    49°32'N 8°40'E
    Alter
    34
    Beiträge
    1.780
    Seltsam...
    was genau gefällt dem Compiler nicht?
    So viele Treppen und so wenig Zeit!

  10. #10
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    18.05.2007
    Beiträge
    329
    t.c:57: warning: data definition has no type or storage class
    t.c:57: warning: type defaults to 'int' in declaration of 'Speed_left'
    usw...

    edit:
    hier:
    Speed_left = Speed_array16[0];

Seite 1 von 2 12 LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •