C: Tabelle mit Zeiger auf unterschiedlich lange Variablen

[Micha (michael_schwaer)]

Hallo,

ich habe ein Problem und hoffe Ihr könnt mir weiterhelfen. Ich habe ein 
Tabelle, wo die Adressen von Parametern abgelegt sind. Es sind 8, 16 und 
32-Byte-Parameter. Für die Definition der Tabelle habe ich die größten 
Wert verwendet (32 Bit).

struct knx_dp_def
{
  UINT32 u32_ID;
  UINT8 u8_Len;
  UINT8 u8_Sonder;
  UINT32* p32_Parameter;  // Zeiger auf Parameter
};
extern struct knx_dp_def knx_dp[KNX_MAX_DP];

Damit der Compiler nicht meckert, habe ich vor jeder Variablen einen 
Cast vorgesetzt (auch bei den 32-er Variablen - schadet ja nicht):

struct knx_dp_def knx_dp[KNX_MAX_DP] = {
// Array        ID    LEN    Sonder    Parameter
/*  0   */        DP_KEINER    ,  0,    NEIN,    NULL_PTR_GEN,    
/*  1   */        DP_TEST_RELAIS_SCHALTEN    ,  32,    NEIN,    (UINT32*)&test.u32_Para_1,    
/*  2   */        DP_TEST_RELAIS_STATUS    ,  32,    NEIN,    (UINT32*)&knx_io.u8_Object_knx_test,    
/*  3   */        DP_TEST_NR3_1_BIT    ,  8,    NEIN,    (UINT32*)&test.u8_Para_1,    
/*  4   */        DP_TEST_NR4_1_BIT    ,  8,    NEIN,    (UINT32*)&test.u8_Para_2,    
/*  5   */        DP_TEST_NR5_1_BYTE    ,  8,    NEIN,    (UINT32*)&test.u8_Para_1,    
/*  6   */        DP_TEST_NR6_1_BYTE    ,  8,    NEIN,    (UINT32*)&test.u8_Para_2,    
/*  7   */        DP_TEST_NR7_2_BYTE    ,  16,    NEIN,    (UINT32*)&test.u16_Para_1,    
/*  8   */        DP_TEST_NR8_2_BYTE    ,  16,    NEIN,    (UINT32*)&test.u16_Para_2,    
/*  9   */        DP_TEST_NR9_4_BYTE    ,  32,    NEIN,    (UINT32*)&test.u32_Para_1,    
/*  10   */        DP_TEST_NR10_4_BYTE    ,  32,    NEIN,    (UINT32*)&test.u32_Para_2,

Soweit so gut. Nun will ich aber Werte in die entsprechenden Parameter 
schreiben (in meinem Fall empfangene KNX-Daten). Damit ich weiß, wie 
groß der Parameter ist, habe ich eine Längenangabe in der Tabelle 
abgelegt (8, 16, 32). Die Info verwende ich auch, um den Wert 
entsprechend zu casten:

// Zugriff auf die Tabelle
if(knx_dp[uiDatapoint].p32_Parameter != NULL_PTR_GEN)  // Parameter enthalten
{
  if(knx_dp[uiDatapoint].u8_Len == 32)
    *knx_dp[uiDatapoint].p32_Parameter = ulWert;
  else if(knx_dp[uiDatapoint].u8_Len == 8)
    *knx_dp[uiDatapoint].p32_Parameter = (UINT8)ulWert;
  else if(knx_dp[uiDatapoint].u8_Len == 16)
    *knx_dp[uiDatapoint].p32_Parameter = (UINT16)ulWert;
}

Das funktioniert prinzipiell: aber der Zeiger verändert 32-Bit im RAM, 
auch wenn ich 8 oder 16 Bit habe. Wie bringe ich den Zeiger dazu, dass 
er nur 8 oder 16 Bit verändert? Geht das überhaupt irgendwie mit einem 
Cast? Ich habe schon selbst herumexperimentiert, aber keine Lösung 
gefunden. Mit Zeigern habe ich immer mal wieder etwas 
Verständnis-Schwierigkeiten.

Gruß
Micha

[Franko P. (sgssn)]

Was hast denn da für ein Zauberwerk? Microkontroller oder PC? Wieviele 
Bit hat das Ding? Und was für nen Compiler?

Gruß

[Arduino F. (Firma: Gast) (arduinof)]

Die C Zeigerwirtschaft ist sowieso schon recht gruselig.
Ein steter Quell besonderer Freuden.
Du machst es nicht besser, nur noch kritischer.

Mein Rat:
Keine falschen Zeigertypen verwenden!
Und wenn schon untypisierte Zeiger, dann doch bitte void Zeiger.

[Jörg W. (dl8dtl) (Moderator)]

Du musst den Zeiger für den Zugriff selbst casten. Natürlich muss (je 
nach Architektur) der Zeiger selbst passend ausgerichtet sein für die 
jeweilige Objektgröße.

Sinnvoller wäre es, eine union aus Zeigern der unterschiedlichen Größen 
zu machen und dann das passende union tag auszuwählen.

union knx_param_ptr {
  uint8_t *ptr8;
  uint16_t *ptr16;
  uint32_t *ptr32;
};

struct knx_dp_def
{
  uint32_t u32_ID;
  uint8_t u8_Len;
  uint8_t u8_Sonder;
  union knx_param_ptr parameter;
};
// …
if(knx_dp[uiDatapoint].p32_Parameter != NULL)  // Parameter enthalten
{
  if(knx_dp[uiDatapoint].u8_Len == 32)
    *knx_dp[uiDatapoint].paramter.ptr32 = ulWert;
  else if(knx_dp[uiDatapoint].u8_Len == 8)
    *knx_dp[uiDatapoint].parameter.ptr8 = (uint8_t)ulWert;
  else if(knx_dp[uiDatapoint].u8_Len == 16)
    *knx_dp[uiDatapoint].parameter.ptr16 = (uint16_t)ulWert;
}

Sonstige Anmerkungen: uint8_t, uint16_t und uint32_t sind seit C99 mit 
diesen Namen standardisiert. Benutze sie, statt eigene zu erfinden.

NULL ist seit Anbeginn standardisiert. Benutze es, statt eigene Namen zu 
erfinden.

Die Fragwürdigkeit der "ungarischen" Notation ist hinlänglich diskutiert 
worden. Deine Sache, ob du sowas trotzdem unbedingt brauchst.

[Micha (michael_schwaer)]

Jörg W. schrieb:
> Sinnvoller wäre es, eine union aus Zeigern der unterschiedlichen Größen
> zu machen und dann das passende union tag auszuwählen.

Vielen Dank für den Tipp.
In meiner Tabelle kommen nun aber Warnungen bei allen definierten 
Parametern, die mehr als 8 Bit haben (siehe Bild). Was muss ich da 
angeben, damit es passt?

[Jörg W. (dl8dtl) (Moderator)]

Micha schrieb:
> Was muss ich da angeben, damit es passt?

Du musst das passende union tag initialisieren. Stichwort: named 
initializers

Ich muss jetzt erstmal zum Mittagessen. :)

