structs incrementieren?

[Jan H. (janiiix3)]

typedef struct
{
  const char *projectName;
  const char *hardwareDate;
  const char *madeBy;  
}DevBoard_t;

const DevBoard_t *uartMsg = &Message;

Ist es irgendwie möglich auf die einzelnen Strings in dieser Struktur 
via. increment zu kommen?

for (uint8_t i = 0 ; i < 3 ; i++)
{
  uart_puts((char*)(uartMsg++));
        uart_puts("\r\n");
}

[J. F. (Firma: Père Lachaise) (rect)]

Schau dir mal pragma packed an.

Mehr: was glaubst du denn?

[Jan H. (janiiix3)]

J. F. schrieb:
> Schau dir mal pragma packed an.
>
> Mehr: was glaubst du denn?

Geht bestimmt irgendwie..

[Teddy (Gast)]

Du hast den Struct als Zeiger definiert. Ist das richtig?

Ich wäre so vorgegangen. Den Struct ganz "normal" als Variable, kein 
Zeiger, definiert.
Dann einen pointer, der auf die Anfangsadresse des Structs zeigt 
definiert.
Wenn man dann den pointer incrementiert, müsste er auf das nächste 
Element zeigen.

[Peter D. (peda)]

Du kannst eine Union aus dem Struct und einem Array definieren. Das 
Array kannst Du dann hochzählen.

[Jan H. (janiiix3)]

Teddy schrieb:
> Du hast den Struct als Zeiger definiert. Ist das richtig?
>
> Ich wäre so vorgegangen. Den Struct ganz "normal" als Variable, kein
> Zeiger, definiert.
> Dann einen pointer, der auf die Anfangsadresse des Structs zeigt
> definiert.
> Wenn man dann den pointer incrementiert, müsste er auf das nächste
> Element zeigen.

Genau so habe Ich das getan. Das klappt eben nicht..

[Teddy (Gast)]

Ich denke so:

typedef struct
{
  const char projectName;
  const char hardwareDate;
  const char madeBy;
}DevBoard_t;

const DevBoard_t uartMsg;

const char *ptr = &uartMsg;

[Jan H. (janiiix3)]

Peter D. schrieb:
> Du kannst eine Union aus dem Struct und einem Array definieren.
> Das
> Array kannst Du dann hochzählen.

Wie genau meinst du das?

[Jan H. (janiiix3)]

Teddy schrieb:
> Ich denke so:
>
> typedef struct
> {
>   const char projectName;
>   const char hardwareDate;
>   const char madeBy;
> }DevBoard_t;
>
> const DevBoard_t uartMsg;
>
> const char *ptr = &uartMsg;

Das haut so leider nicht hin.

[micha (Gast)]

ist IMHO undefiniertes Verhalten, aber wenn du Dich darauf verlässt dass 
die Element in der gleichen Reihenfolge und ohne padding hintereinander 
im Speicher liegen und der Anfang des structs identisch mit seinem 
ersten element ist, dann sollte es gehen.

Wenn der struct aber ehe nur die gleichen Element-typen (const char *) 
beinhaltet solltest Du einfach ein array nutzen, dann klappts auch mit 
der pointer-arithmetic :-)

[Jan H. (janiiix3)]

micha schrieb:
> ist IMHO undefiniertes Verhalten, aber wenn du Dich darauf
> verlässt dass
> die Element in der gleichen Reihenfolge und ohne padding hintereinander
> im Speicher liegen und der Anfang des structs identisch mit seinem
> ersten element ist, dann sollte es gehen.
>
> Wenn der struct aber ehe nur die gleichen Element-typen (const char *)
> beinhaltet solltest Du einfach ein array nutzen, dann klappts auch mit
> der pointer-arithmetic :-)

Wie würde das denn dann aussehen?

union test
{
  DevBoard_t Message;
  char uartMsg[];
};

So ungefähr?

[Wilhelm M. (wimalopaan)]

