Size_t in C++

Size T In C



C++ is de meest populaire en uitgebreide taal die rijk is aan functies die ons werk gemakkelijker maken. Het vergemakkelijkt ons met het type “size_t” dat helpt bij het opslaan van de maximale grootte van elk gegevenstype. Een uniek geheel getaltype zonder teken genaamd “size_t” is gedefinieerd in de standaardbibliotheken van C++. De SIZE_MAX-constante is de grootste waarde die kan worden toegewezen aan een “size_t”-type. De grootste grootte van een array of objecten die theoretisch denkbaar zijn, kan worden opgeslagen in “size_t”. Gebruik het alleen als we enorme matrices, arrays, enz. nodig hebben. De “size_t” kan niet negatief zijn in C++-programmering.

Voorbeeld 1:

Hier worden verschillende headerbestanden geïmporteerd, namelijk “stddef.h”, “limits” en “iostream”. De definities van veelgebruikte variabelen, typen en verwijzingen zijn te vinden in 'stddef.h' en het headerbestand 'limits' wordt gebruikt als constanten die de grenzen van integrale typen vertegenwoordigen, zoals de min- en max-waarden voor verschillende gegevenstypen , die toegankelijk zijn via dit headerbestand. Vervolgens wordt de “iostream” toegevoegd omdat de functies die worden gebruikt voor het invoeren/uitvoeren van de gegevens daarin zijn gedefinieerd.

Hierna wordt hier de naamruimte “std” toegevoegd. Daaronder wordt de methode “main()” aangeroepen. Hierin plaatsen we de “cout” die helpt bij het weergeven van de gegevens die we hier zullen plaatsen. De “numeric_limits::max()” wordt getypt omdat deze de hoogste eindige waarde teruggeeft die het numerieke type “T” kan vertegenwoordigen. Het is significant voor elk begrensd type, maar het kan niet negatief zijn.







Code1:



#include
#include
#include
gebruik makend van naamruimte soa ;
int voornaamst ( ) {
uit << 'De maximale grootte van size_t is ' << numerieke_limieten :: maximaal ( ) << eindl ;
}

Uitgang:
Het zou ons kunnen opvallen dat de maximale grootte van het “T”-type nu wordt weergegeven, wat een zeer grote waarde is, zoals hieronder weergegeven:







Voorbeeld 2:

Hier worden twee headerbestanden geïmporteerd, waaronder “limits” en “iostream. Omdat de functies die nodig zijn voor het invoeren en uitvoeren van de gegevens daarin zijn gedefinieerd, wordt hier “iostream” toegevoegd. Vervolgens wordt het headerbestand “limits” gebruikt om toegang te krijgen tot de constanten die de grenzen van integraaltypen beschrijven, zoals de min- en max-waarden voor verschillende gegevenstypen.

Vervolgens wordt hier de naamruimte “std” geïntroduceerd en wordt de functie “main()” aangeroepen. Hieronder gebruiken we de “INT_MAX” binnen de “cout” om de hoogste waarde van de bovengrens van het integer-gegevenstype weer te geven in C++-programmering. Vervolgens gebruiken we in de volgende regel de “size_t” die de hoogste waarde oplevert.



Code2:

#include
#include
gebruik makend van naamruimte soa ;
int voornaamst ( ) {
uit << 'De maximale gehele waarde: ' << INT_MAX << eindl ;

uit << 'De grootte die de functie size_t bevat: ' << ( maat_t ) 0 - 1 << eindl ;
opbrengst 0 ;
}

Uitvoer :
De maximale grootte van het gehele getal wordt eerst weergegeven, wat we krijgen met behulp van “INT_MAX”. Vervolgens wordt de maximale grootte weergegeven die de “size_t” opslaat, die we krijgen met behulp van “size_t” in deze code.

Voorbeeld 3:

Hier worden twee headerbestanden, “climits” en “iostream”, geïmporteerd. De “iostream” is hier opgenomen omdat de functies die nodig zijn voor het invoeren en uitvoeren van de gegevens daarin zijn gedefinieerd. Vervolgens worden de constanten die de grenzen van integraaltypen beschrijven, zoals de minimum- en maximumwaarden voor verschillende gegevenstypen, benaderd met behulp van het headerbestand “climits”.

Hier wordt nu de functie “main()” aangeroepen en vervolgens de naamruimte “std” geïntroduceerd. Daaronder gebruiken we de “INT_MAX” binnen de “cout” om de bovengrens van de maximale waarde van het integer-gegevenstype in C++-programmering uit te voeren. Daaronder gebruiken we de “INT_MIN” die de lagere waarde van het datatype “int” retourneert. Vervolgens gebruiken we “size_t”, wat de maximale waarde oplevert die het opslaat in de volgende regel:

Code 3:

#include
#include
gebruik makend van naamruimte soa ;
int voornaamst ( ) {
uit << 'De grootste gehele waarde: ' << INT_MAX << eindl ;
uit << 'Het kleinste gehele getal: ' << INT_MIN << eindl ;
uit << 'De grootte die de functie size_t bevat: ' << ( maat_t ) 0 - 1 << eindl ;
opbrengst 0 ;
}

