C ++ Größe von

Die Größe () ist ein Operator in C++. Es ist ein unärer Operator, der den Programmierern hilft, die Größe der Operanden zu bestimmen, die sie verwenden. Ein integraler Typ, der typischerweise mit der Größe „T“ bezeichnet wird, ist das Ergebnis dieses Operators. Dieser Bediener wird normalerweise mit primitiven Datentypen wie ganzzahliger, float, Zeiger usw. verwendet. Darüber hinaus kann es die Größe einer ausgefeilteren Datentypen wie Gewerkschaften und Strukturen liefern. Es ist ein Bediener, der die Größe des Operanden berechnen und die Größe eines beliebigen Datentyps zur Kompilierungszeit bestimmen kann. Die Größe ist die Menge an RAM, die vom Computer verwendet wird und durch den Betrieb der Größe () bestimmt wird.

Syntax des Sizeof () -Operators in c++

Im Folgenden beschreibt die Syntax des SizeOf () Operators:

# sizeof (Name von Data_Type);

Bei Verwendung mit dem ersten Objekttyp gibt die SizeOF () -Funktion die Größe des Objekts in Bytes für den Typ des Objekts aus, der gesendet wird. Die Größe des Elements, der in der Art des Ausdrucks, gemessen in Bytes, ist der zweite Typ. Nachdem der Ausdruck bewertet wurde, bleibt die Größe gleich.

Beispiel 1:

Wenn die Datentypen wie int, float, char usw. Die Funktion wird lediglich die Menge an RAM verwendet, die diesem bestimmten Datentyp zugeteilt wird.

#enthalten
Verwenden von Namespace STD;
int main ()

std :: Cout << "Size of data type int : " <std :: Cout << "Size of data type float : " <std :: Cout << "Size of data type double: " <std :: Cout << "Size of data type char: " <Rückkehr 0;

Durch die Verwendung des SizeOF () -Operators mit dem Cout-Befehl bewerten wir die Größe der integrierten Datentypen in der oben genannten Anwendung. Wie wir in der folgenden Ausgabe sehen können, gibt der Betrieb der Größe () die gleiche Antwort wie wir es erwarten würden.

Beispiel 2:

Das Programm verwendet, wenn ein Klassentyp Operand ist, den sizeof () operator. Hier ist eine Illustration:

#enthalten
Verwenden von Namespace STD;
Klasse mybase_class

int x;
;
int main ()

Mybase_class y;
std :: Cout << "Size of Base class is : "<Rückkehr 0;

Mit nur einer Ganzzahlvariablen „X“ in der Klasse „MyBase_Class“ und der oben genannten Hauptmethode bewerten wir die Größe der Klasse. Zunächst nennen wir die angegebene Klasse und erstellen ihr Objekt als "y". Dann haben wir einen sizeof () operator, der „y“ als Eingabe dauert. Die Ganzzahlvariablen nehmen 4 Bytes auf, sodass das Ergebnis 4 Bytes betragen würde, wie in Folgendes gedruckt:

Beispiel 3:

Wenn wir die Anzahl der Ganzzahlvariablen in einer Klasse erhöhen, wird der folgende Code erstellt:

#enthalten
Verwenden von Namespace STD;
Klasse myclass_base

int i;
int j;
;
int main ()

Myclass_base j;
std :: Cout << "Size of MyClass_Base is : "<Rückkehr 0;

Im vorherigen Code gibt es jetzt eine zweite Ganzzahlvariable "J". Angesichts der Tatsache, dass die int -Variable 4 Bytes aufnimmt und es zwei Ganzzahlvariablen als "I" und "J" gibt, beträgt die Klasse "myclass_base" in diesem Szenario 8 Bytes in Größe.

Beispiel 4:

Der Code kann dem folgenden ähneln, wenn wir eine Char -Variable einfügen:

#enthalten
Verwenden von Namespace STD;
Klasse Myclass

int p;
int q;
char ch;
;
int main ()

Myclass Q;
std :: Cout << "Size of MyClass is : "<Rückkehr 0;

Zwei Ganzzahl und eine Char -Variable werden im vorherigen Code der „MyClass“ -Klasse verwendet. Die Größe der Klasse sollte 9 Bytes betragen, da es nach unseren Berechnungen drei Datentypen (int+int+char) gibt. Dies ist jedoch falsch, weil die Idee der Strukturpolsterung. Sie können den folgenden Ergebniswert sehen:

Beispiel 5:

Der Fall, in dem der Operand ein Array ist. Schauen wir uns die Programmimplementierung an:

