Exempel 1:
Här importeras olika rubrikfiler som är 'stddef.h', 'limits' och 'iostream'. Definitionerna av ofta använda variabler, typer och pekare finns i 'stddef.h' och rubrikfilen 'limits' används som konstanter som representerar gränserna för integraltyper, såsom min- och maxvärden för olika datatyper , som är tillgängliga via den här rubrikfilen. Sedan läggs 'iostream' till eftersom funktionerna som används för att mata in/mata ut data är definierade i den.
Efter detta läggs sedan namnutrymmet 'std' till här. Under detta anropas metoden 'main()'. Inuti detta placerar vi 'cout' som hjälper till att rendera data som vi kommer att placera här. 'numeric_limits::max()' skrivs eftersom det ger tillbaka det högsta ändliga värdet som den numeriska typen 'T' kan representera. Det är betydelsefullt för varje avgränsad typ men det kan inte vara negativt.
Kod 1:
#inkludera
#inkludera
#include
använder sig av namnutrymme std ;
int huvud ( ) {
cout << 'Maximal storlek på size_t är' << numeriska_gränser :: max ( ) << endl ;
}
Produktion:
Vi kanske märker att den maximala storleken för 'T'-typen nu återges, vilket är ett mycket stort värde som visas i följande:
Exempel 2:
Två rubrikfiler importeras här inklusive 'limits' och 'iostream. Eftersom de funktioner som behövs för att mata in och mata ut data är definierade i den, läggs 'iostream' till här. Sedan används rubrikfilen 'limits' för att komma åt konstanterna som beskriver gränserna för integraltyper såsom min- och maxvärden för olika datatyper.
Därefter introduceras namnutrymmet 'std' här och funktionen 'main()' anropas. Under detta använder vi 'INT_MAX' inuti 'cout' för att återge det högsta värdet av heltalsdatatypens övre gräns i C++-programmering. Sedan, på följande rad, använder vi 'size_t' som ger det högsta värdet.
Kod 2:
#include#inkludera
använder sig av namnutrymme std ;
int huvud ( ) {
cout << 'Det maximala heltalsvärdet: ' << INT_MAX << endl ;
cout << 'Storleken som size_t-funktionen har: ' << ( storlek_t ) 0 - 1 << endl ;
lämna tillbaka 0 ;
}
Produktion :
Heltalets maximala storlek renderas först vilket vi får med hjälp av 'INT_MAX'. Sedan renderas den maximala storleken som 'size_t' lagrar, vilket vi får med hjälp av 'size_t' i den här koden.
Exempel 3:
Här importeras två rubrikfiler, 'climits' och 'iostream'. 'iostream' ingår här eftersom de funktioner som krävs för att mata in och mata ut data är definierade i den. Därefter nås konstanterna som beskriver gränserna för integraltyper, såsom minimi- och maximivärden för olika datatyper, med hjälp av rubrikfilen 'climits'.
Här anropas nu funktionen 'main()' och namnutrymmet 'std' introduceras därefter. Under detta använder vi 'INT_MAX' inuti 'cout' för att mata ut den övre gränsen för heltalsdatatypens maximala värde i C++-programmering. Under detta använder vi 'INT_MIN' som returnerar 'int' datatypens lägre värde. Sedan använder vi 'size_t' som ger det maximala värdet den lagrar på följande rad:
Kod 3:
#include#inkludera
använder sig av namnutrymme std ;
int huvud ( ) {
cout << 'Det största heltalsvärdet: ' << INT_MAX << endl ;
cout << 'Det minsta heltal: ' << INT_MIN << endl ;
cout << 'Storleken som size_t-funktionen har: ' << ( storlek_t ) 0 - 1 << endl ;
lämna tillbaka 0 ;
}
Produktion:
Först visas den maximala storleken på heltal som vi får med hjälp av 'INT_MAX'. För det andra visas minimistorleken på heltal som vi får med hjälp av 'INT_MIN'. Sedan, med hjälp av 'size_t' i den här koden, renderas den maximala storleken som 'size_t' lagrar.
Exempel 4:
De inkluderade rubrikfilerna i den här koden är 'cstddef', 'iostream' såväl som 'array'. Dessa header-filer ingår så att vi kan använda de funktioner vars definitioner är definierade i dessa header-filer. 'Array'-huvudfilen läggs till här eftersom vi måste arbeta med 'arrayer' och funktioner i denna kod. Vi förklarar variabeln 'my_sVar' här med 'const size_t' och initierar den med värdet '1000' för att återge dess storlek.
Efter detta deklarerar vi också 'num[]'-matrisen av 'int' datatyp och skickar 'my_sVar' som dess storlek. Sedan använder vi funktionen 'size_of()' där vi placerar variabeln 'num' som parameter och lagrar den i variabeln 'my_size' av typen 'size_t'. Sedan använder vi 'cout' och skriver 'SIZE_MAX' här så att den återger den maximala storleken på variabeln 'my_sVar'.
Därefter visar vi element av arraytyp i mindre antal. Vi väljer bara att visa 10 som 1000, vilket är för många för att få plats i utgången. Med hjälp av typen 'size_t' börjar vi vid index 0 för att visa hur 'size_t' kan användas för både indexering och räkning. Eftersom siffrorna kommer att minska visas arrayen i fallande ordning när vi placerade '–a' i koden.
Kod 4:
#include#include
#inkludera
använder sig av namnutrymme std ;
int huvud ( ) {
konst storlek_t my_sVar = 1000 ;
int på ett [ my_sVar ] ;
storlek_t min storlek = storlek av ( på ett ) ;
cout << 'Maximal storlek på my_sVar = ' << SIZE_MAX << endl ;
cout << 'När du arbetar med en array av tal, är typen size_t som följer.' ;
array < storlek_t , 10 > min_arr ;
för ( storlek_t a = 0 ; a ! = min_arr. storlek ( ) ; ++ a )
min_arr [ a ] = a ;
för ( storlek_t a = min_arr. storlek ( ) - 1 ; a < min_arr. storlek ( ) ; -- a )
cout << min_arr [ a ] << ' ' ;
lämna tillbaka 0 ;
}
Produktion:
Den renderar den maximala storleken på variabeln först och renderar sedan arrayen i fallande ordning.
Exempel 5:
Den här koden inkluderar rubrikfilerna 'cstddef', 'iostream' och 'array'. Eftersom denna kod kräver att vi arbetar med 'arrayer' och funktioner, placeras 'array'-huvudfilen här. För att återge storleken på variabeln 'var', deklarerar vi den här med värdet 'const size_t' och initierar den med '1000'. Den maximala storleken på variabeln 'var' renderas sedan här eftersom vi använde funktionen 'cout' och angav 'SIZE_MAX' i det här fältet.
Därefter försöker vi visa objekten av arraytyp i mindre kvantiteter. Hittills har vi bara valt att visa 20 eftersom 1000 skulle fylla utgången. Vi visar hur 'size_t' kan användas för både indexering och räkning med typen 'size_t' och börjar vid index 0. Matrisen visas sedan i fallande ordning eftersom siffrorna kommer att minska som indikeras av placeringen av '–a' i följande kod:
Kod 5:
#include#include
#inkludera
använder sig av namnutrymme std ;
int huvud ( ) {
konst storlek_t var = 1000 ;
cout << 'Maximal storlek på var = ' << SIZE_MAX << endl ;
cout << 'Size_t-typen som används med en array av siffror anges som' ;
array < storlek_t , tjugo > array_num ;
för ( storlek_t i = 0 ; i ! = array_num. storlek ( ) ; ++ i )
array_num [ i ] = i ;
för ( storlek_t i = array_num. storlek ( ) - 1 ; i < array_num. storlek ( ) ; -- i )
cout << array_num [ i ] << ' ' ;
lämna tillbaka 0 ;
}
Produktion :
Den renderar arrayen i en minskande sekvens efter att ha renderat variabeln till dess maximala storlek.
Slutsats
Typen 'size_t' i C++-programmering utforskades noggrant i den här artikeln. Vi definierade att vi använder 'size_t' i våra C++-koder eftersom det lagrar dess största värde. Vi förklarade också att det är en osignerad typ och att den inte kan vara negativ. Vi demonstrerade koderna för C++-programmering där vi använde 'size_t' och återgav sedan deras resultat i den här artikeln.