[Rbx (rcx)]

Micha schrieb:
> Mit Zeigern habe ich immer mal wieder etwas
> Verständnis-Schwierigkeiten.

Mach halt ein paar Inputs auf Nachfrage, dann bekommst du das schon 
irgendwie mit.

Beim PC Asm muss man auch angeben, ob man einen Byte-Pointer oder einen 
Word-Pointer haben will, wenn Daten aus dem Speicher gelesen werden.

[Daniel A. (daniel-a)]

Ich würde einen `void*` Pointer nehmen, und den Typ statt die Grösse 
speichern:

enum knx_dp_param_type { // in C23, we could use `enum knx_dp_param_type : uint8_t`
  KNX_FP_PT_NONE,
  KNX_FP_PT_U8,
  KNX_FP_PT_U16,
  KNX_FP_PT_U32,
};

struct knx_dp_def {
  uint32_t id;
  uint8_t type; // enum knx_dp_param_type would be larger 
  uint8_t sonder;
  void* parameter;  // Zeiger auf Parameter
};

extern struct knx_dp_def knx_dp[KNX_MAX_DP];

...
  switch((enum knx_dp_param_type)knx_dp[uiDatapoint].type){ // The cast allows the compiler to warn us about forgotten cases.
    case KNX_FP_PT_NONE: break;
    case KNX_FP_PT_U8: *(uint8_t*)knx_dp[uiDatapoint].parameter = ulWert; break;
    case KNX_FP_PT_U16: *(uint16_t*)knx_dp[uiDatapoint].parameter = ulWert; break;
    case KNX_FP_PT_U32: *(uint32_t*)knx_dp[uiDatapoint].parameter = ulWert; break;
  }

