C -> Struktur initalisieren

[Jan H. (janiiix3)]

Moin Moin,

ist es möglich die in der Struktur (cmd_t) befindliche Struktur 
(cmdTable_t) schon am Anfang zu initalisieren?
Und nicht so ->

const cmdTable_t cmdTab[] = "..." ( wie weiter unten..)

typedef struct
{
  cmdTable_t    cmdTable;
  cmdRaw_t    cmdRawData;
}cmd_t;

const cmdTable_t cmdTab[] =
{
  {"set_kx"       ,   "-setk"    ,   NULL   },
  {"unset_kx"      ,   "-usetk"  ,  NULL  },

  {"get_v"      ,  "-gvol"    ,  NULL  },
  {"get_i"      ,  "-gcur"    ,  NULL  },
  {"get_p"      ,  "-gpwr"    ,  NULL  },
  {"get_err"      ,  "-gerr"    ,  NULL  },
  
  {"write_eep"    ,  "-weep"    ,  NULL  },
  {"read_eep"      ,  "-reep"    ,  NULL  },
  {"clear_eep"    ,  "-ceep"    ,  NULL  },
  
  {"set_user"      ,  "-suser"  ,  NULL  },
  {"set_sernr"    ,  "-ssrn"    ,  NULL  },  
  {"set_time"      ,  "-stme"    ,  NULL  },  
};

Ich möchte meiner Funktion nicht unnötig zwei Parameter übergeben. Wenn 
ich die Struktur schon am Anfang einmal initalisieren lasse ( const ) 
brauche ich später dort nichts mehr rein zu schreiben.

[Markus F. (mfro)]

Frage ist nicht klar. Möchtest Du

- verschachtelte Strukturen initialisieren oder gar
- eine Struktur initialisieren, bevor sie im Programm bekannt ist

??

[Einer K. (Gast)]

Meines Wissens nach, in C nicht möglich.

in C++ könnte das so aussehen:

struct Test
{
  const byte pin; 
  uint16_t count;
  Test(const byte pin):pin(pin),count(0){}
};

Test array[] {2,3,4,5};

Das Test.pin stammt aus der Initialisierungsliste
Test.count wird auf 0 gesetzt

Falls dich das nicht befriedigt, gilt:
Markus F. schrieb:
> Frage ist nicht klar.

[egger (Gast)]

Oder möchtest du das?

typedef struct
{
  cmdTable_t    cmdTable;
  cmdRaw_t    cmdRawData;
}cmd_t;

static const cmd_t cmd[] = { 
 {
   (cmdTable_t){ "set_kx", "-setk", NULL }, (cmdRaw_t)wasAuchImmer1
 },
 {
   (cmdTable_t){ "get_v", "-gvol", NULL }, (cmdRaw_t)wasAuchImmer2
 },
 {
   (cmdTable_t){ "get_i", "-gcur", NULL }, (cmdRaw_t)wasAuchImmer3
 }
};

und dann geht auch z.B:

cmd[0].cmdTable.callback(cmd[0].cmdRawData);

[A. S. (Gast)]

Da nicht klar ist, was Du meinst, reduzier Dein Beispiel so weit es 
geht, z.B.:

typedef struct
{
  cmdTable_t    cmdTable;
  cmdRaw_t    cmdRawData;
}cmd_t;

const cmdTable_t cmdTab[] =
{
  {"a","b",0},
  {"c","d",0},
};

cmdTable_t und cmdRaw_t sind nicht bekannt. Egal, wir nehmen an, dass 
erstere unten "richtig" gefüllt wurde.

Unten hast Du ein Array, oben nur ein Feld. Die beiden cmdTable_t haben 
also nichts miteinander zu tun.

Möchtest du eine Instanz von cmd_t initialisieren? ja, das geht, z.B. 
so:

cmd_t myCmd = {
  {"e","f",0},  /* cmdTable analog Deinem Beispiel */
  {3,4,5,6,7}   /* wie auch immer cmdRawData gefüllt werden muss */
}

da der erste Eintrag aber cmd*Table* genannt ist, meinst Du vermutlich 
etwas anderes, als Du schreibst.

[Jan H. (janiiix3)]

Damit "cmd_t cmd[]"
würde ich ja mehrere Strukturen von der Struktur ansich anlegen.
Was ich wollte sind mehrere Strukturen vom Member "cmdTable_t 
cmdTable;".
Diese sollten dann halt mit einem Wert einmal initalisiert werden.
Sonst würde ich mit "cmd_t cmd[]" unnötig Speicherplatz verschenken.

