Die Aufzählung ist ein grundlegender Datentyp in der Sprache C, mit dem Daten präziser und leichter lesbar werden können.
enum colors
{
red,blue,yellow
}clo;
int main(void)
{
clo=red;
printf("%d\n",clo); //0
clo=yellow;
printf("%d\n",clo); //2
return 0;
}
Der Standardwert des ersten Aufzählungselements ist eine Ganzzahl 0, und der Wert der nachfolgenden Aufzählungselemente wird dem vorherigen Element um 1 hinzugefügt. In diesem Beispiel definieren wir den Wert des ersten Aufzählungselements als 1 und des zweiten als 2
enum DAY
{
MON, TUE=3, WED, THU
};
Bei Aufzählungselementen, die keinen Wert angeben, der Wert des vorherigen Elements plus eins. Mit anderen Worten, der Wert von MON ist 0, der Wert von TUE ist 3, der Wert von WED ist 4 und der Wert von THU ist 5
Wie durchquere ich aufgezählte Typen?
In der C-Sprache werden Aufzählungstypen als int-Typen oder int-Typen ohne Vorzeichen behandelt, sodass es nicht möglich ist, Aufzählungstypen gemäß der C-Sprachspezifikation zu durchlaufen.
Wenn Sie den Aufzählungstyp durchlaufen möchten, muss der Aufzählungstyp kontinuierlich sein, um eine bedingte Durchquerung zu erreichen.
#include <stdio.h>
enum DAY
{
MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;
int main(void)
{
// 遍历枚举元素
for (day = MON; day <= SUN; day++) {
printf("枚举元素：%d \n", day);
}
}
Mit Schalter kombinieren
enum colors
{
red,blue,yellow
};
int main(void)
{
enum colors clo;
scanf("%d",&clo);
switch(clo)
{
case red:
printf("你喜欢红色\n");
break;
case blue:
printf("你喜欢蓝色\n");
break;
case yellow:
printf("你喜欢黄色\n");
break;
default:
printf("没有你喜欢的颜色\n");
}
return 0;
}
Speicher belegen:
Wird durch Hinzufügen einer Linkbeschreibung zitiert . Der
Aufzählungstyp bezieht sich auf eine Sammlung benannter Ganzzahlkonstanten. Das heißt, der Aufzählungstyp ist im Wesentlichen eine Sammlung einer Reihe von Konstanten, aber diese Konstanten haben ihre eigenen Namen. Der Aufzählungstyp ist ein benutzerdefinierter Datentyp.
Aufzählungsvariablen sind Variablen, die durch Aufzählungstypen definiert werden. Die Größe der Aufzählungsvariablen, dh die Größe des vom Aufzählungstyp belegten Speichers. Aufgrund der Zuweisung von Aufzählungsvariablen kann jeweils nur eine Konstante in der Aufzählungsstruktur gespeichert werden. Daher entspricht die Größe der Aufzählungsvariablen im Wesentlichen der Größe des von der Konstante belegten Speicherplatzes (die Konstante ist vom Typ int, und der int-Typ im aktuellen Mainstream-Compiler beträgt in 32-Bit-Maschinen und 64-Bit im Allgemeinen 4 Byte Maschinen), Aufzählung Gleiches gilt für die Größe des von Typen belegten Speichers.
Darüber hinaus können Sie die integrierte Indikatorgröße des Compilers verwenden, um die Größe der Aufzählungsvariablen (oder des Aufzählungstyps) zur Überprüfung zu berechnen.
例子：
int main()
{
enum number {
one = 1,
two = 2,
three = 3,
foure = 4,
};
enum number num1;
printf("int sizeof:%d\n",sizeof(int));//int类型占用几个字节；
printf("enum number sizeof:%d\n",sizeof(enum number));//枚举结构enum number占用几个字节；
printf(" variable num1 sizeof:%d\n",sizeof(num1));//定义后的枚举变量占用几个字节；
num1 = three;
printf("after 'num1 = three' ,variable num1 sizeof:%d\n",sizeof(num1));//赋值后的枚举变量占用几个字节；
}
Kommen Sie zu einer Frage: Berechnen Sie den Speicherplatz, den ein Klassenobjekt belegt
class A
{
int i;
union U
{
char buff[13];
int j;
}u;
void foo(){
};
typedef char* (*f) (void*);
enum {
red,blue,pink} color;
};
int main(void)
{
A a;
printf("%d\n",sizeof(a));
return 0;
}
Einfache Analyse:
- Shaping i belegt 4 Bytes
- Union U, der größte Datentyp belegt 4 Bytes, das größte Mitglied belegt 13 Bytes und die Speicherausrichtung ist ein Vielfaches von 16.
- Die Funktion foo () nimmt keinen Platz ein
- Der Typ char * definiert keine Variablen und belegt keinen Platz
- enum belegt 4 Bytes,
also 24 Bytes