Beispiel 1:
Hier werden verschiedene Header-Dateien importiert: „stddef.h“, „limits“ und „iostream“. Die Definitionen häufig verwendeter Variablen, Typen und Zeiger finden Sie in „stddef.h“ und die Header-Datei „limits“ wird als Konstanten verwendet, die die Grenzen ganzzahliger Typen darstellen, z. B. die Min- und Max-Werte für verschiedene Datentypen , auf die über diese Header-Datei zugegriffen werden kann. Dann wird der „iostream“ hinzugefügt, da darin die Funktionen definiert sind, die zur Ein-/Ausgabe der Daten verwendet werden.
Danach wird hier der Namespace „std“ hinzugefügt. Darunter wird die Methode „main()“ aufgerufen. Darin platzieren wir den „cout“, der beim Rendern der Daten hilft, die wir hier platzieren werden. „numeric_limits::max()“ wird so typisiert, dass es den höchsten endlichen Wert zurückgibt, den der numerische Typ „T“ darstellen kann. Es ist für jeden begrenzten Typ von Bedeutung, kann aber nicht negativ sein.
Code 1:
#include
#include
#include
verwenden Namensraum std ;
int hauptsächlich ( ) {
cout << „Die maximale Größe von size_t ist“ << numerische_limits :: max ( ) << endl ;
}
Ausgabe:
Wir stellen möglicherweise fest, dass jetzt die maximale Größe des Typs „T“ gerendert wird, was ein sehr großer Wert ist, wie im Folgenden gezeigt:
Beispiel 2:
Hier werden zwei Header-Dateien importiert, darunter „limits“ und „iostream“. Da darin die für die Ein- und Ausgabe der Daten erforderlichen Funktionen definiert sind, wird hier „iostream“ hinzugefügt. Anschließend wird die Header-Datei „limits“ verwendet, um auf die Konstanten zuzugreifen, die die Grenzen von Integraltypen beschreiben, wie z. B. die Min- und Max-Werte für verschiedene Datentypen.
Anschließend wird hier der Namensraum „std“ eingeführt und die Funktion „main()“ aufgerufen. Darunter verwenden wir „INT_MAX“ innerhalb von „cout“, um den höchsten Wert der Obergrenze des Integer-Datentyps in der C++-Programmierung darzustellen. Dann verwenden wir in der folgenden Zeile „size_t“, das den höchsten Wert ergibt.
Code 2:
#include#include
verwenden Namensraum std ;
int hauptsächlich ( ) {
cout << „Der maximale ganzzahlige Wert:“ << INT_MAX << endl ;
cout << „Die Größe, die die Funktion size_t enthält:“ << ( size_t ) 0 - 1 << endl ;
zurückkehren 0 ;
}
Ausgabe :
Zuerst wird die maximale Größe der Ganzzahl gerendert, die wir mit Hilfe von „INT_MAX“ erhalten. Dann wird die maximale Größe gerendert, die „size_t“ speichert, die wir mit Hilfe von „size_t“ in diesem Code erhalten.
Beispiel 3:
Hier werden zwei Header-Dateien, „climits“ und „iostream“, importiert. Der „iostream“ ist hier enthalten, da darin die Funktionen definiert sind, die zur Ein- und Ausgabe der Daten erforderlich sind. Als nächstes wird über die Header-Datei „climits“ auf die Konstanten zugegriffen, die die Grenzen ganzzahliger Typen beschreiben, z. B. die Minimal- und Maximalwerte für verschiedene Datentypen.
Hier wird nun die Funktion „main()“ aufgerufen und anschließend der Namensraum „std“ eingeführt. Darunter verwenden wir „INT_MAX“ innerhalb von „cout“, um die Obergrenze des Maximalwerts des Integer-Datentyps in der C++-Programmierung auszugeben. Darunter verwenden wir „INT_MIN“, das den unteren Wert des Datentyps „int“ zurückgibt. Dann verwenden wir „size_t“, was den maximalen Wert ergibt, der in der folgenden Zeile gespeichert wird:
Code 3:
#include#include
verwenden Namensraum std ;
int hauptsächlich ( ) {
cout << „Der größte ganzzahlige Wert:“ << INT_MAX << endl ;
cout << „Die kleinste ganze Zahl:“ << INT_MIN << endl ;
cout << „Die Größe, die die Funktion size_t enthält:“ << ( size_t ) 0 - 1 << endl ;
zurückkehren 0 ;
}
Ausgabe:
Zunächst wird die maximale Größe der Ganzzahl angezeigt, die wir mit Hilfe des „INT_MAX“ ermitteln. Zweitens wird die minimale Größe der Ganzzahl angezeigt, die wir mit Hilfe von „INT_MIN“ erhalten. Dann wird mit Hilfe von „size_t“ in diesem Code die maximale Größe gerendert, die „size_t“ speichert.
Beispiel 4:
Die in diesem Code enthaltenen Header-Dateien sind „cstddef“, „iostream“ sowie „array“. Diese Header-Dateien sind enthalten, damit wir die Funktionen nutzen können, deren Definitionen in diesen Header-Dateien definiert sind. Die „Array“-Header-Datei wird hier hinzugefügt, da wir mit den „Arrays“ und Funktionen in diesem Code arbeiten müssen. Wir deklarieren hier die Variable „my_sVar“ mit „const size_t“ und initialisieren sie mit dem Wert „1000“, um ihre Größe darzustellen.
Danach deklarieren wir auch das Array „num[]“ vom Datentyp „int“ und übergeben „my_sVar“ als Größe. Dann verwenden wir die Funktion „size_of()“, in der wir die Variable „num“ als Parameter platzieren und sie in der Variablen „my_size“ vom Typ „size_t“ speichern. Dann verwenden wir „cout“ und geben hier „SIZE_MAX“ ein, damit die maximale Größe der Variablen „my_sVar“ gerendert wird.
Als nächstes zeigen wir die Array-Elemente in kleinerer Anzahl. Wir wählen es nur aus, um 10 als 1000 anzuzeigen, was zu zahlreich ist, um in die Ausgabe zu passen. Mit dem Typ „size_t“ beginnen wir bei Index 0, um zu zeigen, wie „size_t“ sowohl zum Indizieren als auch zum Zählen verwendet werden kann. Da die Zahlen abnehmen, wird das Array in absteigender Reihenfolge angezeigt, da wir „–a“ in den Code eingefügt haben.
Code 4:
#include#include
#include
verwenden Namensraum std ;
int hauptsächlich ( ) {
const size_t my_sVar = 1000 ;
int Auf eins [ my_sVar ] ;
size_t meine Größe = Größe von ( Auf eins ) ;
cout << „Die maximale Größe von my_sVar =“ << SIZE_MAX << endl ;
cout << „Wenn Sie mit einem Array von Zahlen arbeiten, lautet der Typ size_t wie folgt.“ ;
Array < size_t , 10 > my_arr ;
für ( size_t A = 0 ; A ! = my_arr. Größe ( ) ; ++ A )
my_arr [ A ] = A ;
für ( size_t A = my_arr. Größe ( ) - 1 ; A < my_arr. Größe ( ) ; -- A )
cout << my_arr [ A ] << ' ' ;
zurückkehren 0 ;
}
Ausgabe:
Es rendert zuerst die maximale Größe der Variablen und dann das Array in absteigender Reihenfolge.
Beispiel 5:
Dieser Code enthält die Header-Dateien „cstddef“, „iostream“ und „array“. Da dieser Code erfordert, dass wir mit „Arrays“ und Funktionen arbeiten, wird die „Array“-Header-Datei hier platziert. Um die Größe der Variablen „var“ darzustellen, deklarieren wir sie hier mit dem Wert „const size_t“ und initialisieren sie mit „1000“. Die maximale Größe der Variable „var“ wird hier dann gerendert, da wir die Funktion „cout“ verwendet und in diesem Feld „SIZE_MAX“ angegeben haben.
Als nächstes versuchen wir, die Elemente vom Array-Typ in kleineren Mengen anzuzeigen. Bisher haben wir uns nur für die Anzeige von 20 entschieden, da 1000 die Ausgabe füllen würden. Wir demonstrieren, wie „size_t“ sowohl zum Indizieren als auch zum Zählen verwendet werden kann, indem wir den Typ „size_t“ verwenden und bei Index 0 beginnen. Das Array wird dann in absteigender Reihenfolge angezeigt, da die Zahlen abnehmen, wie durch die Platzierung von „–a“ angezeigt der folgende Code:
Code 5:
#include#include
#include
verwenden Namensraum std ;
int hauptsächlich ( ) {
const size_t War = 1000 ;
cout << „Maximale Größe von var =“ << SIZE_MAX << endl ;
cout << „Der Typ size_t, der mit einem Array von Zahlen verwendet wird, wird angegeben als“ ;
Array < size_t , zwanzig > array_num ;
für ( size_t ich = 0 ; ich ! = array_num. Größe ( ) ; ++ ich )
array_num [ ich ] = ich ;
für ( size_t ich = array_num. Größe ( ) - 1 ; ich < array_num. Größe ( ) ; -- ich )
cout << array_num [ ich ] << ' ' ;
zurückkehren 0 ;
}
Ausgabe :
Es rendert das Array in absteigender Reihenfolge, nachdem die Variable auf ihre maximale Größe gerendert wurde.
Abschluss
Der Typ „size_t“ in der C++-Programmierung wurde in diesem Artikel ausführlich untersucht. Wir haben definiert, dass wir „size_t“ in unseren C++-Codes verwenden, da es seinen größten Wert speichert. Wir haben auch erklärt, dass es sich um einen vorzeichenlosen Typ handelt und nicht negativ sein kann. In diesem Artikel haben wir die Codes der C++-Programmierung demonstriert, bei denen wir „size_t“ verwendet und dann deren Ergebnisse gerendert haben.