Pseudocode

typedef struct  
{
  cmdTable_t  table[10];
  cmdRaw_t  raw;
}cmd_t;

cmd_t cmd =
{
  (cmdTable_t){ NULL , NULL , NULL }, // [0]
  (cmdTable_t){ NULL , NULL , NULL }, // [1]
  (cmdTable_t){ NULL , NULL , NULL }, // [2]
  (cmdTable_t){ NULL , NULL , NULL }, // [3]
};

So meine ich das..

[Markus F. (mfro)]

Jan H. schrieb:
> So meine ich das..

Zumindest mir (aber da scheine ich nicht alleine zu sein, die Anderen 
raten ja auch nur rum) ist deine Frage immer noch nicht klar. Im 
Gegenteil.

Dein letztes Beispiel ist etwas ganz anderes, als das zuerst gepostete.

[Falk B. (falk)]

@Jan H. (janiiix3)

>Diese sollten dann halt mit einem Wert einmal initalisiert werden.
>Sonst würde ich mit "cmd_t cmd[]" unnötig Speicherplatz verschenken.

Nicht wirklich. Denn cmt_t cmd braucht so oder so den vollen 
Speicherplatz. Lediglich die Initialisierungsdaten landen dann halt 
mehrfach im Flash und werdem bei der C-Init Sequenz in die RAM-Variable 
kopiert. So what! Mußt du WIRKLICH so sehr Speicher sparen? Oder ist das 
eher Einbildung.

Wenn du denn WIRKLICH meinst, das tun zu müssen, mußt du das zur 
Laufzeit über eine Schleife und memcpy machen, dann reicht es, einmal 
die Init-Daten in dein Array zu kopieren.

[A. S. (Gast)]

Kennst Du Pointer? Wenn ja, dann verweise immer dort, wo Du das gleiche 
mehrfach haben möchtest, mit einem Pointer auf eine Instanz.

Wenn nein, dann formuliere einmal ein Beispiel aus und schreibe dazu, 
was Du anders haben möchtest oder was nicht klappt.

Dein Pseudocode wäre in C übrigns:
Jan H. schrieb:

cmd_t cmd =
{
  /* eigene Klammern für das Array zuerst */
  {
      { NULL , NULL , NULL }, // [0]
      { NULL , NULL , NULL }, // [1]
      { NULL },               /* [2] Wenn nur noch Felder mit 0 kommen,       
      { NULL },               /* [3] */
      /* und auch die letzten 6 kannst Du weglassen, wenn 0 */
  }, /* die Tabelle ist initialisiert */
  /* und jetzt Deine zweite Struktur */ 
  { 
    1, /* erstes Element (was immer Du da hast) */
    2,
    3,
    4  /* 4tes Element, geraten... */
  }
};

Dein (cmdTable_t) ist übrigens unnütz.

[Falk B. (falk)]

@Achim S. (achs)

>Kennst Du Pointer? Wenn ja, dann verweise immer dort, wo Du das gleiche
>mehrfach haben möchtest, mit einem Pointer auf eine Instanz.

Nö, denn dann hast du nur viele Verweise (Pointer) auf eine Instanz. Das 
ist NICHT das Gleiche, wie wenn man mehrere Instanzen mit den gleichen 
Daten initialisieren will, denn danach will man den Inhalt der Instanzen 
vielleicht auch ändern?

[M. K. (kichi)]

Falk B. schrieb:
> Das
> ist NICHT das Gleiche, wie wenn man mehrere Instanzen mit den gleichen
> Daten initialisieren will, denn danach will man den Inhalt der Instanzen
> vielleicht auch ändern?

Glaube ich nicht, denn:

Jan H. schrieb:
> Wenn
> ich die Struktur schon am Anfang einmal initalisieren lasse ( const )
> brauche ich später dort nichts mehr rein zu schreiben.

[Jan H. (janiiix3)]

Das klappt mit dem init. nicht..

typedef struct
{
  /*
  *  Name des Kommandos
  */
  char  name[20];
  
  /*
  *  Befehl der empfangen werden muss
  */
  char  instruction[15];
      
  /*
  *  Funktion die beim entsprechenden Kommando 
  *  ausgeführt werden soll
  */  
  void*  (*fnc) (void* , void*);
  
}cmdTable_t;