Und bei der Initialisierung kann man den Typ dann weglassen, weil 
Konvertierung von `X*` nach `void*` geht immer.

struct knx_dp_def knx_dp[KNX_MAX_DP] = {
// Array        ID    LEN    Sonder    Parameter
/*  0   */ { DP_KEINER },
/*  1   */ { DP_TEST_RELAIS_SCHALTEN,  KNX_FP_PT_U8  , NEIN, &knx_io.u8_Object_knx_test },
  ...
}

Die zusätzlichen `{}` würde ich hier sehr empfehlen, das mögen die 
Compiler, und macht alles etwas einfacher.

Zuletzt noch zur id. Stimmt dessen Wert mit dem Offset des Eintrags 
überein? (also ist `uiDatapoint == knx_dp[uiDatapoint].id`?) Den dann 
könnte man den aus `knx_dp_def` weg lassen:

struct knx_dp_def knx_dp[KNX_MAX_DP] = {
  [DP_KEINER] = {0},
  [DP_TEST_RELAIS_SCHALTEN] = {KNX_FP_PT_U8, NEIN, &knx_io.u8_Object_knx_test},
};

Und zum Pointer, braucht es den Pointer wirklich? Falls der Pointer 
mindestens 32bit braucht, und man in `knx_dp_def` einfach `uint32_t 
parameter` nehmen würde, würde das sogar Speicherplatz sparen, und man 
bräuchte keine Casts mehr.

[Jörg W. (dl8dtl) (Moderator)]

Jörg W. schrieb:
> Micha schrieb:
>> Was muss ich da angeben, damit es passt?
>
> Du musst das passende union tag initialisieren. Stichwort: named
> initializers

struct knx_dp_def knx_dp[KNX_MAX_DP] = {
/*  0   */ .u32_ID=DP_KEINER,               .u8_Len=0,  .u8_Sonder=NEIN, /* 1) */
/*  1   */ .u32_ID=DP_TEST_RELAIS_SCHALTEN, .u8_Len=32, .u8_Sonder=NEIN, .parameter.ptr32=&test.u32_Para_1,
/*  2   */ .u32_ID=DP_TEST_RELAIS_STATUS,   .u8_Len=32, .u8_Sonder=NEIN, .parameter.ptr32=&knx_io.u8_Object_knx_test,    
/*  3   */ .u32_ID=DP_TEST_NR3_1_BIT,       .u8_Len=8,  .u8_Sonder=NEIN, .parameter.ptr8=&test.u8_Para_1,
/*  4   */ .u32_ID=DP_TEST_NR4_1_BIT,       .u8_Len=8,  .u8_Sonder=NEIN, .parameter.ptr8=&test.u8_Para_2,
/*  5   */ .u32_ID=DP_TEST_NR5_1_BYTE,      .u8_Len=8,  .u8_Sonder=NEIN, .parameter.ptr8=&test.u8_Para_1,
/*  6   */ .u32_ID=DP_TEST_NR6_1_BYTE,      .u8_Len=8,  .u8_Sonder=NEIN, .parameter.ptr8=&test.u8_Para_2,
/*  7   */ .u32_ID=DP_TEST_NR7_2_BYTE,      .u8_Len=16, .u8_Sonder=NEIN, .parameter.ptr16=&test.u16_Para_1,
/*  8   */ .u32_ID=DP_TEST_NR8_2_BYTE,      .u8_Len=16, .u8_Sonder=NEIN, .parameter.ptr16=&test.u16_Para_2,
/*  9   */ .u32_ID=DP_TEST_NR9_4_BYTE,      .u8_Len=32, .u8_Sonder=NEIN, .parameter.ptr32=&test.u32_Para_1,
/*  10  */ .u32_ID=DP_TEST_NR10_4_BYTE,     .u8_Len=32, .u8_Sonder=NEIN, .parameter.ptr32=&test.u32_Para_2,

Du siehst schon, Weglassen der "ungarischen" Notation würde die Zeilen 
etwas verkürzen …

1) Du kannst natürlich .parameter.ptr32=NULL explizit schreiben, aber 
bei einer teilweisen Initialisierung einer struct werden implizit alle 
nicht genannten struct tags eh mit 0 bzw. NULL bzw. 0.0 gefüllt, 
insofern ist die Angabe dort unnötig, zumal in diesem Falle ja 
"parameter" eh nicht ausgewertet werden wird.

