Eksempel 1:
Forskellige header-filer importeres her, som er 'stddef.h', 'limits' og 'iostream'. Definitionerne af hyppigt anvendte variabler, typer og pointere kan findes i 'stddef.h', og 'limits'-headerfilen bruges som konstanter, der repræsenterer grænserne for integraltyper, såsom min- og max-værdier for forskellige datatyper , som er tilgængelige via denne overskriftsfil. Derefter tilføjes 'iostream', fordi de funktioner, der bruges til at indtaste/outputte dataene, er defineret i den.
Herefter tilføjes 'std'-navnerummet her. Under dette påkaldes 'main()'-metoden. Inde i denne placerer vi 'cout', som hjælper med at gengive de data, som vi vil placere her. 'numeric_limits::max()' indtastes, da det giver den højeste endelige værdi tilbage, som den numeriske type 'T' kan repræsentere. Det er vigtigt for enhver afgrænset type, men det kan ikke være negativt.
Kode 1:
#include
#inkluder
#include
ved brug af navneområde std ;
int vigtigste ( ) {
cout << 'Den maksimale størrelse på size_t er' << numeriske_grænser :: max ( ) << endl ;
}
Produktion:
Vi bemærker måske, at den maksimale størrelse af 'T'-typen nu gengives, hvilket er en meget stor værdi som vist i følgende:
Eksempel 2:
To header-filer importeres her inklusive 'limits' og 'iostream. Da de nødvendige funktioner til at indtaste og udlæse dataene er defineret i den, tilføjes 'iostream' her. Derefter bruges 'limits'-headerfilen til at få adgang til konstanterne, der beskriver grænserne for integraltyper såsom min- og max-værdier for forskellige datatyper.
Efterfølgende introduceres 'std'-navnerummet her, og funktionen 'main()' kaldes. Under dette bruger vi 'INT_MAX' inde i 'cout' til at gengive den højeste værdi af heltalsdatatypens øvre grænse i C++ programmering. Derefter, i den følgende linje, bruger vi 'size_t', som giver den højeste værdi.
Kode 2:
#include#include
ved brug af navneområde std ;
int vigtigste ( ) {
cout << 'Den maksimale heltalsværdi: ' << INT_MAX << endl ;
cout << 'Den størrelse, som size_t-funktionen har: ' << ( størrelse_t ) 0 - 1 << endl ;
Vend tilbage 0 ;
}
Produktion :
Heltallets maksimale størrelse gengives først, hvilket vi får ved hjælp af 'INT_MAX'. Derefter gengives den maksimale størrelse, som 'size_t' gemmer, som vi får ved hjælp af 'size_t' i denne kode.
Eksempel 3:
Her importeres to header-filer, 'climits' og 'iostream'. 'iostream' er inkluderet her, da de funktioner, der er nødvendige for at input og output dataene, er defineret i den. Dernæst tilgås konstanterne, der beskriver grænserne for integraltyper, såsom minimums- og maksimumværdierne for forskellige datatyper, ved hjælp af 'climits'-headerfilen.
Her aktiveres 'main()'-funktionen nu, og 'std'-navnerummet introduceres efterfølgende. Under dette bruger vi 'INT_MAX' inde i 'cout' til at udlæse den øvre grænse for heltalsdatatypens maksimale værdi i C++ programmering. Under dette bruger vi 'INT_MIN', som returnerer 'int' datatypens lavere værdi. Derefter bruger vi 'size_t', som giver den maksimale værdi, den gemmer i følgende linje:
Kode 3:
#include#include
ved brug af navneområde std ;
int vigtigste ( ) {
cout << 'Den største heltalsværdi: ' << INT_MAX << endl ;
cout << 'Det mindste heltal: ' << INT_MIN << endl ;
cout << 'Den størrelse, som size_t-funktionen har: ' << ( størrelse_t ) 0 - 1 << endl ;
Vend tilbage 0 ;
}
Produktion:
Først vises den maksimale størrelse af hele tallet, som vi opnår ved hjælp af 'INT_MAX'. For det andet vises minimumsstørrelsen af heltal, som vi opnår ved hjælp af 'INT_MIN'. Derefter, ved hjælp af 'size_t' i denne kode, gengives den maksimale størrelse, som 'size_t' gemmer.
Eksempel 4:
De inkluderede header-filer i denne kode er 'cstddef', 'iostream' såvel som 'array'. Disse header-filer er inkluderet, så vi kan bruge de funktioner, hvis definitioner er defineret i disse header-filer. 'Array'-headerfilen tilføjes her, da vi skal arbejde med 'arrays' og funktioner i denne kode. Vi erklærer variablen 'my_sVar' her med 'const size_t' og initialiserer den med værdien '1000' for at gengive dens størrelse.
Efter dette erklærer vi også 'num[]'-arrayet af 'int'-datatypen og sender 'my_sVar' som dens størrelse. Derefter bruger vi 'size_of()'-funktionen, hvori vi placerer 'num'-variablen som parameteren og gemmer den i 'my_size'-variablen af typen 'size_t'. Derefter bruger vi 'cout' og skriver 'SIZE_MAX' her, så det gengiver den maksimale størrelse af 'my_sVar'-variablen.
Dernæst viser vi array-type elementerne i mindre antal. Vi vælger det kun for at vise 10 som 1000, hvilket er for mange til at passe i outputtet. Ved at bruge 'size_t'-typen starter vi ved indeks 0 for at vise, hvordan 'size_t' kan bruges til både indeksering og optælling. Da tallene vil falde, vises arrayet i faldende rækkefølge, da vi placerede '–a' i koden.
Kode 4:
#include#include
#include
ved brug af navneområde std ;
int vigtigste ( ) {
konst størrelse_t min_sVar = 1000 ;
int på en [ min_sVar ] ;
størrelse_t min_størrelse = størrelse af ( på en ) ;
cout << 'Den maksimale størrelse på my_sVar = ' << SIZE_MAX << endl ;
cout << 'Når du arbejder med en matrix af tal, er størrelse_t-typen som følger.' ;
array < størrelse_t , 10 > min_arr ;
til ( størrelse_t -en = 0 ; -en ! = min_arr. størrelse ( ) ; ++ -en )
min_arr [ -en ] = -en ;
til ( størrelse_t -en = min_arr. størrelse ( ) - 1 ; -en < min_arr. størrelse ( ) ; -- -en )
cout << min_arr [ -en ] << ' ' ;
Vend tilbage 0 ;
}
Produktion:
Den gengiver først den maksimale størrelse af variablen og renderer derefter arrayet i faldende rækkefølge.
Eksempel 5:
Denne kode inkluderer 'cstddef', 'iostream' og 'array' header-filer. Da denne kode kræver, at vi arbejder med 'arrays' og funktioner, placeres 'array'-headerfilen her. For at gengive størrelsen af 'var'-variablen, erklærer vi den her med 'const size_t'-værdien og initialiserer den med '1000'. Den maksimale størrelse af 'var'-variablen gengives her, da vi brugte 'cout'-funktionen og specificerede 'SIZE_MAX' i dette felt.
Dernæst forsøger vi at vise array-type elementerne i mindre mængder. Indtil videre har vi kun valgt at vise 20, fordi 1000 ville fylde outputtet. Vi demonstrerer, hvordan 'size_t' kan bruges til både indeksering og optælling ved hjælp af typen 'size_t' og starter ved indeks 0. Arrayet vises derefter i faldende rækkefølge, fordi tallene vil falde som angivet ved placeringen af '–a' i følgende kode:
Kode 5:
#include#include
#include
ved brug af navneområde std ;
int vigtigste ( ) {
konst størrelse_t var = 1000 ;
cout << 'Maksimal størrelse på var = ' << SIZE_MAX << endl ;
cout << 'Størrelse_t-typen, der bruges med en række tal, er angivet som ' ;
array < størrelse_t , tyve > array_num ;
til ( størrelse_t jeg = 0 ; jeg ! = array_num. størrelse ( ) ; ++ jeg )
array_num [ jeg ] = jeg ;
til ( størrelse_t jeg = array_num. størrelse ( ) - 1 ; jeg < array_num. størrelse ( ) ; -- jeg )
cout << array_num [ jeg ] << ' ' ;
Vend tilbage 0 ;
}
Produktion :
Det gengiver arrayet i en faldende rækkefølge efter at have gengivet variablen til dens maksimale størrelse.
Konklusion
'Size_t'-typen i C++-programmering blev udforsket grundigt i denne artikel. Vi definerede, at vi bruger 'size_t' i vores C++-koder, da det gemmer sin største værdi. Vi forklarede også, at det er en usigneret type, og den kan ikke være negativ. Vi demonstrerede koderne for C++ programmering, hvor vi brugte 'size_t' og derefter gengivet deres resultater i denne artikel.