typedef struct  
{
  uint8_t dataInRawBuff :1;
  char cmdRawBuff[CMD_SIZE_OF_MAX_RAW_DATA];  
}cmdRaw_t;
cmdRaw_t cmdRaw;

typedef struct  
{
  cmdTable_t  table[4];
  cmdRaw_t  raw;
}cmd_t;

cmd_t cmd =
{
  {
    { NULL , NULL , NULL }, // [0]
    { NULL , NULL , NULL }, // [1]
    { NULL , NULL , NULL }, // [2]
    { NULL , NULL , NULL }, // [3]    
  },
  {
    0,
    .cmdRawBuff = "",
  },
};

[A. S. (Gast)]

lass bitte das bitfeld weg (wozu auch), also:

uint8_t dataInRawBuff;

Und statt  .cmdRawBuff = ...
besser gernichts oder wenn überhaupt:

{{0}}

Zudem hast Du jeweils noch ein Komma am Ende zuviel (egal, obs vom 
Compiler ignoriert wird oder nicht).

Fang einfach mit leeren Mengen an und initialisiere jeweils ein element 
mehr. Und wenn das eine element mehr nicht klappt, dann lies dir die 
Fehlermeldung durch. Und wenn Du damit nichts anfangen kannst, dann 
poste sie hier. So ist das alles nur ein großer, nicht funktionierender 
Matsch, der Dich und uns nicht weiter bringt.

[DPA (Gast)]

Wie wärs mit sowas:

#include <stdbool.h>
#include <stddef.h>

#define CMD_SIZE_OF_MAX_RAW_DATA 256

typedef struct cmdTable {
  const char*  name;
  const char*  instruction;
  void*  (*fnc) (void* , void*);
} cmdTable_t;

typedef struct cmdRaw {
  bool dataInRawBuff;
  char cmdRawBuff[CMD_SIZE_OF_MAX_RAW_DATA];
} cmdRaw_t;

typedef struct cmd {
  const struct cmdTable* table;
  size_t table_length;
  struct cmdRaw* buffer;
} cmd_t;

// (Nicht definierte felder werden mit 0 initialisiert)
static const struct cmdTable table[] = {
  { "set_kx", "-setk" },
  {
    .name = "unset_kx",
    .instruction = "-usetk"
  },
};

struct cmd cmd = {
  .table = table,
  .table_length = sizeof(table)/sizeof(*table),
  .buffer = &(struct cmdRaw){0},
};

int main(){}

[Markus F. (mfro)]

Weil's falsch ist. So (z.B.) ginge das:

cmd_t cmd =
{
  {
    { {0} , {0} , NULL }, // [0]
    { {0} , {0} , NULL }, // [1]
    { {0} , {0} , NULL }, // [2]
    { {0} , {0} , NULL }, // [3]
  },
  {
    0,
    .cmdRawBuff = "",
  },
};

name und instruction sind char-Arrays, keine Zeiger. Entsprechend kann 
man sie nicht mit einem NULL-Zeiger initialisieren.

Ob das natürlich das ist, was Du wirklich haben willst, kannst nur Du 
selbst wissen (uns verrätst Du's ja nicht).

[Jan H. (janiiix3)]

DPA schrieb:
> Wie wärs mit sowas:
>

> struct cmd cmd = {
>   .table = table,
>   .table_length = sizeof(table)/sizeof(*table),
>   .buffer = &(struct cmdRaw){0},
> };
> 
> int main(){}
>

Die Variante sieht gut aus. Werde ich nehmen.
Kurze Frage noch..

>   .table_length = sizeof(table)/sizeof(*table),

Müsste das nicht so lauten?

.table_length = sizeof(table)/sizeof(table[0]),

[Karl M. (Gast)]

Hallo Jan,

C Grundlagen, ist das selben.

Jan H. schrieb:
>>   .table_length = sizeof(table)/sizeof(*table),
> Müsste das nicht so lauten?.table_length =
> sizeof(table)/sizeof(table[0]),

[Jan H. (janiiix3)]

Karl M. schrieb:
> Hallo Jan,
>
> C Grundlagen, ist das selben.
>
> Jan H. schrieb:
>>>   .table_length = sizeof(table)/sizeof(*table),
>> Müsste das nicht so lauten?.table_length =
>> sizeof(table)/sizeof(table[0]),

Ja natürlich.. Peinlich! Danke.