Größe des Operators in C -Sprache

In diesem Artikel erfahren wir den Größe des Operators in C. Es ist ein weit verbreiteter unärer Operator in der eingebetteten Softwareentwicklung, was uns hilft, die Größe des Operanden herauszufinden. Daher hilft uns der Rückgabewert des Größenoperators, die Anzahl der im Computerspeicher zugewiesenen Bytes zu verstehen, um die bestimmte Variable oder den Datentyp zu halten.

Verständnis der Größe:

Bevor wir uns mit der Diskussion der Größe des Operators eintauchen, lassen Sie uns zunächst die Bedeutung des Bedieners verstehen. Ein Operator wird durch ein Token oder ein Symbol dargestellt, das zur Durchführung einer Operation wie Addition, Subtraktion, Multiplikation, Teilung usw. verwendet wird. auf Werte oder Variablen (Operanden). Beispielsweise ist „ *“ das Symbol, das zur Darstellung des Multiplikationsvorgangs verwendet wird, und es funktioniert bei zwei Operanden (Ergebnis = a * b;). Dies ist ein Beispiel für einen binären Operator.

Wenn ein Bediener jedoch nur an einem Operanden arbeitet, rufen wir einen solchen Operator als unärer Operator an. Der Größenoperator ist einer der unartigen Operatoren, die in der C -Programmiersprache existieren, und erscheint anscheinend nur an einem Operanden. Der Größe des Operators gibt die Größe des Operanden zurück. Das bedeutet, dass wir aus dem Rückgabewert des Größe des Operators klar sagen können.

Der Speicher eines Computers ist eine Sammlung von Speichereinheiten (ich.e. Byte). Wenn sizeof (int) in einem bestimmten Computersystem vier zurückgibt, können wir sagen, dass eine Ganzzahlvariable 4 Bytes benötigt, um ihren Wert im Speicher dieses spezifischen Computersystems zu halten. Bitte beachten Sie außerdem, dass der Rückgabewert des Größe des Operators auch von den von Ihnen verwendeten Maschinen abhängt (32-Bit-System oder 64-Bit-System).

Syntax:

Größe (Typ)
Größe (Expression)

Die Rückgabetyp der Größe ist size_t.

Beispiele:

Da wir nun den Größe des Operators verstehen und die Syntax kennen, sollten wir uns einige Beispiele ansehen, die uns helfen, das Konzept besser zu verstehen.

• Größe für integrierte Typen (Beispiel1.C)
• Größe für Array (Beispiel2.C)
• Größe für benutzerdefinierte Typen (Beispiel3.C)
• Größe für Variablen (Beispiel4.C)
• Größe für Expression (Beispiel5.C)
• Praktische Verwendung von Größe (Beispiel6).C)

Größe für integrierte Typen (Beispiel1.C):

In diesem Programm werden wir sehen, wie der Sizeof-Operator für integrierte Datentypen wie int, char, float, doppelt funktioniert. Schauen wir uns das Programm und die Ausgabe an.

#enthalten
int main ()

printf ("Größe von char = %ld \ n", sizeof (char));
printf ("Größe von int = %ld \ n", Größe (int));
printf ("Größe von Float = %ld \ n", Größe von (float));
printf ("Größe von Double = %ld \ n \ n", Größe (doppelt));
printf ("Größe von kurzer int = %ld \ n", Größe (kurz int));
printf ("Größe von long int = %ld \ n", Größe (lang int));
printf ("Größe des langen langen int = %ld \ n", Größe von (long lang int));
printf ("Größe von langem Doppel = %ld \ n", Größe (langes Doppel));
Rückkehr 0;

Größe für Array (Beispiel2.C)

In diesem Programm werden wir sehen. Im Falle eines Arrays kehrt der Größe des Operators zurück (Nein. von Elementen im Array * sizeof (Array -Typ)). Wenn wir beispielsweise ein ganzzahliges Array von 10 Elementen (int Smartphones [10]) deklarieren;) kehrt die Größe (Smartphones) zurück:

(NEIN. von Elementen in Smartphones * sizeof (int)) = (10 * 4) = 40

Schauen wir uns das Programm und die Ausgabe an.

#enthalten
int main ()

int Smartphones [10];
char SmartPhonenamen [10];
doppelter Smartphonesprice [10];
printf ("Größe von int = %ld \ n", Größe (int));
printf ("Größe von char = %ld \ n", sizeof (char));
printf ("Größe von Double = %ld \ n", Größe (doppelt));
/* Finden Sie die Größe des Arrays*/
printf ("Größe von Smartphones [10] = %ld \ n", Größe von (Smartphones));
printf ("Größe der SmartPhonenamen [10] = %ld \ n", sizeof (SmartPhonenamen));
printf ("Größe von Smartphonesprice [10] = %ld \ n", sizeof (smartphonesprice));
Rückkehr 0;

Größe für benutzerdefinierte Typen (Beispiel3.C):

In diesem Beispiel werden wir sehen. Verwenden wir das Programm und verstehen wir die Ausgabe.

