Initialisierung von Variablen & Arrays in Strukturen

[R3FRESH]

Man soll doch, wenn man Variablen & Arrays definiert, auch unbedingt sofort initialisieren, damit der Inhalt der Variable/der Arrayelemente von vorne weg klar ist.

So zB:

int x = 0;
int array1 [10] = {0};
int array2 [5] [5] = {{0}};

Wie is das jetzt aber bei Strukturen?
Ich habe zB folgende 2 Strukturen (koord & daten):

/* Definition der Struktur 'koord' mit 2 Strukturvariablen 'x' & 'y'; Deklaration von 2 Instanzen 'erste' & 'zweite' */
struct koord
{
    int x;
    int y;
} erste, zweite;

/* Definition der Struktur 'daten' mit 1 Array 'a'; Deklaration von 1 Instanz 'datensatz' */
struct daten
{
    int a [4];
} datensatz;

Wenn ich aber die Variablen oder das Array initialisieren möchte, gibts ne Compilermeldung 'Ein Datenmemberinitialisierer ist nicht zulässig.'
Also ist initialisieren in Strukturen nicht wichtig?

[DirkB]

Wie versuchst du das denn?
Wie sieht die Zeile mit dem Fehler aus?

[SeppJ]

Lass mich raten, du hast dies gemacht:

struct koord
{
    int x = 0;
    int y = 0;
} erster;

Das geht nicht. Die Initialisierung erfolgt analog zu der anderer Variablen:

struct koord
{
    int x;
    int y;
};

struct koord erster = {0,0};

[R3FRESH]

Oh sorry, habe ich nich klar aufgelistet, mein Fehler.
So wie ichs gewohnt bin, Variablen & Arrays zu initialisieren, also mit 0.
Der Compiler markiert dann das =-Zeichen & bringt die oben genannte Fehlermeldung.

struct koord
{
    int x = 0;
    int y = 0;
} erste, zweite;

struct daten
{
    int a [4] = {0};
} datensatz;

[R3FRESH]

@SeppJ - Ah ok. Da kann ich aber die Definition, die Deklaration & die Initialisierung der Variablen in einem Stück erledigen, oder?

struct koord
{
    int x;
    int y;
} erste = {0, 0}, zweite = {0, 0};

Hm, & wie sieht die Initialisierung dann bei Arrays aus?

[DirkB]

Die Antwort hat SeppJ ja schon geraten.
Du kannst die Initialisierung aber auch direkt nach der definition machen.

struct daten
{
    int a [4];
} datensatz = {0};

[R3FRESH]

@DirkB - ok & jetzt nochmal weitergefragt, wie sieht ne Initialisierung für mehrere Arrays mit jeweils 1 Dimension aus? & wie für mehrere Arrays mit mehreren Dimensionen?

/* mehrere Arrays mit jeweils 1 Dimension */
	struct daten
	{
		int	 a [4],
				b [10],
				c [15],
				d [20];
	} datensatz;

	/* mehrere Arrays mit mehreren Dimensionen */
	struct daten
	{
		int	 e [4] [5],
				f [10] [20] [30],
				g [15] [20],
				h [20] [25];
	} datensatz;

[SeppJ]

Du musst nur mehr {} verschachteln, um innere zusammengesetzte Datentypen zu initialisieren.

[R3FRESH]

Ne Initialisierung für ne Struktur mit gemsichten Strukturelementen, also Variablen, mehrere Arrays mit jeweils 1 Dimension & mehrere Arrays mit mehreren Dimensionen würde dann wie folgt aussehen?!

/* Variablen, mehrere Arrays mit jeweils 1 Dimension & mehrere Arrays mit mehreren Dimensionen */
	struct daten
	{
		int	 x,
				y;
		int	 a [4],
				b [10],
				c [15],
				d [20],
				e [4] [5],
				f [10] [20] [30],
				g [15] [20],
				h [20] [25];
	} erste = {0, 0}, zweite = {0, 0}, datensatz = {{0}, {0}, {0}, {0}, {0, 0}, {0, 0, 0}, {0, 0}, {0, 0}};

[SeppJ]

Nein. Denke daran, wie du ein Array initialisierst. Dann rate mal, wie du wohl ein Array von Arrays initialisierst. Und so weiter.

edit: Jetzt hast du es überarbeitet, aber es wird immer verwirrender. Du hast eine Variable, die du Initialisieren willst. Normalerweise machst du das, indem du etwas schreibst wie int foo = 0; . Diese Variable ist jedoch ein komplexer Datentyp und hat wiederum mehrere Felder. Du weißt auch, wie du diese Untervariablen initialsisiert, z.B. int foo[3] = {1,2,3}; oder struct bar{ int a,b;} foo = {1,2}; . Und jetzt musst du doch bloß 1+1 zusammenzählen und wir ausmalen, wie man das wohl macht, wenn die Untervariablen selber wieder komplexe Datentypen sind.

[Wutz]

SeppJ schrieb:

Du musst nur mehr {} verschachteln, um innere zusammengesetzte Datentypen zu initialisieren.

Nein, muss er nicht.
Solange der Default-Initialisierer 0 verwendet wird, reicht ein einfaches

= {0}

für beliebig tief verschachtelte Arrays und/oder Strukturen aus.
Außerdem werden keine Datentypen initialisiert sondern Speicherbereiche, die durch Variablennamen repräsentiert werden.

[R3FRESH]

omg, gleich is der Durchblick weg 0.o

Also nochmal von vorne.
So definiere ich ne Struktur, deklariere sie mit ner Instanz & initialisiere die 2 Strukturvariablen.

/* Defi einer Struktur, Dekla mit Instanz 'erste' & Ini der 2 Strukturvariablen */
	struct daten
	{
		 int	x,
				y;
	} erste = {5, 6};

Dann erweitere ich die Struktur um 1 eindimensionales Array & initialisiere das Array mit der Instanz 'datensatz'.

/* Strukturerweiterung um Array, Instanz 'datensatz' & Ini des Arrays */
	struct daten
	{
		 int	x,
				y;
		 int	a [4];
	} erste = {5, 6}, datensatz = {1, 2, 3, 4};

Is das bis hier hin so mal richtig?

[DirkB]

struct daten
    {
         int    x,
                y;
         int    a [4];
    } erste = {5, 6}, datensatz = {1, 2, {3,    4} };
//                                 x  y  a[0] a[1]

[Wutz]

R3FRESH schrieb:

/* Defi einer Struktur, Dekla mit Instanz 'erste' & Ini der 2 Strukturvariablen */
	struct daten
	{
		 int	x,
				y;
	} erste = {5, 6};

/* Definition einer Struktur, Definition einer Variable vom Typ Struktur (Definition bedeutet immer auch gleichzeitig eine (implizite) Deklaration) & Ini der 2 Strukturvariablen */

/* Strukturerweiterung um Array, Instanz 'datensatz' & Ini des Arrays */
    struct daten
    {
         int    x,
                y;
         int    a [4];
    } erste = {5, 6}, datensatz = {1, 2, 3, 4};

erste.x=5
erste.y=6
erste.a[0]=0
erste.a[1]=0
erste.a[2]=0
erste.a[3]=0

datensatz.x=1
datensatz.y=2
datensatz.a[0]=3
datensatz.a[1]=4
datensatz.a[2]=0
datensatz.a[3]=0

/* wenn die vorgegebenen Initialisierer nicht "ausreichen", wird immer "aufgefüllt" genauso, als wenn =0 dort stehen würde, Klammerung wie oben erwähnt, egal */