wie groß ist meine struktur tatsächlich (struct alignment) ?

[doomcalyptica]

hallo, ich habe nur ein kleines verständnis problem mit structs
wieso ist der

#include <stdio.h>
#include <string.h>


struct klasse{
	char liste[255];
	char name[255];
	char anrede[255];
	char vorname[255];
	char wohnort[255];
	char adresse[255];
	char plz[10];
	int alter;
	int gewicht;

};

struct klasse s1={"LEER","LEER","LEER","LEER","LEER","LEER","LEER",0,0};
struct klasse s2={"LEER","LEER","LEER","LEER","LEER","LEER","LEER",0,0};
struct klasse s3={"LEER","LEER","LEER","LEER","LEER","LEER","LEER",0,0};


void eingabe(struct klasse &ein){
	printf("\nanrede: ");
	scanf("%s",&ein.anrede);
	printf("\nvorname: ");
	scanf("%s",&ein.vorname);
	printf("\nname: ");
	scanf("%s",&ein.name);
	printf("\nwohnort: ");
	scanf("%s",&ein.wohnort);
	printf("\nplz: ");
	scanf("%s",&ein.plz);
	printf("\nadresse: ");
	scanf("%s",&ein.adresse);
	printf("\nalter: ");
	scanf("%d",&ein.alter);
	printf("\ngewicht: ");
	scanf("%d",&ein.gewicht);
}


void ausgabe(struct klasse geb){
	printf("\n\n\n\t\t%s\n\n",geb.liste);
	printf("Daten von %s %s %s\n",geb.anrede,geb.vorname,geb.name);
	printf("wohnort/plz: %s/%s\n",geb.wohnort,geb.plz);
	printf("adresse: %s\n",geb.adresse);
	printf("alter %d, gewicht %d\n",geb.alter,geb.gewicht);
}


void main(){

	int wahl;

	printf("deine wahl\n");
	printf("1 -> teilnehmer 1\n");
	printf("2 -> teilnehmer 2\n");
	printf("3 -> teilnehmer 3\n");
	scanf("%d",&wahl);

	switch(wahl){
	case 1:
		eingabe(s1);
		break;
	case 2:
		eingabe(s2);
		break;
	case 3:
		eingabe(s3);
		break;
	default:
		printf("nicht vorhanden\n");
		break;
	}

	ausgabe(s1);
	ausgabe(s2);
	ausgabe(s3);

	printf("\ndie grosse in bytes der \"klasse\": %d\n",sizeof(klasse));
	printf("\ndie grosse in bytes von \"s1\": %d\n",sizeof(s1));
}

ich habe mir eine struktur namens klasse angelegt. nun hab ich in meinem buch etwas von struct alignment gelesen und wollte mal schauen welche groesse meine structur tatsächlich im speicher einnimt. ich bin etwas über die ausgabe von:

	printf("\ndie grosse in bytes der \"klasse\": %d\n",sizeof(klasse));
	printf("\ndie grosse in bytes von \"s1\": %d\n",sizeof(s1));

verwundert, beide, also klasse und s1 sind gleich groß. ich habe erwartet, das klasse drei mal goßer ist als zb s1. weil im prinzip lege ich 3 structs-aliases an.
und irgendwo muss ja der platz im speicher für s1,s2 und s3 sein ....
hat darauf jemand eine antwort ?

[r00t043]

jupp, hab ich.
klasse ist nur eine Beschreibung wie dein struct aufgebaut ist und besitzt garkeinen Speicher und somit ist die Groesse auch nur theoretisch, waehrend s1, s2 und s3 irgendwo bei dir im Speicher liegen und weil sie vom Typ 'struct klasse' sind muessen sie auch genauso gross sein wie die 'struct klasse' die du oben beschrieben hast.
Ich hoffe, das ist einigermassen verstaendlich

[doomcalyptica]

jo das war es danke
aber ich habe nochmal so ein ding:

#include <stdio.h>

struct test{
	int d:1;
	int a:1;
}def;

void main(){
	def.d=4000000000;
	def.a=3999999999;
	printf("%d\n",sizeof(def));
}

er zeigt mir doch tatsächlich 4 bytes an ...
aber wennich die anderen bits widda zuschalte, dann zeigt er mir woe gewohnt 8 bytes an

#include <stdio.h>

struct test{
	int d;
	int a;
}def;

void main(){
	def.d=4000000000;
	def.a=3999999999;
	printf("%d\n",sizeof(def));
}

die erste ausgabe verstehe ich einfach nicht.

[wraith]

Das zweite Bsp. sollte dir klar sein, zwei int (je 4 Bytes), macht 8 Bytes (keine PaddingBytes nötig).

In deinem ersten Bsp. hast du zwei Bit-Feld-Member, eines mit Namen d, das einem Bit entsprechen soll, und damit genau zwei verschiedene Werte (das muß nicht zwingend 0 und 1 sein) aufnehmen kann (deine spätere Zuweisung macht also nicht das was du willst).
Und einen zweiten Member mit Namen a, und mit selbigen Eigenschaften wie obiger.

Der Typ ist int, und damit belegt dein erster Bit-Feld-Member bereits 4 Byte, obwohl nur mit einem Bit (zwei Zustände), deklariert.
Dein zweiter Member braucht auch nur ein Bit, und passt damit ja noch locker in den ersten int mit rein, also ist es unnötig vom Compiler nochmal einen int (mit wieder 4 Bytes anzulegen), um dort das zweite Bit abzuspeichern.
Man kann das erzwingen mit einem unbenannten Bit-Feld der Größe 0.

Wenn du statt int in deinem ersten Bsp. zb. char nimmst, dann wird dir sizeof wahrscheinlich 1 ausgeben.char gehört aber zu den implementierungsabhängigen Typen, die man bei einem Bit-Feld benutzen kann, daher muß es nicht funktionieren.