C Struct arbeiten

[Vorgestern (Gast)]

Moin, ich hab ein Struct

typedef struct{
    int speedR;
    int speedL;
    int encR;
    int encL;
} encoder_t;

Ich möchte jetzt eine Ausgabe schreiben. Wie kann ich in einer Schleife 
die Einträge automatisch abrufen. In der Art:

encoder_t encoder1;
...
for(int i=0; i<4; i++){
   printf("%d", encoder1.[i]);
}

Wie gehts richtig? (Umgekehrtes Enum?)
Ausgabe für jeden einzelnen Eintrag händisch erstellen? (Hab ein Struct 
welches noch mehr Inhalte beinhaltet..)
Gar kein Struct nutzen?
Andere Möglichkeiten sowas gut zu händeln?

[Dr. Sommer (Gast)]

Das geht aus Prinzip nicht. Die Einträge eines struct können 
unterschiedliche Typen haben, welche unterschiedlich behandelt werden 
müssen, und daher nicht in einer Schleife iteriert werden können.

Du kannst ein Array nutzen und mit einem enum fixe Indizes für die 
Einträge definieren, oder eine union aus Array und Einträgen (gefährlich 
+ hässlich), oder einfach die 4 Einträge manuell per printf ausgeben - 
falls du die nicht noch an vielen anderen Stellen im Code iterieren 
musst.

In C++ kann man sich eine statische Iteration bauen welche automatisch 4 
printf Statements generiert - hier aber ziemlicher Overkill.

[Peter D. (peda)]

Da muß man sich entscheiden, entweder struct oder array.
Man kann zwar eine Union aus struct und array machen, aber das ist 
unsauber.
Sauber ist, ein Array zu nehmen und die Elemente über ein Enum 
anzusprechen.

[Patrick C. (pcrom)]

Dies waehre eine moeglichkeit :

typedef union {
    struct {
        uint8 data[NRF_PKSIZE];
    } raw;
    struct {
        uint8   NrfCmd;
        uint8   Future;
        uint8   ssize;
        uint8   rsize;
        uint8   sbuf[28];
    } s;
} s_NrfPacket;

Aber wie schon gesagt von Peter D, das ist unsauber.
zB :
* Andere compilers koennten unterschiedliche speicher-definitionen haben
* Andere prozessoren koennten unterschiedliche speicher-definitionen 
haben
* Manchmal wird in ein struct mehr platz reserviert dann wirklich 
benotigt
Und wahrscheinlich noch mehrere nachteilen... Aber fuer mich 
funktioniert es.

Patrick

[TriHexagon (Gast)]

Oder einfach eine Funktion definieren dir die Indexe auf die Elemente 
abbildet (Mapping-Funktion). Dann kannst du das Struktur behalten und 
kannst die Elemente trotzdem indexieren. Keine ekligen Unions nötig und 
auch kein Array.

In C++ könnte man auch mittels der Operatorenüberladung genau die Syntax 
haben, die du verwendest.

[zitter_ned_aso (Gast)]

Vorgestern schrieb:
> Enum

ich würde es so machen:

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>

typedef enum {speedR,speedL, encR, encL, ENC_DATA_LEN} enc_iterator;

typedef struct{
    int encoder_data[ENC_DATA_LEN];
} encoder_t;

void print_encoder_data(encoder_t* e){
    for(enc_iterator i=speedR; i<ENC_DATA_LEN; i++)
       printf("%d\n", e->encoder_data[i]); 

}

int main(int argc, char* argv[]){


    encoder_t enc;
    enc.encoder_data[speedR]=1;
    enc.encoder_data[speedL]=2;
    enc.encoder_data[encR]=3;
    enc.encoder_data[encL]=4;
    
    print_encoder_data(&enc);

    return 0;
}

[x^2 (Gast)]

Die Array-Lösung hat das Problem, dass Padding/Alignment der struct 
ignoriert wird und es Umsortierungen in der struct nicht nachzieht. 
Ebenso unsauber aber etwas komfortabler:

encoder_t x;

static const uint8_t at[] = 
{
   offsetof(x, speedR), 
   offsetof(x, speedL),
   offsetof(x, encR),
   offsetof(x, encL)
};

for (int i = 0; i < sizeof(at)/sizeof(at[0]); ++i)
{
   int element = ((const int*)&x)[at[i]/sizeof(int)];
   printf("%d\n", element);
}

[Walter K. (walter_k488)]

Vorgestern schrieb:
> typedef struct{
>     int speedR;
>     int speedL;
>     int encR;
>     int encL;
> } encoder_t;
>
> Ich möchte jetzt eine Ausgabe schreiben. Wie kann ich in einer Schleife
> die Einträge automatisch abrufen

Indem Du Pointer verwendest, die auf die einzelnen Strukturelemente 
zeigen.
Da in Deinem Beispiel alle Elemente vom gleichen Datentyp sind - ist 
dieser Weg problemlos möglich.