Array in Struktur füllen

[Marco Oklitz (Gast)]

nabend !

ich komm grad irgendwie nicht weiter und frag dehalb mal graderaus:

was mach ich hier falsch:

ich will den dateninhalt einer struktur welche nicht global oder 
statisch ist initialisieren.

.......
typedef struct s_picture            // Struktur für ein Einzelbild
{
    int             pic_id;     // ID des Einzelbildes innerhalb der Animation
    int             ani_id;     // ID der dazugeörigen Animation
    int             ms_pause;   // Anzeigedauer des Einzelbildes
    unsigned char   matrix[5][5][5];    //125 Byte Matrix der einzelnen LEDs
} s_pic;
.......
void clear_s_picture(s_pic *bild)
{
    bild->pic_id=0;
    bild->ani_id=0;
    bild->ms_pause=1000;
    bild->matrix=  {
    {    {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }    }  ,
    {    {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }    }  ,
    {    {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }    }  ,
    {    {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }    }  ,
    {    {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }  ,  {  0,  0,  0,  0,  0  }    }
};



}

gibt beim kompilieren in zeile
  bild->matrix=  {
den fehler:

main.c|169|error: expected expression before ‘{’ token|

keine Ahnung !

Muß ich jedes Element des Arrays einzeln auf 0 setzen ??

mfg marco

[Johann L. (gjlayde)]

Da gibt's mehrere Möglichkeiten

typedef struct
{
    int pic_id;
    int ani_id;
    int ms_pause;
    unsigned char matrix[5][5][5];
} s_pic;

#define N {0, 0, 0, 0, 0 }

void clear_s_picture (s_pic *bild)
{
    *bild = (s_pic) 
    {
        0, 0, 1000,
        { 
            { N, N, N, N, N },
            { N, N, N, N, N },
            { N, N, N, N, N },
            { N, N, N, N, N },
            { N, N, N, N, N }
        }
    };
}
#undef N

#include <string.h>

void clear_s_picture2 (s_pic *bild)
{
    memset (bild, 0, sizeof (s_pic));
    
    bild->ms_pause = 1000;
}

wohei die erste nicht standardkonform ist, wenn ich mich recht erinnere 
(GNU-C).

Die zweite Variante dürfte merklich effizienter sein.

Als dritte Möglichkeit gibt's nocht: ne (statische) Variable mit 
Initializer anlegen und kopieren.

[Marco Oklitz (Gast)]

Ja Ok ich sehe die struktur will als ganzes initialisiert werden

deine zweite lösung probier ich nachher mal aus, die is schön kurz.

um große arrays zu füllen hab ich auch memcpy benutzt , aber da brauch 
man ja auch ne vorlage. memset is da doch eleganter.

danke das hilft mir weiter

mfg marco

[Yalu X. (yalu) (Moderator)]

Johann L. schrieb:
> wohei die erste nicht standardkonform ist, wenn ich mich recht erinnere
> (GNU-C).

Doch (C99).

> Die zweite Variante dürfte merklich effizienter sein.

GCC 4.6.1 mit -Os erzeugt für beide Varianten exakt den gleichen Code.
Mit -O2 oder -O3 ist die memset-Variante größer und etwas langsamer, da
der GCC dort memset-Code generiert, der für eine variable und nicht für
eine bekannterweis durch 4 teilbare Blockgröße optimiert ist.

[Johann L. (gjlayde)]

Yalu X. schrieb:

> Mit -O2 oder -O3 ist die memset-Variante größer und etwas langsamer, da
> der GCC dort memset-Code generiert, der für eine variable und nicht für
> eine bekannterweis durch 4 teilbare Blockgröße optimiert ist.

hmmm. Eigentlich kann GCC das, wär evtl. ne Frage in 
[e-mail] wert.  Möglicherweise liegt's daran, daß nicht 
bekannt ist, ob bild aligned ist.  Hilft __attribute__((aligned(4)))?

[Yalu X. (yalu) (Moderator)]

Johann L. schrieb:
> Hilft __attribute__((aligned(4)))?

Nein, das ändert überhaupt nichts.

GCC mit -O2 unterscheidet bei memset zwischen variabler und fester
Blockgröße. Bei variabler Größe wird memset aus der Bibliothek aufge-
rufen. Bei fester Größe wird die Funktion geinlinet, aber so, als wäre
die Größe variabel. D.h. auch wenn die Größe ein Vielfaches von 4 ist,
wird am Ende trotzdem noch überprüft, ob noch eine 16- oder 8-Bit-
Schreibaktion erforderlich ist. Den Modulo-4-Check könnte er ja auch
schon zur Compilezeit machen und damit immer optimalen Code generieren.

Im Gegensatz zu -O2 wird bei -Os und bekannter Blockgröße der Modulo-4-
Check sehr wohl gemacht. Das Ergebnis ist eine einfache Schleife
(maximal kurz), die entweder einen 4-, 2- oder 1-Byte-Schreibbefehl
(je nach Modulo-4-Rest) enthält.

[Johann L. (gjlayde)]

→ http://gcc.gnu.org/bugzilla