[Daniel A. (daniel-a)]

Hier braucht es die klammern nun aber wirklich. Entweder

struct knx_dp_def knx_dp[KNX_MAX_DP] = {
  { .u32_ID=DP_KEINER },

Oder:

struct knx_dp_def knx_dp[KNX_MAX_DP] = {
  [0].u32_ID=DP_KEINER,

aber

struct knx_dp_def knx_dp[KNX_MAX_DP] = {
  .u32_ID=DP_KEINER,

wird nicht gehen.

[Jörg W. (dl8dtl) (Moderator)]

Daniel A. schrieb:
> Hier braucht es die klammern nun aber wirklich.

Stimmt, danke für die Korrektur.

Sinnvoll finde ich die Variante, die den Array-Index explizit benennt:

struct knx_dp_def knx_dp[KNX_MAX_DP] = {
[0] = { .u32_ID=DP_KEINER,               .u8_Len=0,  .u8_Sonder=NEIN, /* 1) */ },
[1] = { .u32_ID=DP_TEST_RELAIS_SCHALTEN, .u8_Len=32, .u8_Sonder=NEIN, .parameter.ptr32=&test.u32_Para_1 },
[2] = { .u32_ID=DP_TEST_RELAIS_STATUS,   .u8_Len=32, .u8_Sonder=NEIN, .parameter.ptr32=&knx_io.u8_Object_knx_test },
[3] = { .u32_ID=DP_TEST_NR3_1_BIT,       .u8_Len=8,  .u8_Sonder=NEIN, .parameter.ptr8=&test.u8_Para_1 },
[4] = { .u32_ID=DP_TEST_NR4_1_BIT,       .u8_Len=8,  .u8_Sonder=NEIN, .parameter.ptr8=&test.u8_Para_2 },
[5] = { .u32_ID=DP_TEST_NR5_1_BYTE,      .u8_Len=8,  .u8_Sonder=NEIN, .parameter.ptr8=&test.u8_Para_1 },
[6] = { .u32_ID=DP_TEST_NR6_1_BYTE,      .u8_Len=8,  .u8_Sonder=NEIN, .parameter.ptr8=&test.u8_Para_2 },
[7] = { .u32_ID=DP_TEST_NR7_2_BYTE,      .u8_Len=16, .u8_Sonder=NEIN, .parameter.ptr16=&test.u16_Para_1 },
[8] = { .u32_ID=DP_TEST_NR8_2_BYTE,      .u8_Len=16, .u8_Sonder=NEIN, .parameter.ptr16=&test.u16_Para_2 },
[9] = { .u32_ID=DP_TEST_NR9_4_BYTE,      .u8_Len=32, .u8_Sonder=NEIN, .parameter.ptr32=&test.u32_Para_1 },
[10] = {.u32_ID=DP_TEST_NR10_4_BYTE,     .u8_Len=32, .u8_Sonder=NEIN, .parameter.ptr32=&test.u32_Para_2 },

Damit erübrigt sich gleich noch der Kommentar zum Array-Index.