Jan H. schrieb:
> micha schrieb:
>> ist IMHO undefiniertes Verhalten, aber wenn du Dich darauf
>> verlässt dass
>> die Element in der gleichen Reihenfolge und ohne padding hintereinander
>> im Speicher liegen und der Anfang des structs identisch mit seinem
>> ersten element ist, dann sollte es gehen.
>>
>> Wenn der struct aber ehe nur die gleichen Element-typen (const char *)
>> beinhaltet solltest Du einfach ein array nutzen, dann klappts auch mit
>> der pointer-arithmetic :-)
>
> Wie würde das denn dann aussehen?
>

> union test
> {
>   DevBoard_t Message;
>   char uartMsg[];
> };
>

> So ungefähr?

Wenn die einzelnen C-Strings in DevBoard_t 0-terminated sind (wie es bei 
C-Strings angenommen wird), dann wird nur der erste String in DevBoard_t 
ausgegeben.

Edit: Sehe gerade, dass die Elemente in DecBoard_t gar keine char-Arrays 
sind, dann geht das natürlich so eh nicht.

Warum gibst Du die C-Strings nicht einfach direkt aus, statt so ein 
type-punning einzubauen (was zugegebenermaßen in C erlaubt und kein UB 
ist).

[Kirsch (Gast)]

Jan H. schrieb:
> typedef struct
> {
>   const char *projectName;
>   const char *hardwareDate;
>   const char *madeBy;
> }DevBoard_t;
>
> const DevBoard_t *uartMsg = &Message;
>
> Ist es irgendwie möglich auf die einzelnen Strings in dieser Struktur
> via. increment zu kommen?for (uint8_t i = 0 ; i < 3 ; i++)
> {
>   uart_puts((char*)(uartMsg++));
>         uart_puts("\r\n");
> }

typedef struct {
    const char *projectName;
    const char *hardwareDate;
    const char *madeBy;
} DevBoard_t;

char** test = ()

[Jan H. (janiiix3)]

Kirsch schrieb:
> char** test = ()

Und was zuweisen?

[Johann L. (gjlayde)]

Jan H. schrieb:
> Ist es irgendwie möglich auf die einzelnen Strings in dieser Struktur
> via. increment zu kommen?

Vielleicht ein Array mit benamten Indices anstatt Komponenten?  Eine 
Union wie oben genannt geht zwar auch, aber die Lesbarkeit solcher 
Konstrukte ist nicht sooo toll.

Beispiel:

enum
{
    ID_ProjectName,
    ID_HardwareDate,
    ID_MadeBy,
    ID_Count
};

typedef struct
{
  const char *strings[ID_Count];
} DevBoard_t;

const DevBoard_t Message =
{
    {
        [ID_ProjectName] = "Project",
        [ID_HardwareDate] = "Now",
        [ID_MadeBy] = "Me"
    }
};

const DevBoard_t *uartMsg = &Message;
extern void uart_puts (const char*);

void func (const DevBoard_t *board)
{
    for (int i = 0; i < ID_Count; i++)
    {
        uart_puts (board->strings[i]);
    }
    
    const char *const *str = board->strings;

    for (int i = 0; i < ID_Count; i++)
    {
        uart_puts (*str++);
    }
}

[Jan H. (janiiix3)]

Johann L. schrieb:
> Vielleicht ein Array mit benamten Indices anstatt Komponenten?  Eine
> Union wie oben genannt geht zwar auch, aber die Lesbarkeit solcher
> Konstrukte ist nicht sooo toll.

Wie würde es denn mit einem "union" aussehen?

[Wilhelm M. (wimalopaan)]

Etwa so:

typedef struct {
  const char *projectName;
  const char *hardwareDate;
  const char *madeBy;  
} DevBoard_t;

typedef union {
    DevBoard_t db;
    const char* array[3];
} Strings;

int main() {
    DevBoard_t db = {"abc", "def", "ghi"};
    Strings s = {db};

    printf("n: %s\n", s.array[0]);    
    printf("h: %s\n", s.array[1]);    
    printf("m: %s\n", s.array[2]);    
    
    const char** ptr = s.array;

    printf("n: %s\n", *ptr++);    
    printf("h: %s\n", *ptr++);    
    printf("m: %s\n", *ptr);    
}

Aber gut ist das nicht.

