Iteration über Struct

[Third E. (third-eye)]

Hallo,

nach Lesen des Threads Beitrag ""Zeiger" auf struct-Element" 
stellt sich mir die Frage, ob der untenstehende Code empfehlenswert ist?
Speziell der Cast auf (TFilterStruct*).

Ein ähnlicher Code läuft auf einem 8Bit-µC, nur habe ich dort ein Array 
aus TFilterStruct erstellt und rufe die einzelnen Arrayelemente über 
einen Index (Enum) auf. Das funktioniert problemlos, nur ist es beim 
Debuggen immer sehr umständlich, weil ich da nur Zahlen als Index sehe. 
Dann muss ich erst immer nachzusehen, welcher "sprechende" Enum-Wert 
denn der Zahl entspricht.

Ich habe den Code abgeändert und ein kleines C-Programm für den PC zur 
besseren Evaluierung erstellt.
Ich verwende jetzt ein Struct bestehend aus Structs.

Ich möchte sowohl auf bestimmte Elemente zugreifen können (wie bei der 
Dummy-Initialisierung) als iterieren (wie in der for-Schleife).

Weiterhin stellt sich mir die Frage: Könnte man die for-Schleife zwecks 
Optimierung des Speicherverbrauchs (kleiner µC!) gleich den Pointer 
initialisieren bzw. iterieren?

Man beachte übrigens auch die Dummy-Werte, von oben nach unten gelesen. 
:-D

Grüße
Third Eye

#include <stdio.h>
#include <conio.h>
#include <stdint.h>

typedef struct
{
   uint16_t InputValue;
   float FilteredValue;
   uint8_t FlagInputValueReadyToProcess;
} TFilterStruct;


static struct
{
   TFilterStruct U1Max;
   TFilterStruct U2Max;
   TFilterStruct U1Avg;
   TFilterStruct U2Avg;
}
FilterStructAll = {0};


int main(void)
{
   //Dummy-mäßig auf irgendwelche Werte setzen:
   FilterStructAll.U1Max.InputValue = 0xBAD;
   FilterStructAll.U2Max.InputValue = 0xDEAF;
   FilterStructAll.U1Avg.InputValue = 0xACDC;
   FilterStructAll.U2Avg.InputValue = 0xBABE;

   TFilterStruct* Ptr = (TFilterStruct*)&FilterStructAll;
   for (uint8_t i = 0; i < sizeof(FilterStructAll) / sizeof(TFilterStruct); i++)
   {
      printf("%X\r\n", Ptr->InputValue);
      Ptr++;
   }

   printf("Ende.\r\n");
   getch(); //Auf "Enter" warten.
   return 0;
}

[Dumdi D. (dumdidum)]

Der Code ist nicht sicher. Es ist meiner Meinung nach nicht garantiert, 
dass zwischen den TFilterStructs keine Füllbytes angelegt werden. (Und 
damit springt der Ptr++ zu kurz).

Warum legst Du kein Array mit TFilterStructs an?

[Tom (Gast)]

Direkt im Speicher herumzumachen und als Nebenwirkung die passenden 
(oder wie hier dank Padding die nicht passenden) Daten zu erwischen ist 
ein Wartungsalptraum. Bei Miniprogrammen wie hier geht das notfalls, 
aber sobald es etwas komplexer wird, baut man sich Bugs ein.

#include <stdio.h>
#include <stdint.h>

typedef struct
{
    uint16_t InputValue;
    float FilteredValue;
    uint8_t FlagInputValueReadyToProcess;
} TFilterStruct;

enum eFilterName { U1Max, U2Max, U1Avg, U2Avg, NUM_OF_FILTERS};

TFilterStruct Filters[NUM_OF_FILTERS];

