C++ Constexpr స్ట్రింగ్ యొక్క ఉపయోగం ఏమిటి?
constexprని ఉపయోగించడం మరింత కాంపాక్ట్ మరియు ఆప్టిమైజ్ చేయబడిన ఎక్జిక్యూటబుల్ ఫైల్‌లకు దారి తీస్తుంది. కంపైలర్ ద్వారా విలువలు ముందుగానే నిర్ణయించబడతాయి కాబట్టి, ఫలితంగా వచ్చే బైనరీలు పరిమాణంలో చిన్నవిగా ఉంటాయి, సిస్టమ్ వనరులను మరింత పొదుపుగా ఉపయోగించడం ద్వారా వివిధ ప్లాట్‌ఫారమ్‌లలో సాఫ్ట్‌వేర్ పనితీరును మెరుగుపరుస్తుంది. ఈ ఫీచర్ యొక్క ఒక ప్రత్యేక ముఖ్యమైన ప్రయోజనం ఏమిటంటే ఇది రన్‌టైమ్ గణనలను తగ్గించడం. సాధ్యమైనప్పుడల్లా సంకలన ప్రక్రియలో విలువలు లెక్కించబడతాయి, రన్‌టైమ్ మూల్యాంకనం తక్కువ అవసరం అవుతుంది. ఈ సమర్థత బూస్ట్ అమలును వేగవంతం చేయడమే కాకుండా మొత్తం ప్రోగ్రామ్ కార్యకలాపాలను క్రమబద్ధం చేస్తుంది.
ఉదాహరణ 1: ఫ్యాక్టోరియల్ కాలిక్యులేషన్ కోసం C++లో Constexprని ఉపయోగించడం
ఈ ఉదాహరణలో, మేము రన్-టైమ్‌లో కాకుండా కంపైల్-టైమ్‌లో గణనలను నిర్వహించడానికి అనుమతించే constexprని ఉపయోగిస్తాము. కారకాలను లెక్కించే సందర్భంలో, ఒక సాధారణ గణిత ఆపరేషన్, ఇది constexpr, సంకలనం సమయంలో కారకాల విలువలను గణించడానికి పరపతిని ఉపయోగించవచ్చు. కింది కోడ్‌ని పరిశీలించి, సమీక్షించి, కోడ్ యొక్క వివరణను చూద్దాం:
#
constexpr int కారకమైన ( int n ) {
తిరిగి n <= 1 ? 1 : ( n * కారకమైన ( n - 1 ) ) ;
}
int ప్రధాన ( ) {
int ఒకదానిపై = 5 ;
std :: కోట్ << 'కారకం' << ఒకదానిపై << ' = ' << కారకమైన ( ఒకదానిపై ) << std :: endl ;
}
ఇవ్వబడిన కోడ్ ఉదాహరణ పునరావృత మార్గంలో సంఖ్య యొక్క కారకాన్ని లెక్కించడానికి constexpr యొక్క ఉపయోగాన్ని ప్రదర్శిస్తుంది. కంపైలర్ ఈ ఉదాహరణలో కంపైల్-టైమ్‌లో ఫాక్టోరియల్ ఎక్స్‌ప్రెషన్‌ను మూల్యాంకనం చేయగలదు ఎందుకంటే ఫాక్టోరియల్ ఫంక్షన్ ప్రకటించబడింది మరియు constexpr స్పెసిఫైయర్‌తో నిర్వచించబడింది. C++ ప్రోగ్రామ్‌లో constexprని ఉపయోగించి, కంపైలర్ రన్‌టైమ్ గణన అవసరాన్ని తొలగిస్తూ, కంపైల్ సమయంలో 5 యొక్క కారకం వ్యక్తీకరణను అంచనా వేస్తుంది.
ఇప్పుడు, నిర్దిష్ట వివరాలు మరియు వివరణలతో కోడ్ యొక్క వివరణాత్మక బ్రేక్‌డౌన్‌ను చూద్దాం.
ముందుగా, కన్సోల్‌కి ప్రింటింగ్ కోసం అవసరమైన ఇన్‌పుట్ మరియు అవుట్‌పుట్ ఫంక్షనాలిటీలైన “std::cout” వంటి వాటిని అందించే “iostream” హెడర్ ఫైల్‌ను చేర్చడానికి మేము #include
తరువాత, మేము 'constexpr int factorial (int n)' అయిన కారకం() ఫంక్షన్ (పునరావృత)లోకి వెళ్తాము. ఈ కారకం() ఫంక్షన్ ఒక 'n' పూర్ణాంకం యొక్క కారకాన్ని లెక్కించే పునరావృత ఫంక్షన్‌ను నిర్వచిస్తుంది. కంపైలేషన్ సమయంలో ఫంక్షన్‌ను మూల్యాంకనం చేయడం వల్ల పనితీరు ఆప్టిమైజేషన్లు జరుగుతాయని Constexpr సూచిస్తుంది.
రిటర్న్ n <= 1 ? 1 : (n * factorial(n – 1)) లైన్ రికర్షన్ కోసం షరతులతో కూడిన వ్యక్తీకరణను ఉపయోగిస్తుంది, ఇది “n” 1 కంటే తక్కువగా లేదా సమానంగా ఉంటే, అది 1 (బేస్ కేస్)ని అందిస్తుంది. కాకపోతే, అది ఫాక్టోరియల్ గణనను (n! = n * (n-1)!) చేస్తుంది, ఇది ఫాక్టోరియల్‌ను కంప్యూటింగ్ చేయడానికి సాధారణ సూత్రం, పదే పదే “n – 1”తో కాల్ చేసి, ఆపై ఫలితాన్ని “nతో గుణించాలి. ”. ఈ పంక్తులు కారకం గణన కోసం గేట్ కీపర్ లాగా పనిచేస్తాయి. ఇది సంఖ్య బేస్ స్థాయిలో ఉందో లేదో తనిఖీ చేస్తుంది మరియు అలా అయితే 1ని అందిస్తుంది. కాకపోతే, ఇది ఫంక్షన్ కాల్‌ల చైన్ రియాక్షన్‌ను ప్రారంభిస్తుంది, ప్రతి ఒక్కటి బేస్ కేస్ చేరే వరకు చిన్న సంఖ్యలపై పని చేస్తుంది. అప్పుడు, ఫలితాలు రివర్స్ క్రమంలో కలిసి గుణించబడతాయి. మీ సూచన కోసం కోడ్ యొక్క అవుట్‌పుట్ క్రిందిది:
ఉదాహరణ 2: C++ Constexpr స్ట్రింగ్‌ని ప్రదర్శించే చిన్న అక్షరాలను లెక్కించడం
ఇక్కడ, మేము counterexpr స్ట్రింగ్ ఉపయోగించి చిన్న అక్షరాల సంఖ్యను ఎలా లెక్కించాలో నేర్చుకుంటాము. ఈ ఉదాహరణలో, రన్‌టైమ్ గణనను తగ్గించడానికి constexpr ఫీచర్‌ని ఉపయోగించి ఇచ్చిన స్ట్రింగ్‌లోని చిన్న అక్షరాల సంఖ్యను లెక్కించడం దీని ఉద్దేశ్యం. CountLowercase() ఫంక్షన్, constexprగా ప్రకటించబడింది, 'string_view' స్ట్రింగ్‌ను దాని పారామీటర్‌గా తీసుకుంటుంది మరియు ఇన్‌పుట్‌గా ఇచ్చిన స్ట్రింగ్‌లోని ప్రతి అక్షరం ద్వారా పునరావృతమవుతుంది. మనకు ఎదురయ్యే ప్రతి చిన్న అక్షరానికి, గణన పెరుగుతుంది. కంపైల్-సమయ మూల్యాంకనం యొక్క సామర్థ్యం మరియు పనితీరు ప్రయోజనాలను ప్రదర్శిస్తూ, ఫంక్షన్ స్థిరమైన వ్యక్తీకరణలపై పని చేస్తున్నందున ఫలితం కంపైల్ సమయంలో పొందబడుతుంది. ముందుగా, కింది కోడ్‌ను తనిఖీ చేయండి. అప్పుడు, వివరణాత్మక వివరణకు వెళ్లండి:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
constexpr పరిమాణం_t చిన్న అక్షరం ( స్ట్రింగ్_వ్యూ లు ) {
పరిమాణం_t లెక్కించండి = 0 ;
కోసం ( చార్ సి : లు ) {
ఉంటే ( తక్కువ ( సి ) ) {
లెక్కించండి ++;
}
}
తిరిగి లెక్కించండి ;
}
int ప్రధాన ( ) {
కోట్ << 'లో మొత్తం చిన్న అక్షరాలు' లోవేర్ కేస్ లెటర్స్ 'అవి ='
<< చిన్న అక్షరం ( 'లోవెర్ కేస్ లెటెర్స్' ) << endl ;
}
ప్రతి లైన్ యొక్క వివరణతో కోడ్ యొక్క వివరణాత్మక విచ్ఛిన్నం ఇక్కడ ఉంది:
సందేశాలను ప్రింట్ చేయడానికి ప్రామాణిక ఇన్‌పుట్/అవుట్‌పుట్ స్ట్రీమ్ లైబ్రరీని ఉపయోగించడానికి #include
countLowercase() ఫంక్షన్‌లో, “constexpr size_t countlower(string_view s)” ఫంక్షన్, ఇచ్చిన స్ట్రింగ్ వీక్షణలో చిన్న అక్షరాలను గణిస్తుంది. Int main() అనేది ప్రోగ్రామ్ యొక్క ఎంట్రీ పాయింట్, ఇది “LoWeR CaSe LeTtErS”లో చిన్న అక్షరాల సంఖ్యను సూచించే సందేశాన్ని ప్రింట్ చేస్తుంది మరియు “LoWeR CaSe LeTtErS”తో కౌంట్‌లోవర్‌కేస్() ఫంక్షన్‌ను ఇన్‌పుట్‌గా పిలుస్తుంది మరియు ఫలితాన్ని ప్రింట్ చేస్తుంది. ప్రోగ్రామ్ యొక్క క్రింది అవుట్‌పుట్‌ను చూడండి:
ఉదాహరణ 3: C++ Constexprని ఉపయోగించడం ద్వారా అర్రే ప్రదర్శన
ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో ఒకే రకమైన డేటా రకానికి చెందిన మూలకాల యొక్క నిర్మాణాత్మక సేకరణలు ఎలా సృష్టించబడతాయి, యాక్సెస్ చేయబడతాయి మరియు తారుమారు చేయబడతాయో అర్రే ప్రదర్శన చూపిస్తుంది. కింది వాటిలో, మేము ఒక కోడింగ్ ఉదాహరణ ద్వారా వివరిస్తాము, దీనిలో ప్రోగ్రామ్ కంపైల్-టైమ్ అర్రే ఇనిషియలైజేషన్ మరియు మానిప్యులేషన్ యొక్క సాధారణ ఉదాహరణను అందిస్తుంది.
శ్రేణి ప్రదర్శన శ్రేణుల భావనను వివరిస్తుంది-ఒకే డేటా రకాన్ని పంచుకునే మూలకాల యొక్క నిర్మాణాత్మక సేకరణ-మరియు ప్రోగ్రామింగ్ భాషను ఉపయోగించి వాటిని ఎలా సృష్టించవచ్చు, యాక్సెస్ చేయవచ్చు మరియు మార్చవచ్చు. కింది కోడింగ్ ఉదాహరణలో, కంపైల్-టైమ్‌లో శ్రేణిని ఎలా ప్రారంభించాలో, దాని పరిమాణాన్ని లెక్కించడం మరియు ఇచ్చిన శ్రేణి యొక్క మూలకాలను ఎలా ముద్రించాలో మేము ప్రదర్శిస్తాము. కింది ఇవ్వబడిన కోడ్‌ని చూడండి మరియు వివరణకు వెళ్లండి:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
constexpr int శ్రేణి [ 9 ] = { 5 , 55 , 555 , 5555 , 55555 } ;
constexpr int పరిమాణం_శ్రేణి = పరిమాణం శ్రేణి / పరిమాణం ( int ) ;
కోట్ << 'అరే యొక్క పొడవు =' << పరిమాణం_శ్రేణి << endl ;
కోట్ << 'శ్రేణిలోని మూలకాలు =' ;
కోసం ( int i = 0 ; i < పరిమాణం_శ్రేణి ; ++ i ) {
కోట్ << శ్రేణి [ i ] << '' ;
}
}
ఈ ప్రోగ్రామ్ constexpr శ్రేణిని ప్రారంభిస్తుంది, కంపైల్ సమయంలో దాని పొడవును గణిస్తుంది, ఆపై శ్రేణి యొక్క పొడవు మరియు మూలకాలను కన్సోల్‌కు ముద్రిస్తుంది. కంపైల్ సమయంలో శ్రేణి మరియు దాని లక్షణాలు నిర్ణయించబడతాయని Constexpr నిర్ధారిస్తుంది. కోడ్‌ను విచ్ఛిన్నం చేసి, నిర్దిష్ట వివరాలను ఒక్కొక్కటిగా వివరిస్తాము:
ప్రామాణిక ఇన్‌పుట్-అవుట్‌పుట్ స్ట్రీమ్ లైబ్రరీని చేర్చడానికి, అవుట్‌పుట్ కోసం “కౌట్” వంటి ఫంక్షన్‌ల వినియోగాన్ని అనుమతిస్తుంది, #include
'ఫర్' లూప్ 'అరేయింట్[]'అరే యొక్క మూలకాల ద్వారా పునరావృతమవుతుంది మరియు విలువలు కన్సోల్‌కు ముద్రించబడతాయి. ఇవ్వబడిన కోడ్ యొక్క క్రింది అవుట్‌పుట్‌ని చూద్దాం:
ముగింపు
C++లో constexpr కీవర్డ్ పరిచయం మరియు పరిణామం స్థిరమైన వ్యక్తీకరణలు మరియు విలువలు ఎలా నిర్వహించబడతాయో విప్లవాత్మకంగా మార్చాయి. ఈ వ్యాసం మూడు ఆచరణాత్మక ఉదాహరణలను అన్వేషించింది, కంప్యూటింగ్ ఫ్యాక్టోరియల్స్, చిన్న అక్షరాలను లెక్కించడం మరియు కంపైల్ సమయంలో శ్రేణులను ప్రారంభించడంలో constexpr యొక్క శక్తిని ప్రదర్శిస్తుంది. మెరుగైన పనితీరు, తగ్గిన రన్‌టైమ్ గణనలు మరియు మెరుగైన మెమరీ సామర్థ్యం వంటి ముఖ్యమైన టేకావేలు ఉన్నాయి. Constexpr అనేది ఒక కోడ్‌బేస్‌లో విశ్వసనీయమైన, స్థిరమైన ఎంటిటీలను సృష్టించడం, మార్పులేని మరియు మరింత క్రమబద్ధీకరించబడిన మరియు సమర్థవంతమైన ప్రోగ్రామ్‌లకు సహకరించడం కోసం విలువైన ఆస్తి.