Besser schreibst Du eine eigene Funktion (in C) oder überlädst (in C++) 
eine entsprechende Ausgabefunktion.

[Jan H. (janiiix3)]

Johann L. schrieb:
> Beispiel:
> enum
> {
>     ID_ProjectName,
>     ID_HardwareDate,
>     ID_MadeBy,
>     ID_Count
> };
>
> typedef struct
> {
>   const char *strings[ID_Count];
> } DevBoard_t;
>
> const DevBoard_t Message =
> {
>     {
>         [ID_ProjectName] = "Project",
>         [ID_HardwareDate] = "Now",
>         [ID_MadeBy] = "Me"
>     }
> };
Diese Lösung finde ich recht interessant.
Wie sieht es mit einem "String Array" aus? Kann Ich das da auch so 
einfach einbinden?

     char *name[x];

[Johann L. (gjlayde)]

Jan H. schrieb:
> Diese Lösung finde ich recht interessant.
> Wie sieht es mit einem "String Array" aus? Kann Ich das da auch so
> einfach einbinden?

Das kommt auf die Anwendung an ob das besser ist:

enum { ... };

#define MAX_LEN 10

typedef struct
{
  const char strings[ID_Count][MAX_LEN];
} DevBoard_t;

const DevBoard_t Message =
{
    {
        [ID_ProjectName] = "Project",
        [ID_HardwareDate] = "Now",
        [ID_MadeBy] = "Me"
    }
};

extern void uart_puts (const char*);

const DevBoard_t *uartMsg = &Message;

void func (const DevBoard_t *board)
{
    for (int i = 0; i < ID_Count; i++)
    {
        uart_puts (board->strings[i]);
    }
    
    const char (*str)[MAX_LEN] = board->strings;

    for (int i = 0; i < ID_Count; i++)
    {
        uart_puts (*str++);
    }
}

Ein Problem ist, dass die maximale String-Länge statisch bekannt sein 
muss. Und während man ein const char* ändern und auf einen anderen 
String zeigen lassen kann, ist das bei einem const char[] nicht so.  Und 
ohne das "const" brauch man ein strcpy um einen neuen String 
hineinzubekommen.  Dafür brauch man beim Zugriff eine Indirektion 
weniger und keinen Platz zum Speichern der Adressen, allerdings gibt es 
auch Verschnitt bei ungleich langen Strings.

[Daniel A. (daniel-a)]

Ich denke hier wäre ein Array angebrachter. Beispiel:
http://rextester.com/NUW57351

#include <stdio.h>

#define DEVBOARD_INFO \
  X(PROJECT_NAME, "Name des Projekts") \
  X(HARDWARE_DATE, "Herstelldatum des Geräts") \
  X(MADE_BY, "Hergestellt von")

enum devboard_entries {
#define X(N,D) DEVBOARD_INFO_ ## N,
DEVBOARD_INFO
#undef X
DEVBOARD_INFO_COUNT
};

const char* devboard_info_description[] = {
#define X(N,D) D,
DEVBOARD_INFO
#undef X
};

typedef const char* devboard_info_t[DEVBOARD_INFO_COUNT];

devboard_info_t devboard = {
  [DEVBOARD_INFO_PROJECT_NAME] = "Mein Projekt",
  [DEVBOARD_INFO_HARDWARE_DATE] = "1970-1-1",
  [DEVBOARD_INFO_MADE_BY] = "mir",
};

void print_devboard_info(devboard_info_t info){
  for( int i=0; i<DEVBOARD_INFO_COUNT; i++ ){
    printf("%s: %s\n", devboard_info_description[i], info[i]);
  }
}

int main(){
  print_devboard_info(devboard);
}

Edit: war mal wieder zu spät...

[Jan H. (janiiix3)]

Johann L. schrieb:
> Jan H. schrieb:
> Diese Lösung finde ich recht interessant.
> Wie sieht es mit einem "String Array" aus? Kann Ich das da auch so
> einfach einbinden?
>
> Das kommt auf die Anwendung an ob das besser ist:enum { ... };
Deine erste Lösung reicht mir. Scheint erstmal perfekt zu passen.