int main(void)
{
    //Dummy-mäßig auf irgendwelche Werte setzen:
    Filters[U1Max].InputValue = 0xBAD;
    Filters[U2Max].InputValue = 0xDEAF;
    Filters[U1Avg].InputValue = 0xACDC;
    Filters[U2Avg].InputValue = 0xBABE;

    for (enum eFilterName i = 0; i < NUM_OF_FILTERS; i++)
    {
        printf("%X\r\n", Filters[i].InputValue);
    }

    printf("Ende.\r\n");
    return 0;
}

[Tom (Gast)]

Third E. schrieb:
> Könnte man die for-Schleife zwecks
> Optimierung des Speicherverbrauchs (kleiner µC!) gleich den Pointer
> initialisieren bzw. iterieren?

Das sind Probleme, über die man am Ende nachdenkt, wenn das Projekt 
fertig ist, aber 2 Byte Speicher fehlen und in der geplanten 
Serienproduktion der nächstgrößere uC zu teuer wäre.

[Tom (Gast)]

Tom schrieb:
> for (enum eFilterName i = 0; i < NUM_O

Was ich damit sagen wollte:
Zumindest mit QT Creator wird beim Debuggen der Wert von i als 
Bezeichnung des enums und als Zahl angezeigt, wenn man i als enum 
deklariert. Andere IDEs habe ich nicht ausprobiert.

[L33t 1D107 (Gast)]

> Man beachte übrigens auch die Dummy-Werte, von oben nach unten gelesen.

Solche Initialisierungen funktionieren nur korrekt mit den Werten 0xDEAD 
0xBEEF 0x1D107 0x7353.

[Marc (Gast)]

folgende Lösung finde ich elegant:
So kann man jeden Filter direkt ansprechen und für die Display Ausgabe 
ist trotzdem eine Liste vorhanden.

#include <stdio.h>
#include <conio.h>
#include <stdint.h>

typedef struct
{
   uint16_t InputValue;
   float FilteredValue;
   uint8_t FlagInputValueReadyToProcess;
} TFilterStruct;


static struct
{
   TFilterStruct U1Max;
   TFilterStruct U2Max;
   TFilterStruct U1Avg;
   TFilterStruct U2Avg;
} Filter = {0};


static const TFilterStruct *FilterList[] = {&Filter.U1Max, &Filter.U2Max, &Filter.U1Avg, &Filter.U2Avg};
#define FILTERLIST_SIZE (sizeof(FilterList)/sizeof(FilterList[0]))

int main(void)
{
  //Dummy-mäßig auf irgendwelche Werte setzen:
  Filter.U1Max.InputValue = 0xBAD;
  Filter.U2Max.InputValue = 0xDEAF;
  Filter.U1Avg.InputValue = 0xACDC;
  Filter.U2Avg.InputValue = 0xBABE;

  for (int i = 0; i < FILTERLIST_SIZE; i++)
  {
    printf("%X\r\n", FilterList[i]->InputValue);
  }

  printf("Ende.\r\n");
  return 0;
}

FilterList kann man auch um Beschreibungstexte ergänzen, nicht 
unpraktisch auf einem Display:
Beispiel:

#include <stdio.h>
#include <conio.h>
#include <stdint.h>

typedef struct
{
   uint16_t InputValue;
   float FilteredValue;
   uint8_t FlagInputValueReadyToProcess;
} TFilterStruct;


static struct
{
   TFilterStruct U1Max;
   TFilterStruct U2Max;
   TFilterStruct U1Avg;
   TFilterStruct U2Avg;
} Filter = {0};

typedef struct 
{
  const char * pInfotext;
  const TFilterStruct *pFilter;
} FilterInfoType;

static const FilterInfoType FilterList[] = 
{
  {"U1Max", &Filter.U1Max},
  {"U2Max", &Filter.U2Max},
  {"U1Avg", &Filter.U1Avg},
  {"U1Avg", &Filter.U2Avg}
};
  
#define FILTERLIST_SIZE (sizeof(FilterList)/sizeof(FilterList[0]))

int main(void)
{
  //Dummy-mäßig auf irgendwelche Werte setzen:
  Filter.U1Max.InputValue = 0xBAD;
  Filter.U2Max.InputValue = 0xDEAF;
  Filter.U1Avg.InputValue = 0xACDC;
  Filter.U2Avg.InputValue = 0xBABE;

  for (int i = 0; i < FILTERLIST_SIZE; i++)
  {
    printf("%s = %X\r\n", FilterList[i].pInfotext, FilterList[i].pFilter->InputValue);
  }

  printf("Ende.\r\n");
  return 0;
}

[itzztitz (Gast)]

für leute mit dynamischem ansatz geht auch ne liste ...

struct TFilterStruct{
   TFilterStruct     *next;
   uint16_t          InputValue;
   float             FilteredValue;
   uint8_t           FlagInputValueReadyToProcess;
};

TFilterStruct *FilterList;

void AddToList( ... ){
   TFilterStruct *newelement;
   newelement = malloc( sizeof( TFilterStruct ) );
   ...
}

void DeleteFromList( ... ){

}

void foo ( void ){
  TFilterStruct *element;
  for (element= FilterList ; element!= NULL; element= element->next){
     if( element->FlagInputValueReadyToProcess ){
         print("%f", element->FilteredValue );           
     }
  }    
}

[itzztitz (Gast)]

jaaa da fehlt ein "struct"

struct TFilterStruct *element;

[Dumdi D. (dumdidum)]

itzztitz schrieb:
> für leute mit dynamischem ansatz geht auch ne liste ...

Wobei in dem Code ja die Hälfte fehlt...

[A. H. (ah8)]

Warum willst Du denn überhaupt unbedingt iterieren? Was ist verkehrt an:

#include <stdio.h>
#include <conio.h>
#include <stdint.h>

typedef struct
{
   uint16_t InputValue;
   float FilteredValue;
   uint8_t FlagInputValueReadyToProcess;
} TFilterStruct;


static struct
{
   TFilterStruct U1Max;
   TFilterStruct U2Max;
   TFilterStruct U1Avg;
   TFilterStruct U2Avg;
}
FilterStructAll = {0};

void printTFilterStruct(TfilterStruct *tFilterStruct) {
  printf("%X\r\n", tFilterStruct->InputValue);
}

int main(void)
{
   //Dummy-mäßig auf irgendwelche Werte setzen:
   FilterStructAll.U1Max.InputValue = 0xBAD;
   FilterStructAll.U2Max.InputValue = 0xDEAF;
   FilterStructAll.U1Avg.InputValue = 0xACDC;
   FilterStructAll.U2Avg.InputValue = 0xBABE;

   printTFilterStruct(&FilterStructAll.U1Max);
   printTFilterStruct(&FilterStructAll.U2Max);
   printTFilterStruct(&FilterStructAll.U1Avg);
   printTFilterStruct(&FilterStructAll.U2Avg);

   printf("Ende.\r\n");
   getch(); //Auf "Enter" warten.
   return 0;
}

[A. H. (ah8)]

Und wenn Du, aus welchen Gründen auch immer, beide Welten brauchst, dann 
vielleicht so (ungetestet!):

#include <stdio.h>
#include <conio.h>
#include <stdint.h>

typedef struct
{
   uint16_t InputValue;
   float FilteredValue;
   uint8_t FlagInputValueReadyToProcess;
} TFilterStruct;


static struct
{
   TFilterStruct U1Max;
   TFilterStruct U2Max;
   TFilterStruct U1Avg;
   TFilterStruct U2Avg;
}
FilterStructAll = {0};

static TfilterStruct *FilterArrayAll[] = { 
  &FilterStructAll.U1Max,
  &FilterStructAll.U2Max,
  &FilterStructAll.U1Avg,
  &FilterStructAll.U2Avg
};

int main(void)
{
  static uint16_t init_values[] = { 0xBAD, 0xDEAF, 0xACDC, 0xBABE };

  assert(sizeof(FilterArrayAll)/sizeof(*FilterArrayAll)==sizeof(init_values)/sizeof(*init_values))
  for ( int i=0; i<sizeof(FilterArrayAll)/sizeof(*FilterArrayAll), ++i )
     FilterArrayAll[i]->InputValue = init_values[i];

  for ( int i=0; i<sizeof(FilterArrayAll)/sizeof(*FilterArrayAll), ++i )
     printf("%X\r\n", FilterArrayAll[i]->InputValue);

  printf("Ende.\r\n");
  getch(); //Auf "Enter" warten.
  return 0;
}

[Third E. (third-eye)]

A. H. schrieb:
> Warum willst Du denn überhaupt unbedingt iterieren?
Der Einwurf ist berechtigt bei gerade mal vier Struct-Elementen. War 
eher eine allgemeine Frage, denn es könnten ja auch sehr viel mehr 
Elemente sein, auf die man iterierbar zugreifen möchte.

[Jasson J. (jasson)]

Zuerst gebe ich zu, ich habe dein Anliegen nicht ganz durchleuchtet, 
noch alle obigen Beiträge gelesen.

Ich beschäftige mich gerade mit dem Gaphischen Framework "GrLib" von TI 
für die TIVA-C Serie. Das arbeitet mit einer Architektur in C, die es 
erlaubt binäre Bäume aus verschiedenen Struct-Typen aufzubauen, von 
einem Parser durchitterrieren zu lassen und die in den Structs 
befindlichen Daten von einem spezifischen C-File bearbeiten zu lassen.
Das ist von der Idee her ähnlich wie die Grafischen Sachen auch .NET 
oder Qt. Also Buttons, Slider, Checkboxen etc. Das ganze dann mit 
Touchdisplay.

Das ist echt interessant, wie das über defines von Parameterlisten im 
Header und so einer Art sinngemäßen Basisklasse gelöst ist (nennt sich 
"tWidget"). Die Idee ist, das in der Basisklasse u.a. Zeiger auf Parent, 
Next und Child existieren, mit denen ein Parser durch einen Binären Baum 
verschiedener Instanzen und Hierachien itterieren kann. Der Zeiger der 
"Basisklasse" wird dann im C-File Code in einer standadisierten Funktion 
deren Signatur in allen Files gleich ist auf den spezifischen Typ 
umgecastet. Bei dem Funktionsaufruf wird auch ein Argument übergen, was 
die Zielfunktion machen soll. Daüber lassen sich dann wiederum 
spezifische Aktion im jeweiligen C-File realisieren. Erinnert stark an 
den OOP-Interface Gedanken.

Was ich damit beschrieben will ist, dass das die Möglichkeit bietet, 
Daten und "Methoden" auch in C relativ nah an einander zu binden. UND du 
kannst sogar Stucts verschiedener Typen wegen der "Basisklasse" 
hintereinander packen. Also du musst nicht zwingend in Arrays von 
Structs eines bestimmten Typs denken.

Das SW Package wo die GrLib drin ist wäre z.B. TivaWare - wenn du es dir 
tatsächlich ansehen willst. Es gibt sie auch für andere Prozessorfamilen 
von TI wie MSP und AM335 - was dich aber Zwecks Verstehen und Reverse 
Engineering vom FW nicht interessieren braucht.

[Bernd K. (prof7bit)]

Dumdi D. schrieb:
> Der Code ist nicht sicher. Es ist meiner Meinung nach nicht garantiert,
> dass zwischen den TFilterStructs keine Füllbytes angelegt werden. (Und
> damit springt der Ptr++ zu kurz

Wo sollen die unterschiedlichen Füllbytes denn herkommen? Wenn Ptr von 
selben Typ ist wie die einzelnen Struct-Elemente dann gelten auch die 
selben Alignment-Regeln.