Uitgang:
Eerst wordt de maximale grootte van het gehele getal weergegeven, die we verkrijgen met behulp van de “INT_MAX”. Ten tweede wordt de minimale grootte van het gehele getal weergegeven, die we verkrijgen met behulp van “INT_MIN”. Vervolgens wordt met behulp van “size_t” in deze code de maximale grootte weergegeven die door “size_t” wordt opgeslagen.

Voorbeeld 4:

De meegeleverde headerbestanden in deze code zijn “cstddef”, “iostream” en “array”. Deze headerbestanden zijn opgenomen zodat we de functies kunnen gebruiken waarvan de definities in deze headerbestanden zijn gedefinieerd. Het headerbestand “array” is hier toegevoegd omdat we met de “arrays” en functies in deze code moeten werken. We declareren de variabele “my_sVar” hier met de “const size_t” en initialiseren deze met de waarde “1000” om de grootte ervan weer te geven.

Hierna declareren we ook de array 'num[]' van het gegevenstype 'int' en geven we 'my_sVar' door als de grootte ervan. Vervolgens gebruiken we de functie “size_of()” waarin we de variabele “num” als parameter plaatsen en deze opslaan in de variabele “my_size” van het type “size_t”. Vervolgens gebruiken we de 'cout' en typen we hier 'SIZE_MAX', zodat de maximale grootte van de variabele 'my_sVar' wordt weergegeven.

Vervolgens tonen we de array-type elementen in kleinere aantallen. We selecteren het alleen om 10 als 1000 weer te geven, wat te veel is om in de uitvoer te passen. Met behulp van het type “size_t” beginnen we bij index 0 om te laten zien hoe “size_t” kan worden gebruikt voor zowel indexeren als tellen. Omdat de getallen afnemen, wordt de array in aflopende volgorde weergegeven terwijl we “–a” in de code hebben geplaatst.

Code 4:

#include
#include
#include
gebruik makend van naamruimte soa ;
int voornaamst ( ) {
const maat_t mijn_sVar = 1000 ;
int op een [ mijn_sVar ] ;
maat_t mijn maat = De grootte van ( op een ) ;
uit << 'De maximale grootte van my_sVar = ' << GROOTTE_MAX << eindl ;
uit << 'Als je met een reeks getallen werkt, is het size_t type als volgt. ' ;
reeks < maat_t , 10 > mijn_arr ;
voor ( maat_t A = 0 ; A ! = mijn_arr. maat ( ) ; ++ A )
mijn_arr [ A ] = A ;
voor ( maat_t A = mijn_arr. maat ( ) - 1 ; A < mijn_arr. maat ( ) ; -- A )
uit << mijn_arr [ A ] << ' ' ;
opbrengst 0 ;
}

Uitgang:
Het geeft eerst de maximale grootte van de variabele weer en vervolgens de array in aflopende volgorde.

Voorbeeld 5:

Deze code bevat de headerbestanden “cstddef”, “iostream” en “array”. Omdat deze code vereist dat we met “arrays” en functies werken, wordt het headerbestand “array” hier geplaatst. Om de grootte van de variabele “var” weer te geven, declareren we deze hier met de waarde “const size_t” en initialiseren we deze met “1000”. De maximale grootte van de variabele “var” wordt hier weergegeven, omdat we de functie “cout” hebben gebruikt en in dit veld “SIZE_MAX” hebben opgegeven.

Vervolgens proberen we de items van het array-type in kleinere hoeveelheden weer te geven. Tot nu toe hebben we er alleen voor gekozen om er 20 weer te geven, omdat 1000 de uitvoer zouden vullen. We demonstreren hoe “size_t” kan worden gebruikt voor zowel indexeren als tellen met behulp van het type “size_t” en beginnend bij index 0. De array wordt vervolgens in aflopende volgorde weergegeven omdat de getallen afnemen zoals aangegeven door de plaatsing van “–a” in de volgende code:

Code 5:

#include
#include
#include
gebruik makend van naamruimte soa ;
int voornaamst ( ) {
const maat_t was = 1000 ;
uit << 'Maximale grootte van var = ' << GROOTTE_MAX << eindl ;
uit << 'Het size_t-type dat wordt gebruikt met een reeks getallen wordt gegeven als ' ;

reeks < maat_t , twintig > array_num ;
voor ( maat_t i = 0 ; i ! = array_num. maat ( ) ; ++ i )
array_num [ i ] = i ;
voor ( maat_t i = array_num. maat ( ) - 1 ; i < array_num. maat ( ) ; -- i )
uit << array_num [ i ] << ' ' ;
opbrengst 0 ;
}

Uitvoer :
Het geeft de array in afnemende volgorde weer nadat de variabele de maximale grootte heeft bereikt.

Conclusie

Het type “size_t” in C++-programmeren werd in dit artikel grondig onderzocht. We hebben gedefinieerd dat we “size_t” gebruiken in onze C++-codes omdat deze de grootste waarde opslaat. We hebben ook uitgelegd dat het een type zonder teken is en niet negatief kan zijn. We hebben de codes van C++-programmering gedemonstreerd waarbij we de “size_t” gebruikten en vervolgens hun resultaten in dit artikel weergegeven.