“isnumber()” అనేది C++ భాష అందించిన ఫంక్షన్, ఇది నమోదు చేయబడిన డేటాలో సంఖ్య ఉందో లేదో తనిఖీ చేయడంలో సహాయపడుతుంది. దురదృష్టవశాత్తూ, ఈ “isnumber()” ఫంక్షన్ కేవలం Mac లేదా Apple వినియోగదారుల కోసం మాత్రమే. కానీ C++ భాష మనకు “isnumber()” ఫంక్షన్‌తో సమానమైన “isdigit()” ఫంక్షన్‌తో కూడా సులభతరం చేస్తుంది. నమోదు చేసిన డేటాలోని సంఖ్యను కనుగొనడంలో రెండు విధులు సహాయపడతాయి. “isdigit()” అనేది “isnumber()” ఫంక్షన్‌కి ప్రత్యామ్నాయం అని కూడా మనం చెప్పగలం. ఇక్కడ, మేము మాక్‌ని కలిగి లేనందున “isdigit()” ఫంక్షన్‌ని అన్వేషిస్తాము మరియు రెండు ఫంక్షన్‌లు ఒకేలా ఉంటాయి.
ఉదాహరణ 1:
మాకు ఈ కోడ్‌లో “iosream” హెడర్ ఫైల్ అవసరం. కాబట్టి, 'సిన్\cout' ఫంక్షన్ యొక్క ఫంక్షన్ నిర్వచనాలను కలిగి ఉన్నందున మేము దానిని ఇక్కడ చేర్చాము. దీని కింద, ప్రామాణిక నేమ్‌స్పేస్ “std” జోడించబడింది. మేము డ్రైవర్ కోడ్ అయిన “ప్రధాన()” పద్ధతిని అమలు చేస్తాము. ఇప్పుడు, మేము మొదట 'కౌట్' సహాయంతో ఒక పంక్తిని ప్రింట్ చేస్తాము. తరువాత, కింది “కౌట్”లో, మనం “2”ని పారామీటర్‌గా పాస్ చేసే “isdigit()” ఫంక్షన్‌ని ఉపయోగిస్తాము. ఇప్పుడు, ఈ “isdigit()” ఫంక్షన్ “2” అంకె కాదా అని తనిఖీ చేస్తుంది. “2” అంకె అయితే, అది “1”ని అందిస్తుంది. అది కాకపోతే, '0' అనేది ఈ ఫంక్షన్ యొక్క ఫలితం.
కోడ్ 1:
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
కోట్ << 'విలువ అంకె లేదా కాదు:' ;
కోట్ << కూడా ( '2' ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ ఫలితం “1”ని అన్వయిస్తుంది అంటే మనం గతంలో నమోదు చేసిన డేటా అంకె లేదా సంఖ్య అని అర్థం. కాబట్టి, ఈ “isdigit()” ఫంక్షన్ “1”ని అందిస్తుంది.
ఉదాహరణ 2:
మేము నిర్వచించిన ఫంక్షన్‌లను ఉపయోగించాల్సి ఉన్నందున ఈ సందర్భంలో మూడు హెడర్ ఫైల్‌లు చేర్చబడ్డాయి. మేము “cctype” మరియు “iostream” అలాగే “cstring” హెడర్ ఫైల్‌ను దిగుమతి చేస్తాము. క్యారెక్టర్ టెస్టింగ్ మరియు మానిప్యులేషన్ ఫంక్షన్‌లను అందిస్తున్నందున “cctype” హెడర్ ఫైల్ చేర్చబడింది. ఇన్‌పుట్ మరియు అవుట్‌పుట్ ఫంక్షన్‌లను అందిస్తున్నందున “iostream” హెడర్ ఫైల్ చేర్చబడుతుంది మరియు మన కోడ్‌లోని స్ట్రింగ్‌లకు మనం వర్తించే ఫంక్షన్‌ను అందించే విధంగా “cstring” చేర్చబడుతుంది.
ఇప్పుడు, “std” మరియు “main()” పద్ధతులు ప్రారంభించబడ్డాయి. అప్పుడు, అక్షర శ్రేణి ప్రారంభించబడుతుంది, అక్కడ మనం సంఖ్యలతో సహా స్ట్రింగ్ డేటాను నమోదు చేస్తాము. “strDigit[]” అనేది ఇక్కడ “char” యొక్క శ్రేణి. అప్పుడు, దీని కింద, మేము 'int' డేటా రకం యొక్క 'ఫలితాన్ని' ప్రకటిస్తాము. 'కౌట్' ఇచ్చిన వచనాన్ని రెండర్ చేస్తుంది. అప్పుడు, మేము అక్కడ 'ఫర్' లూప్‌ను ఉంచుతాము, దాని నుండి స్ట్రింగ్ యొక్క అక్షరాలు ఒక్కొక్కటిగా పాస్ చేయబడతాయి. అప్పుడు, మేము దీని తర్వాత ఉపయోగించుకునే “isdigit()” ఫంక్షన్, స్ట్రింగ్ అక్షరం అంకెలు కాదా అని తనిఖీ చేస్తుంది. ఇది అంకె అయితే, మనం ఈ “ఫలితం” వేరియబుల్‌ని “isdigit()” ఫంక్షన్‌తో ప్రారంభించినప్పుడు అది “ఫలితం” వేరియబుల్‌లో సేవ్ చేయబడుతుంది. అప్పుడు, మేము 'if'ని ఉంచుతాము మరియు 'ఫలితాన్ని' వాదనగా పాస్ చేసి, ఆపై 'cout' సహాయంతో సంఖ్యను ప్రదర్శిస్తాము.
కోడ్ 2:
##
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
చార్ strDigit [ ] = 'azz2@mp;1p8$.;qr' ;
పూర్తి ఫలితం;
కోట్ << 'స్ట్రింగ్ క్రింది అంకెలను కలిగి ఉంది:' << endl;
కోసం ( int a = 0 ; a < strlen ( strDigit ) ; a++ ) {
result = isdigit ( strDigit [ a ] ) ;
ఉంటే ( ఫలితం )
కోట్ << strDigit [ a ] << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము మునుపు జోడించిన స్ట్రింగ్‌లో ఇక్కడ రెండర్ చేయబడిన మూడు సంఖ్యలు ఉన్నాయి. 'isdigit()' ఫంక్షన్ సహాయంతో మేము ఈ సంఖ్యలను స్ట్రింగ్ నుండి పొందాము.
ఉదాహరణ 3:
మేము అందించిన ఫంక్షన్‌లను ఉపయోగించాల్సిన అవసరం ఉన్నందున ఈ సందర్భంలో మూడు హెడర్ ఫైల్‌లు చేర్చబడ్డాయి. ఇక్కడ, మేము 'cctype', 'iostream' మరియు 'cstring' కోసం హెడర్ ఫైల్‌లను దిగుమతి చేస్తాము. “std” నేమ్‌స్పేస్ జోడించబడింది మరియు “main()” ఫంక్షన్‌ని ఇప్పుడు అంటారు. ఆ తరువాత, మేము స్ట్రింగ్ డేటాను చొప్పించే అక్షర శ్రేణి ప్రారంభించబడుతుంది. ఇందులో పూర్ణాంకాలు ఉంటాయి. ఈ సందర్భంలో 'చార్' యొక్క శ్రేణిని 's[]' అంటారు. మేము దాని క్రింద ఉన్న 'int' డేటా రకం యొక్క 'అంకెలను' నిర్వచించాము.
పేర్కొన్న వచనం 'కౌట్' ద్వారా రెండర్ చేయబడుతుంది మరియు 'ఫర్' లూప్ చొప్పించబడుతుంది, దాని నుండి స్ట్రింగ్ యొక్క అక్షరాలు ఒక్కొక్కటిగా అందించబడతాయి. స్ట్రింగ్ అక్షరాలు అంకెలు కాదా అని నిర్ణయించడానికి “isdigit()” ఫంక్షన్ ఉపయోగించబడుతుంది. మేము 'isdigit()' ఫంక్షన్‌ని ఉపయోగించి 'అంకెలు' వేరియబుల్‌ని ప్రారంభించాము కాబట్టి, అది ఒక అంకె అయితే, అది 'డిజిట్స్' వేరియబుల్‌లో సేవ్ చేయబడుతుంది. తరువాత, మేము 'if' స్టేట్‌మెంట్‌ను ఇన్సర్ట్ చేస్తాము, 'అంకెలు'ని ఆర్గ్యుమెంట్‌గా పాస్ చేసి, నంబర్‌ను ప్రదర్శించడానికి 'కౌట్'ని ఉపయోగిస్తాము.
కోడ్ 3:
##
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
చార్ లు [ ] = 'నాకు 3 సోదరులు, 4 సోదరీమణులు, 7 మేనమామలు, 9 అత్త' ;
పూర్ణాంక అంకెలు;
కోట్ << 'ఈ వాక్యంలో అంకెలు ఉన్నాయి :' << endl;
కోసం ( int i = 0 ; i < strlen ( లు ) ; i++ ) {
అంకెలు = ఐస్ డిజిట్ ( లు [ i ] ) ;
ఉంటే ( అంకెలు )
కోట్ << లు [ i ] << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము ఇంతకు ముందు జోడించిన స్ట్రింగ్‌లోని నాలుగు అంకెలు క్రింది వాటిలో ప్రదర్శించబడతాయి. “isdigit()” పద్ధతి స్ట్రింగ్ నుండి సంఖ్యలను సంగ్రహించడానికి అనుమతిస్తుంది.
ఉదాహరణ 4:
ఈ కోడ్‌లో ఈ హెడర్ ఫైల్‌లు అవసరం కాబట్టి “cctype” మరియు “iostream” జోడించబడ్డాయి. అప్పుడు, మేము ఇక్కడ ప్రామాణిక “std” నేమ్‌స్పేస్‌ని ఉంచుతాము. ఇప్పుడు, మేము 'ప్రధాన ()' పద్ధతిని పిలుస్తాము. దీని తర్వాత, మేము 'char' డేటా రకం యొక్క నాలుగు వేరియబుల్‌లను 'z', '2', '5' విలువలతో 'character_1', 'character_2', 'character_3' మరియు 'character_4' పేర్లతో ప్రారంభిస్తాము మరియు '&', వరుసగా.
అప్పుడు, మేము 'isdigit()' ఫంక్షన్ సహాయంతో అన్ని అక్షరాలను తనిఖీ చేస్తాము మరియు 'cout'ని జోడించిన తర్వాత ఈ వేరియబుల్స్‌ను ఈ ఫంక్షన్‌లో విడిగా ఉంచుతాము. ఇచ్చిన అక్షరం ఒక సంఖ్య అయితే, అది అక్కడ “1”ని సూచిస్తుంది. లేకపోతే, అది '0'ని అందిస్తుంది. మనం అక్షరం లేదా వర్ణమాలను నమోదు చేస్తే, “isdigit()” ఫంక్షన్ యొక్క ఫలితం “0”.
కోడ్ 4:
##
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
చార్ క్యారెక్టర్_1 = 'తో' ;
చార్ క్యారెక్టర్_2 = '2' ;
చార్ క్యారెక్టర్_3 = '5' ;
చార్ క్యారెక్టర్_4 = '&' ;
కోట్ << పాత్ర_1 << 'ఒక అంకె:' << కూడా ( పాత్ర_1 ) << endl;
కోట్ << పాత్ర_2 << 'ఒక అంకె:' << కూడా ( పాత్ర_2 ) << endl;
కోట్ << పాత్ర_3 << 'ఒక అంకె:' << కూడా ( పాత్ర_3 ) << endl;
కోట్ << పాత్ర_4 << 'ఒక అంకె:' << కూడా ( పాత్ర_4 ) << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇప్పుడు, ఈ ఫలితం “1”ని రెండర్ చేస్తుంది, ఇక్కడ “isdigit()” ఫంక్షన్ సంఖ్యను కనుగొంటుంది మరియు కింది వాటిలో చూపిన విధంగా ప్రత్యేక అక్షరం లేదా వర్ణమాలను కనుగొనే చోట “0”ని రెండర్ చేస్తుంది:
ఉదాహరణ 5:
ఇక్కడ, మేము “క్యారెక్టర్” వేరియబుల్‌ని ప్రకటించి, ఆపై డేటాను నమోదు చేయమని వినియోగదారుకు చెప్పే పంక్తిని ప్రదర్శిస్తాము. దీని కింద, మేము వినియోగదారు ఇన్‌పుట్‌ను అంగీకరించే “సిన్”ని ఉంచుతాము మరియు దానిని “క్యారెక్టర్” వేరియబుల్‌లో సేవ్ చేస్తాము.
దీని క్రింద, మేము “isdigit()” ఫంక్షన్‌ను ఉంచుతాము మరియు ఈ ఫంక్షన్‌లో “అక్షర” వేరియబుల్‌ను పాస్ చేస్తాము, అది నమోదు చేసిన అక్షరం అంకెనా కాదా అని తనిఖీ చేస్తుంది. అప్పుడు, మేము ఇక్కడ టైప్ చేసిన మొదటి “కౌట్” స్టేట్‌మెంట్‌ను రెండర్ చేస్తాము. అంకె కాకపోతే, రెండవ “కౌట్” స్టేట్మెంట్ ప్రదర్శించబడుతుంది. ఇక్కడ, మేము వినియోగదారు ఇన్‌పుట్‌ను పొందుతాము మరియు వినియోగదారు ఇన్‌పుట్ డేటాకు “isdigit()” ఫంక్షన్‌ను వర్తింపజేస్తాము.
కోడ్ 5:
##
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
చార్ పాత్ర;
కోట్ << 'మీరు తనిఖీ చేయాలనుకుంటున్న డేటాను ఇక్కడ నమోదు చేయండి' <> పాత్ర;
కూడా ( పాత్ర ) ? కోట్ << 'ఇది ఒక అంకె.'
: కౌట్ << 'ఇది అంకె కాదు' ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
మనం “p” అయిన వర్ణమాలని నమోదు చేసినప్పుడు, అది “isdigit()” ఫంక్షన్ యొక్క ఫలితం వలె “ఇది అంకె కాదు” అని చెప్పే రెండవ ప్రకటనను ప్రదర్శిస్తుంది.
ఇప్పుడు, మేము మునుపటి కోడ్‌ను మళ్లీ అమలు చేస్తాము. ఈ సమయంలో, మేము ఇక్కడ '9' ఎంటర్ చేసి 'Enter' నొక్కండి. అప్పుడు, ఇది 'isdigit()' ఫంక్షన్ ఫలితంగా 'ఇది ఒక అంకె' అని చెప్పే మొదటి ప్రకటనను అందిస్తుంది.
మునుపటి కోడ్ మరోసారి అమలు చేయబడింది, కానీ మేము ఈసారి “@”ని చొప్పించి, “Enter” నొక్కండి. ఫలితంగా, 'ఇది అంకె కాదు' అనే రెండవ స్టేట్మెంట్, 'isdigit()' ఫంక్షన్ కారణంగా కనిపిస్తుంది.
ముగింపు
C++ ప్రోగ్రామింగ్‌లో “isnumber()” మరియు “isdigit()” ఒకే విధమైన విధులు అని మేము ఈ కథనంలో నిర్వచించాము. వ్యత్యాసం ఏమిటంటే, “isnumber()” అనేది Mac వినియోగదారుల కోసం, కాబట్టి మేము C++ ప్రోగ్రామింగ్‌లో “isnumber()” ఫంక్షన్ స్థానంలో “isdigit()” ఫంక్షన్‌ని ఉపయోగిస్తాము. నమోదు చేసిన డేటా నుండి సంఖ్యను తనిఖీ చేయడంలో మరియు తదనుగుణంగా ఫలితాన్ని అందించడంలో ఈ ఫంక్షన్ సహాయపడుతుందని మేము పూర్తిగా అన్వేషించాము.