ఉదాహరణ 1:
'stddef.h', 'పరిమితులు' మరియు 'iostream' అనే విభిన్న హెడర్ ఫైల్‌లు ఇక్కడ దిగుమతి చేయబడ్డాయి. తరచుగా ఉపయోగించే వేరియబుల్స్, రకాలు మరియు పాయింటర్‌ల నిర్వచనాలు “stddef.h”లో కనుగొనబడతాయి మరియు “పరిమితులు” హెడర్ ఫైల్ వివిధ డేటా రకాలైన కనిష్ట మరియు గరిష్ట విలువలు వంటి సమగ్ర రకాల సరిహద్దులను సూచించే స్థిరాంకాలుగా ఉపయోగించబడుతుంది. , ఈ హెడర్ ఫైల్ ద్వారా యాక్సెస్ చేయవచ్చు. అప్పుడు, “iostream” జోడించబడుతుంది ఎందుకంటే డేటాను ఇన్‌పుట్/అవుట్‌పుట్ చేయడానికి ఉపయోగించే ఫంక్షన్‌లు దానిలో నిర్వచించబడ్డాయి.
దీని తరువాత, “std” నేమ్‌స్పేస్ ఇక్కడ జోడించబడుతుంది. దీని కింద, “ప్రధాన()” పద్ధతి అమలు చేయబడుతుంది. దీని లోపల, మేము ఇక్కడ ఉంచే డేటాను అందించడంలో సహాయపడే “కౌట్”ని ఉంచుతాము. 'సంఖ్య_పరిమితులు:: గరిష్టం()' టైప్ చేయబడింది, ఎందుకంటే ఇది సంఖ్యా రకం 'T' సూచించగల అత్యధిక పరిమిత విలువను తిరిగి ఇస్తుంది. ప్రతి సరిహద్దు రకానికి ఇది ముఖ్యమైనది కానీ అది ప్రతికూలంగా ఉండకూడదు.
కోడ్ 1:
#include
# <పరిమితులు> చేర్చండి
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
కోట్ << 'size_t గరిష్ట పరిమాణం' << సంఖ్యా_పరిమితులు :: గరిష్టంగా ( ) << endl ;
}
అవుట్‌పుట్:
'T' రకం యొక్క గరిష్ట పరిమాణం ఇప్పుడు రెండర్ చేయబడిందని మేము గమనించవచ్చు, ఇది క్రింది వాటిలో చూపిన విధంగా చాలా పెద్ద విలువ.
ఉదాహరణ 2:
“పరిమితులు” మరియు “iostreamతో సహా ఇక్కడ రెండు హెడర్ ఫైల్‌లు దిగుమతి చేయబడ్డాయి. డేటాను ఇన్‌పుట్ చేయడానికి మరియు అవుట్‌పుట్ చేయడానికి అవసరమైన ఫంక్షన్‌లు దానిలో నిర్వచించబడినందున, “iostream” ఇక్కడ జోడించబడింది. అప్పుడు, వివిధ డేటా రకాల కోసం కనిష్ట మరియు గరిష్ట విలువలు వంటి సమగ్ర రకాల సరిహద్దులను వివరించే స్థిరాంకాలను యాక్సెస్ చేయడానికి “పరిమితులు” హెడర్ ఫైల్ ఉపయోగించబడుతుంది.
తదనంతరం, ఇక్కడ “std” నేమ్‌స్పేస్ పరిచయం చేయబడింది మరియు “main()” ఫంక్షన్ అంటారు. దీని కింద, C++ ప్రోగ్రామింగ్‌లో పూర్ణాంక డేటా రకం ఎగువ బౌండ్ యొక్క అత్యధిక విలువను అందించడానికి మేము 'కౌట్' లోపల 'INT_MAX'ని ఉపయోగిస్తాము. తర్వాత, కింది లైన్‌లో, అత్యధిక విలువను ఇచ్చే “size_t”ని ఉపయోగిస్తాము.
కోడ్ 2:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
కోట్ << 'గరిష్ట పూర్ణాంకం విలువ:' << INT_MAX << endl ;
కోట్ << 'size_t ఫంక్షన్ కలిగి ఉన్న పరిమాణం:' << ( పరిమాణం_t ) 0 - 1 << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
పూర్ణాంకం యొక్క గరిష్ట పరిమాణం ముందుగా రెండర్ చేయబడుతుంది, దీనిని మనం 'INT_MAX' సహాయంతో పొందుతాము. ఆ తర్వాత, “size_t” స్టోర్ చేసే గరిష్ట పరిమాణం ఈ కోడ్‌లో “size_t” సహాయంతో మనకు లభిస్తుంది.
ఉదాహరణ 3:
ఇక్కడ, రెండు హెడర్ ఫైల్‌లు, “క్లిమిట్స్” మరియు “iostream” దిగుమతి చేయబడ్డాయి. డేటాను ఇన్‌పుట్ చేయడానికి మరియు అవుట్‌పుట్ చేయడానికి అవసరమైన విధులు నిర్వచించబడినందున “iostream” ఇక్కడ చేర్చబడింది. తరువాత, వివిధ డేటా రకాల కనిష్ట మరియు గరిష్ట విలువలు వంటి సమగ్ర రకాల సరిహద్దులను వివరించే స్థిరాంకాలు 'క్లిమిట్స్' హెడర్ ఫైల్‌ని ఉపయోగించి యాక్సెస్ చేయబడతాయి.
ఇక్కడ, “main()” ఫంక్షన్ ఇప్పుడు ప్రారంభించబడింది మరియు “std” నేమ్‌స్పేస్ తరువాత పరిచయం చేయబడింది. దీని క్రింద, C++ ప్రోగ్రామింగ్‌లో పూర్ణాంక డేటా రకం గరిష్ట విలువ యొక్క ఎగువ సరిహద్దును అవుట్‌పుట్ చేయడానికి మేము 'కౌట్' లోపల 'INT_MAX'ని ఉపయోగిస్తాము. దీని కింద, మేము 'INT_MIN'ని ఉపయోగిస్తాము, ఇది 'int' డేటా రకం యొక్క తక్కువ విలువను అందిస్తుంది. అప్పుడు, మేము “size_t”ని ఉపయోగిస్తాము, ఇది క్రింది లైన్‌లో నిల్వ చేసే గరిష్ట విలువను ఇస్తుంది:
కోడ్ 3:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
కోట్ << 'అతిపెద్ద పూర్ణాంకం విలువ:' << INT_MAX << endl ;
కోట్ << 'చిన్న పూర్ణాంకం:' << INT_MIN << endl ;
కోట్ << 'size_t ఫంక్షన్ కలిగి ఉన్న పరిమాణం:' << ( పరిమాణం_t ) 0 - 1 << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ముందుగా, 'INT_MAX' సహాయంతో మనం పొందే పూర్ణాంకం యొక్క గరిష్ట పరిమాణం ప్రదర్శించబడుతుంది. రెండవది, 'INT_MIN' సహాయంతో మనం పొందే పూర్ణాంకం యొక్క కనీస పరిమాణం ప్రదర్శించబడుతుంది. ఆపై, ఈ కోడ్‌లోని “size_t” సహాయంతో, “size_t” స్టోర్‌లు రెండర్ చేయబడిన గరిష్ట పరిమాణం.
ఉదాహరణ 4:
ఈ కోడ్‌లో చేర్చబడిన హెడర్ ఫైల్‌లు “cstddef”, “iostream”, అలాగే “array”. ఈ హెడర్ ఫైల్‌లు చేర్చబడ్డాయి కాబట్టి మేము ఈ హెడర్ ఫైల్‌లలో నిర్వచించబడిన నిర్వచనాలను ఉపయోగించుకోవచ్చు. ఈ కోడ్‌లోని “శ్రేణులు” మరియు ఫంక్షన్‌లతో మనం పని చేయాల్సి ఉన్నందున “శ్రేణి” హెడర్ ఫైల్ ఇక్కడ జోడించబడింది. మేము ఇక్కడ “my_sVar” వేరియబుల్‌ను “const size_t”తో ప్రకటిస్తాము మరియు దాని పరిమాణాన్ని రెండర్ చేయడానికి “1000” విలువతో దాన్ని ప్రారంభిస్తాము.
దీని తర్వాత, మేము “int” డేటా రకం యొక్క “num[]” శ్రేణిని కూడా ప్రకటిస్తాము మరియు దాని పరిమాణంగా “my_sVar”ని పాస్ చేస్తాము. అప్పుడు, మేము “size_of()” ఫంక్షన్‌ని ఉపయోగిస్తాము, దీనిలో మేము “num” వేరియబుల్‌ను పారామీటర్‌గా ఉంచుతాము మరియు దానిని “size_t” రకం యొక్క “my_size” వేరియబుల్‌లో నిల్వ చేస్తాము. అప్పుడు, మేము ఇక్కడ “cout”ని ఉపయోగిస్తాము మరియు “SIZE_MAX” అని టైప్ చేస్తాము కాబట్టి ఇది “my_sVar” వేరియబుల్ యొక్క గరిష్ట పరిమాణాన్ని అందిస్తుంది.
తరువాత, మేము శ్రేణి-రకం మూలకాలను చిన్న సంఖ్యలో చూపుతాము. మేము 10ని 1000గా చూపించడానికి మాత్రమే ఎంచుకుంటాము, ఇది అవుట్‌పుట్‌లో సరిపోయేంత ఎక్కువ. “size_t” రకాన్ని ఉపయోగించి, ఇండెక్సింగ్ మరియు లెక్కింపు రెండింటికీ “size_t” ఎలా ఉపయోగించబడుతుందో చూపించడానికి మేము సూచిక 0 వద్ద ప్రారంభిస్తాము. సంఖ్యలు తగ్గుతాయి కాబట్టి, మేము కోడ్‌లో “–a”ని ఉంచినప్పుడు శ్రేణి అవరోహణ క్రమంలో చూపబడుతుంది.
కోడ్ 4:
##
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
స్థిరంగా పరిమాణం_t నా_sVar = 1000 ;
int ఒకదానిపై [ నా_sVar ] ;
పరిమాణం_t నా_పరిమాణం = పరిమాణం ( ఒకదానిపై ) ;
కోట్ << 'my_sVar గరిష్ట పరిమాణం =' << SIZE_MAX << endl ;
కోట్ << 'సంఖ్యల శ్రేణితో పని చేస్తున్నప్పుడు, size_t రకం క్రింది విధంగా ఉంటుంది.' ;
అమరిక < పరిమాణం_t , 10 > నా_అర్ ;
కోసం ( పరిమాణం_t a = 0 ; a ! = నా_అర్. పరిమాణం ( ) ; ++ a )
నా_అర్ [ a ] = a ;
కోసం ( పరిమాణం_t a = నా_అర్. పరిమాణం ( ) - 1 ; a < నా_అర్. పరిమాణం ( ) ; -- a )
కోట్ << నా_అర్ [ a ] << '' ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇది ముందుగా వేరియబుల్ యొక్క గరిష్ట పరిమాణాన్ని రెండర్ చేస్తుంది మరియు శ్రేణిని అవరోహణ క్రమంలో అందిస్తుంది.
ఉదాహరణ 5:
ఈ కోడ్ “cstddef”, “iostream” మరియు “array” హెడర్ ఫైల్‌లను కలిగి ఉంటుంది. ఈ కోడ్‌కి మనం “శ్రేణులు” మరియు ఫంక్షన్‌లతో పని చేయాల్సి ఉంటుంది కాబట్టి, “శ్రేణి” హెడర్ ఫైల్ ఇక్కడ ఉంచబడుతుంది. “var” వేరియబుల్ యొక్క పరిమాణాన్ని రెండర్ చేయడానికి, మేము దానిని ఇక్కడ “const size_t” విలువతో ప్రకటిస్తాము మరియు దానిని “1000”తో ప్రారంభించాము. మేము ఈ ఫీల్డ్‌లో “కౌట్” ఫంక్షన్‌ని ఉపయోగించాము మరియు “SIZE_MAX”ని పేర్కొన్నందున “var” వేరియబుల్ యొక్క గరిష్ట పరిమాణం ఇక్కడ రెండర్ చేయబడుతుంది.
తరువాత, మేము శ్రేణి-రకం అంశాలను చిన్న పరిమాణంలో ప్రదర్శించడానికి ప్రయత్నిస్తాము. ఇప్పటివరకు, మేము 20ని మాత్రమే ప్రదర్శించడానికి ఎంచుకున్నాము ఎందుకంటే 1000 అవుట్‌పుట్‌ను నింపుతుంది. మేము 'size_t'ని ఇండెక్సింగ్ మరియు లెక్కింపు రెండింటికీ 'size_t' రకాన్ని ఉపయోగించి మరియు ఇండెక్స్ 0 నుండి ఎలా ఉపయోగించవచ్చో ప్రదర్శిస్తాము. ఆ తర్వాత శ్రేణి అవరోహణ క్రమంలో ప్రదర్శించబడుతుంది, ఎందుకంటే '–a'ని ఉంచడం ద్వారా సంఖ్యలు తగ్గుతాయి కింది కోడ్:
కోడ్ 5:
##
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
స్థిరంగా పరిమాణం_t ఉంది = 1000 ;
కోట్ << 'వర్ యొక్క గరిష్ట పరిమాణం =' << SIZE_MAX << endl ;
కోట్ << 'సంఖ్యల శ్రేణితో ఉపయోగించబడిన size_t రకం ఇలా ఇవ్వబడింది' ;
అమరిక < పరిమాణం_t , ఇరవై > శ్రేణి_సంఖ్య ;
కోసం ( పరిమాణం_t i = 0 ; i ! = శ్రేణి_సంఖ్య. పరిమాణం ( ) ; ++ i )
శ్రేణి_సంఖ్య [ i ] = i ;
కోసం ( పరిమాణం_t i = శ్రేణి_సంఖ్య. పరిమాణం ( ) - 1 ; i < శ్రేణి_సంఖ్య. పరిమాణం ( ) ; -- i )
కోట్ << శ్రేణి_సంఖ్య [ i ] << '' ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
ఇది వేరియబుల్‌ను గరిష్ట పరిమాణానికి రెండర్ చేసిన తర్వాత తగ్గుతున్న క్రమంలో శ్రేణిని రెండర్ చేస్తుంది.
ముగింపు
C++ ప్రోగ్రామింగ్‌లోని “size_t” రకం ఈ కథనంలో పూర్తిగా అన్వేషించబడింది. మేము మా C++ కోడ్‌లలో “size_t”ని ఉపయోగించాలని నిర్వచించాము, ఎందుకంటే ఇది దాని అతిపెద్ద విలువను నిల్వ చేస్తుంది. ఇది సంతకం చేయని రకం మరియు ఇది ప్రతికూలంగా ఉండదని కూడా మేము వివరించాము. మేము C++ ప్రోగ్రామింగ్ కోడ్‌లను ప్రదర్శించాము, అక్కడ మేము 'size_t'ని ఉపయోగించాము మరియు ఈ కథనంలో వాటి ఫలితాలను అందించాము.