Betrachten Sie nun das Programm und wir können die Größe von SmartPhonetypen manuell berechnen. Wie Sie unten sehen können, ist SmartPhonType eine Struktur und enthält die folgenden Elemente:

• Anzahl der Zeichentypvariablen = 1 [sp_name]
• Anzahl der Ganzzahltypvariablen = 1 [sp_version]
• Anzahl der Float -Typ -Variablen = 3 [sp_length, sp_width, sp_height]

Aus dem Beispiel-1 haben wir das gesehen:

• • Die Größe des Charakters ist 1 Byte
  • Die Größe einer Ganzzahl beträgt 4 Bytes
  • Die Größe eines Schwimmers beträgt 4 Bytes

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, i, i.e. SmartPhonetype. Daher sollte die Größe der Struktur = (1 + 4 + 4 + 4 + 4) Bytes = 17 Bytes sein. Die Programmausgabe besagt jedoch, dass die Strukturgröße 20 beträgt. Die zusätzlichen 3 Bytes (sp_name, das ein Zeichen ist, nimmt 4 Bytes anstelle von 1 Byte), die für die Struktur aufgrund der Strukturpolsterung zugewiesen wurden.

#enthalten
/* Erstellen Sie einen benutzerdefinierten Strukturtyp - SmartPhonType*/
struct SmartPhonetype

char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
Smartphone;
/* Definieren Sie einen benutzerdefinierten Gewerkschaftstyp - SmartphoneUnionType*/
Union SmartphoneUnionType

char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
Smartphone_U;
int main ()

/* Finden Sie die Größe von Struktur und Vereinigung heraus*/
printf ("Größe von struktur = %ld \ n", Größe (Smartphone));
printf ("Größe von Union = %ld \ n", sizeof (smartphone_u));
Rückkehr 0;

Größe für Variablen (Beispiel4.C):

Dieses Beispielprogramm zeigt, dass der Größenoperator auch die Variable akzeptieren und die Größe der Variablen zurückgeben kann.

#enthalten
int main ()

/ * Deklare char, int, float und doppeltypvariable und array */
char var_a, var_b [20];
int var_c, var_d [20];
float var_e, var_f [20];
double var_g, var_h [20];
/* Ermitteln Sie die Größe von Variablen und Array.
Dieses Programm zeigt, dass auch Variable kann
als Operandengröße des Operators verwendet werden*/
/* 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 variabler und int array*/
printf ("Größe von int = %ld \ n", Größe (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 des Schwimmers, Schwimmervariable und Float Array*/
printf ("Größe von Float = %ld \ n", Größe von (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 der doppelten, doppelten Variablen und Doppelarray*/
printf ("Größe von Double = %ld \ n", Größe (doppelt));
printf ("Größe von var_g = %ld \ n", sizeof (var_g));
printf ("Größe von var_h [20] = %ld \ n", sizeof (var_h));
Rückkehr 0;

Größe für Expression (Beispiel5.C):

In diesem Beispielprogramm werden wir zeigen, dass der Größe des Operators auch einen Ausdruck akzeptieren und die Größe des resultierenden Ausdrucks zurückgeben kann.

#enthalten
int main ()

int var_a = 5, var_b = 3;
double var_c = 2.5, var_d = 4.5;
printf ("Größe von int = %ld \ n", Größe (int));
printf ("Größe von Double = %ld \ n \ n", Größe (doppelt));
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 Ganzzahlvariable mit einer doppelten Variablen.
Daher gibt der Größe des Operators die Größe der maximalen Größe zurück
Variable i.e. Variable der Doppeltyp.*/
printf ("Größe von var_a * var_c = %ld \ n", sizeof (var_a * var_c));
Rückkehr 0;

Praktische Verwendung von Größe (Beispiel6).C):

Dieses Beispielprogramm hilft Ihnen, einen praktischen Anwendungsfall des Größe des Operators zu verstehen. Der Größenoperator ist sehr nützlich, während der dynamische Speicher aus dem Haufen mit malloc zugewiesen wird. Schauen wir uns das Programm und die Ausgabe an.

#enthalten
#enthalten
Typedef Struct

char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
SmartPhonType;
int main ()

/* Zuwach im Heap -Speicher für das Halten von fünf SmartPhonetypen zuweisen
Variablen.
*/
SmartPhonType * Smartphone_Ptr = (SmartPhonType *) Malloc (5 * sizeof (SmartPhonType));
if (smartphone_ptr != Null)

printf ("Speicher für 5 Smartphonetype -Strukturvariablen in zugewiesen
der Haufen Speicher.\N");

anders

printf ("Fehler während der Heap -Speicherzuweisung aufgetreten!");

Rückkehr 0;

Abschluss:

Die Größe von ist ein wichtiger unärer Operator in der C -Programmiersprache C. Es hilft uns bei der Ermittlung der Größe primitiver Datentypen, benutzerdefinierten Datentypen, Ausdrücke usw. im Computerspeicher. Der Größe des Operators spielt eine wichtige Rolle bei der Zuweisung eines dynamischen Speichers in C mit malloc, calloc usw. im Heap -Speicher.