#enthalten
Verwenden von Namespace STD;
int main ()

int arr_set [] = 5,15,25,35,45;
std :: Cout << "Size of the 'arr_set' is : "<Rückkehr 0;

Wir haben ein ganzzahliges Array als "arr_set" mit fünf Elementen im vorherigen Programm eingerichtet. Wir haben die Größe des Arrays unter Verwendung des sizeof () -Operators bestimmt. Das Array hat 20 Bytes, da der int -Datentyp 4 Bytes aufnimmt und 5 Einträge im Array enthalten, wodurch ein Gesamtspeicherraum von 5 * 4 = 20 Bytes erforderlich ist. Wie wir in der folgenden Ausgabe sehen können, hat der Betrieb von sizeof () das gleiche Ergebnis erzeugt.

Beispiel 6:

Das Beispiel nimmt bereits die Größe des Arrays an. Betrachten wir ein Array aus einer bestimmten Perspektive.

#enthalten
Verwenden von Namespace STD;
void new_function (int array [])

std :: Cout << "Size of array is : " <
int main ()

int array [] = 51,52,53,54,55;
New_Function (Array);
Rückkehr 0;

Wir haben versucht, die Funktion „New_function“ in der oben genannten Anwendung zu verwenden, um die Größe des Arrays zu drucken. Wir haben in diesem Fall ein Array vom Typ Ganzzahl gebildet und senden den Parameter „Array“ an die New_Function (). Die Größe des Ganzzahlzeigers oder int* wird vom New_Function zurückgegeben (). In den 64-Bit-Betriebssystemen beträgt die Größe des int* 8 Bytes. Die Ausgabe erzeugt die Array -Größe wie folgt:

Beispiel 7:

Dies ist nun das Beispiel, bei dem das Argument der Art eines Zeigers innerhalb des Sizeof () Operators ist.

#enthalten
Verwenden von Namespace STD;
int main ()

int *ptr1 = new int (31);
std :: Cout << "ptr1 size:" <std :: Cout << "*ptr1 size :" <doppelt *ptr2 = neues Double (20.99);
std :: Cout <<"ptr2 size :" <std :: Cout <<" *ptr2 size :"<char *ptr3 = new char ('m');
std :: Cout <<"ptr3 size :" <std :: Cout <<"*ptr3 size :"<Rückkehr 0;

Wir haben die Größe der Zeiger im Skript berechnet, das zuvor erwähnt wurde. Für die Datentypen "int", "doppelt" und "char" bleiben die Zeigergrößen konstant. Die Größe des Zeigers beträgt 4 Bytes, wenn der Computer ein 32-Bit-Betriebssystem hatte. Die Größe des Zeigers beträgt 8 Bytes, wenn der Computer ein 64-Bit-Betriebssystem ausführt. Das Ergebnis sind 8 Bytes, da wir dieses Skript auf einer 64-Bit-Plattform ausführen. Wenn wir dem Zeiger nun das Symbol „*“ geben, ändert sich die Ausgabe abhängig vom Datentyp. Wenn *ptr1 beispielsweise ein Ganzzahltyp ist, gibt der sizeof () -Operator 4 Bytes an, da ein Int -Datentyp 4 Bytes aufnimmt. Das Folgende ist die resultierende Größe der Zeiger, die jedem angegebenen Datentyp entsprechen:

Beispiel 8:

Das Beispiel, bei dem wir einen Ausdruck als sizeof () operator operand haben.

#enthalten
Verwenden von Namespace STD;
int main ()

int Integer_1;
Double Integer_2;
Cout << "size of int and double: " <Rückkehr 0;

Wir haben zwei Variablen, Integer_1 und Integer_2, der INT- bzw. Doppeltypen. Sie werden im Programm deklariert. Wie wir wissen, sind Ganzzahlen 4 Bytes groß, während Doppel 8 Bytes sind. Wir haben beide im sizeof () operator hinzugefügt. Die Variable, doppelt mit einer 8-Byte-Größe, ist das Ergebnis.

Abschluss

Eine Größe () Erklärung für C ++ endet hier. Wir haben die Einzelheiten darüber durchgesehen, wie der C ++ Sizeof () Operator funktioniert, zusammen mit relevanten Beispielen. Jeder Datentyp, jeder Ausdruck, Array usw. kann seine Größe unter Verwendung des sizeof () Operators ermitteln lassen. Der Datentyp oder ein Ausdruck muss als Teil des Arguments bereitgestellt werden. Und die Funktion gibt die Größe dieses Datentyps in Bytes als Ergebnis zurück.