Phenquestions
Größe verstehenvon:
Bevor wir in die Diskussion über die Größe des Operators eintauchen, wollen wir zuerst die Bedeutung des Operators verstehen understand. Ein Operator wird durch ein Token oder Symbol dargestellt, das verwendet wird, um eine Operation wie Addition, Subtraktion, Multiplikation, Division usw. durchzuführen. auf Werten oder Variablen (Operanden). "*" ist beispielsweise das Symbol, das verwendet wird, um die Multiplikationsoperation darzustellen, und es funktioniert mit zwei Operanden (Ergebnis = a * b ;). Dies ist ein Beispiel für einen binären Operator.
Wenn ein Operator jedoch nur mit einem Operanden arbeitet, nennen wir einen solchen Operator als unären Operator. Der Operator sizeof ist einer der unären Operatoren, die in der Programmiersprache C existieren, und er arbeitet anscheinend nur mit einem Operanden. Der Operator sizeof gibt die Größe des Operanden zurück. Das heißt, aus dem Rückgabewert des Operators Sizeof können wir eindeutig sagen, wie viele Bytes zugewiesen sind, um den jeweiligen Operanden im Computerspeicher zu halten.
Der Speicher eines Computers ist eine Sammlung von Speichereinheiten (i.e. Byte). Wenn sizeof (int) in einem bestimmten Computersystem vier zurückgibt, können wir sagen, dass eine Integer-Variable 4 Byte benötigt, um ihren Wert im Speicher dieses bestimmten Computersystems zu speichern. Beachten Sie außerdem, dass der Rückgabewert des Operators sizeof auch von den von Ihnen verwendeten Maschinen abhängt (32-Bit-System oder 64-Bit-System).
Syntax:
Größevon(Typ)Größevon(Ausdruck)
Der Rückgabetyp von sizeof ist size_t.
Beispiele:
Da wir nun die Größe des Operators verstehen und die Syntax kennen, sehen wir uns ein paar Beispiele an, die uns helfen werden, das Konzept besser zu verstehen.
- Sizeof für eingebaute Typen (Beispiel1.c)
- Sizeof für Array (Beispiel2.c)
- Sizeof für benutzerdefinierte Typen (Beispiel3.c)
- Sizeof für Variablen (Beispiel4.c)
- Sizeof für Ausdruck (Beispiel5.c)
- Praktische Verwendung von sizeof (Beispiel6.c)
Sizeof für eingebaute Typen (Beispiel1.c):
In diesem Programm werden wir sehen, wie der Operator sizeof für integrierte Datentypen wie int, char, float, double funktioniert. Schauen wir uns das Programm und die Ausgabe an.
#einschließenint main()
printf("Größe von char = %ld \n", sizeof(char));
printf("Größe von int = %ld \n", sizeof(int));
printf("Größe von Float = %ld \n", sizeof(float));
printf("Größe von double = %ld \n\n", sizeof(double));
printf("Größe von short int = %ld \n", sizeof(short int));
printf("Größe von long int = %ld \n", sizeof(long int));
printf("Größe von long long int = %ld \n", sizeof(long long int));
printf("Größe des langen Doubles = %ld \n", sizeof(long double));
0 zurückgeben;
Sizeof für Array (Beispiel2.c)
In diesem Programm werden wir sehen, wie der Operator sizeof für verschiedene Array-Typen verwendet wird. Im Fall eines Arrays wird der Operator sizeof zurückgegeben (No. der Elemente im Array * Sizeof (Arraytyp)). Wenn wir beispielsweise ein Array vom Typ Integer mit 10 Elementen (int SmartPhones [10] ;) deklarieren, gibt sizeof(Smartphones) Folgendes zurück:
(Nein. der Elemente in SmartPhones * sizeof(int)) = (10 * 4) = 40Schauen wir uns das Programm und die Ausgabe an.
#einschließenint main()
int SmartPhones[10];
char SmartPhoneNames[10];
doppelter SmartPhones-Preis[10];
printf("Größe von int = %ld \n", sizeof(int));
printf("Größe von char = %ld \n", sizeof(char));
printf("Größe von double = %ld \n", sizeof(double));
/* Ermitteln Sie die Größe des Arrays*/
printf("Größe von SmartPhones[10] = %ld \n", sizeof(SmartPhones));
printf("Größe von SmartPhoneNames[10] = %ld \n", sizeof(SmartPhoneNames));
printf("Größe von SmartPhonesPrice[10] = %ld \n", sizeof(SmartPhonesPrice));
0 zurückgeben;
Sizeof für benutzerdefinierte Typen (Beispiel3.c):
In diesem Beispiel sehen wir, wie der Operator sizeof für benutzerdefinierte Datentypen wie Structure und Union verwendet wird. Lassen Sie uns das Programm verwenden und die Ausgabe verstehen.
Wenn wir uns nun das Programm ansehen, können wir die Größe von SmartPhoneType manuell berechnen. Wie Sie unten sehen können, ist SmartPhoneType eine Struktur und enthält die folgenden Elemente:
- Anzahl der Zeichentypvariablen = 1 [sp_name]
- Anzahl der Variablen vom Typ Integer = 1 [sp_version]
- Anzahl der Float-Variablen = 3 [sp_length, sp_width, sp_height]
Aus Beispiel-1 haben wir Folgendes gesehen:
-
- Zeichengröße ist 1 Byte
- Die Größe einer Ganzzahl beträgt 4 Byte
- Die Größe eines Floats beträgt 4 Byte
Wenn wir also die Größe aller Elemente in der Struktur addieren, sollten wir in der Lage sein, die Größe der Struktur zu erhalten, d.e. Smartphone-Typ. Daher sollte die Größe der Struktur = (1 + 4 + 4 + 4 + 4) Byte = 17 Byte sein. Die Programmausgabe sagt jedoch, dass die Strukturgröße 20 beträgt. Die zusätzlichen 3 Bytes (sp_name, das ist ein Zeichen, benötigt 4 Bytes statt 1 Bytes), die der Struktur aufgrund des Strukturauffüllens zugewiesen wurden.
#einschließen/* Benutzerdefinierten Strukturtyp erstellen - SmartPhoneType*/
struct SmartPhoneType
char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
Smartphone;
/* Definiere einen benutzerdefinierten Unionstyp - SmartPhoneUnionType*/
Union SmartPhoneUnionType
char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
SmartPhone_u;
int main()
/* Ermitteln Sie die Größe von Struktur und Vereinigung*/
printf("Größe der Struktur = %ld \n", sizeof(SmartPhone));
printf("Größe der Vereinigung = %ld \n", sizeof(SmartPhone_u));
0 zurückgeben;
Sizeof für Variablen (Beispiel4.c):
Dieses Beispielprogramm zeigt, dass der Operator sizeof die Variable auch akzeptieren und die Größe der Variablen zurückgeben kann.
#einschließenint main()
/* Variablen und Array vom Typ char, int, float und double deklarieren */
char var_a, var_b[20];
int var_c, var_d[20];
float var_e, var_f[20];
doppelte var_g, var_h[20];
/* Größe von Variablen und Arrays herausfinden.
Dieses Programm zeigt, dass Variable auch
als Operand verwendet werden sizeof Operator*/
/* Größe von char, char-Variable und char-Array*/
printf("Größe von char = %ld \n", sizeof(char));
printf("Größe von var_a = %ld \n", sizeof(var_a));
printf("Größe von var_b[20] = %ld \n\n", sizeof(var_b));
/* Größe von int, int-Variable und int-Array*/
printf("Größe von int = %ld \n", sizeof(int));
printf("Größe von var_c = %ld \n", sizeof(var_c));
printf("Größe von var_d[20] = %ld \n\n", sizeof(var_d));
/* Größe von Float, Float-Variable und Float-Array*/
printf("Größe von Float = %ld \n", sizeof(float));
printf("Größe von var_e = %ld \n", sizeof(var_e));
printf("Größe von var_f[20] = %ld \n\n", sizeof(var_f));
/* Größe von Double, Double-Variable und Double-Array*/
printf("Größe von double = %ld \n", sizeof(double));
printf("Größe von var_g = %ld \n", sizeof(var_g));
printf("Größe von var_h[20] = %ld \n", sizeof(var_h));
0 zurückgeben;
Sizeof für Ausdruck (Beispiel5.c):
In diesem Beispielprogramm zeigen wir, dass der Operator sizeof auch einen Ausdruck akzeptieren und die Größe des resultierenden Ausdrucks zurückgeben kann return.
#einschließenint main()
int var_a = 5, var_b = 3;
doppelter var_c = 2.5, var_d = 4.5;
printf("Größe von int = %ld \n", sizeof(int));
printf("Größe von double = %ld \n\n", sizeof(double));
printf("Größe von var_a * var_b = %ld \n", sizeof(var_a * var_b));
printf("Größe von var_c * var_d = %ld \n", sizeof(var_c * var_d));
/* Hier multiplizieren wir eine Integer-Variable mit einer Double-Variablen.
Daher gibt der Operator sizeof die Größe der maximalen Größe zurück
variabel i.e. Variable vom Typ Double.*/
printf("Größe von var_a * var_c = %ld \n", sizeof(var_a * var_c));
0 zurückgeben;
Praktische Verwendung von sizeof (Beispiel6.c):
Dieses Beispielprogramm hilft Ihnen, einen praktischen Anwendungsfall der Größe des Operators zu verstehen. Der Sizeof-Operator ist sehr nützlich bei der Zuweisung des dynamischen Speichers vom Heap mit malloc. Schauen wir uns das Programm und die Ausgabe an.
#einschließen#einschließen
typedef-Struktur
char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
SmartphoneTyp;
int main()
/* Speicher im Heap-Speicher für die Aufnahme von fünf SmartPhoneTypes zuweisen
Variablen.
*/
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *)malloc(5 * sizeof(SmartPhoneType));
if(SmartPhone_Ptr != NULL)
printf("Speicher für 5 SmartPhoneType-Strukturvariablen in
der Heap-Speicher.\n");
sonst
printf("Bei der Heap-Speicherzuweisung ist ein Fehler aufgetreten!");
0 zurückgeben;
Fazit:
Der Sizeof ist ein wichtiger unärer Operator in der Programmiersprache C. Es hilft uns bei der Bestimmung der Größe primitiver Datentypen, benutzerdefinierter Datentypen, Ausdrücke usw. im Computerspeicher. Der Operator Sizeof spielt eine wichtige Rolle bei der Zuweisung von dynamischem Speicher in C mithilfe von malloc, calloc usw. im Heap-Speicher.
