ప్రోగ్రామింగ్ భాషలకు లైబ్రరీలు, ఫంక్షన్‌లు, సింటాక్స్ మరియు ఇతర విషయాలు వాటితో పని చేస్తున్నప్పుడు అవసరం. కాబట్టి, మా కోడ్‌లు ఎర్రర్‌లను కలిగి ఉండే అవకాశం ఉంది. C++లో ప్రోగ్రామింగ్‌లో అనేక రకాల లోపాలు ఉన్నాయి. మేము ఇక్కడ 'C++లో int సాధ్యం కాదు' లోపం గురించి చర్చిస్తాము. పూర్ణాంక రకం డేటా “int”తో మేము dereference ఆపరేటర్ “*”ని ఉపయోగించేందుకు ప్రయత్నించినప్పుడు ఈ లోపం సంభవిస్తుంది ఎందుకంటే “int” అనేది ఆదిమ డేటా రకం. మేము C++ ప్రోగ్రామింగ్‌లో “int”ని తగ్గించలేము. ఇక్కడ, 'C++' లోపంలో పూర్ణాంకానికి ప్రాధాన్యత ఇవ్వబడదు మరియు దాని పరిష్కారం పూర్తిగా అన్వేషించబడుతుంది. ఈ గైడ్‌లో కొన్ని కోడ్‌లు ఇవ్వబడ్డాయి, దీనిలో ఈ లోపం ఎలా సంభవిస్తుందో మరియు C++లో ఈ రకమైన లోపాన్ని ఎలా నిర్వహించాలో చూద్దాం.
ఉదాహరణ 1: Dereferencing Int
ఈ కోడ్‌లో, మేము C++లో “int”ని తగ్గించడానికి ప్రయత్నిస్తాము. ఇప్పుడు, మేము నిర్వచించిన ఫంక్షన్‌లను ఉపయోగించుకోవడానికి “iostream” హెడర్ ఫైల్‌ను చేర్చుతాము. దీని కింద, మేము “namespace std”ని ఉపయోగిస్తాము మరియు ఇక్కడ “main()” పద్ధతిని అమలు చేస్తాము. అప్పుడు, మేము “int” డేటా రకంతో “my_num” వేరియబుల్‌ని ప్రకటిస్తాము మరియు ఈ వేరియబుల్‌కు “99”ని కేటాయిస్తాము.
ఇప్పుడు, మేము “int” డేటా రకం యొక్క “my_value”ని ప్రకటిస్తాము మరియు దానిని “*my_num”తో ప్రారంభిస్తాము అంటే “int” డేటా రకానికి చెందిన “my_num” వేరియబుల్‌ను తగ్గించడానికి ప్రయత్నిస్తున్నామని అర్థం. కంపైల్ చేస్తున్నప్పుడు ఈ లైన్‌లో ఎర్రర్ ఏర్పడింది ఎందుకంటే మనం “int”ని డిరిఫరెన్స్ చేయలేము. మేము int dereferencing తర్వాత పొందే విలువను ప్రదర్శించాలనుకుంటున్నాము, కాబట్టి మేము 'my_value' వేరియబుల్‌ని జోడించిన 'cout'ని ఉంచుతాము.
కోడ్ 1:
#include
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
int my_num = 99 ;
int my_value = * నా_సంఖ్య;
కోట్ << 'పూర్ణాంకాన్ని తీసివేయడం ద్వారా మనకు లభించే విలువ:' << నా_విలువ << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, విలువ ఏదీ ప్రదర్శించబడలేదని మరియు '*' యొక్క చెల్లని రకం ఆర్గ్యుమెంట్ ఉందని చెప్పే లోపం సంభవించిందని మేము గమనించవచ్చు. దీని అర్థం మనం C++లో “int”ని డీరిఫరెన్స్ చేయలేము.
పరిష్కారం 1: డిఫరెన్సింగ్ లేకుండా
ఇక్కడ, మేము డిఫరెన్సింగ్ లేకుండా నేరుగా పూర్ణాంక విలువను పొందుతాము. కొన్ని ఫంక్షన్ నిర్వచనాలు ఉన్నందున మేము 'iostream' హెడర్ ఫైల్‌ను దిగుమతి చేస్తాము. అప్పుడు, మేము 'ఉపయోగించు' కీవర్డ్‌తో పాటుగా 'namespace std'ని టైప్ చేసి, ఆపై ఇక్కడ 'main()' పద్ధతిని కాల్ చేస్తాము. ఇప్పుడు, మేము “99” విలువతో “int” డేటా రకం యొక్క “my_num” వేరియబుల్‌ని ప్రారంభిస్తాము.
అప్పుడు, మేము 'my_value' పేరుతో మరొక వేరియబుల్‌ని ప్రారంభించాము మరియు పూర్ణాంకం సంఖ్యను కలిగి ఉన్న 'my_num' వేరియబుల్‌తో దాన్ని కేటాయిస్తాము. దీని తర్వాత, “కౌట్”లో “my_value”ని ఉంచడం ద్వారా మేము ఈ పూర్ణాంకం విలువను డిఫరెన్స్ చేయకుండా నేరుగా పొందుతాము. ఇది పూర్ణాంక విలువను పొందుతుంది మరియు ప్రదర్శిస్తుంది.
కోడ్ 1:
#includeనేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
int my_num = 99 ;
int my_value = my_num;
కోట్ << 'పూర్ణాంకాన్ని తగ్గించకుండా మనం పొందే విలువ: ' << నా_విలువ << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
పూర్ణాంక విలువ ఇక్కడ రెండర్ చేయబడింది, ఇది మన C++ కోడ్‌లో డిఫరెన్స్ చేయకుండానే పొందుతుంది. మేము ఈ పూర్ణాంకం విలువను నేరుగా యాక్సెస్ చేస్తాము మరియు దానిని ప్రదర్శిస్తాము.
పరిష్కారం 2: పాయింటర్‌ను డిఫరెన్స్ చేయడం ద్వారా
“iostream” హెడర్ ఫైల్ నిర్దిష్ట ఫంక్షన్ నిర్వచనాలను కలిగి ఉంటుంది; మేము వాటిని దిగుమతి చేసుకున్నాము. తర్వాత, “namespace std” మరియు “using” కీవర్డ్‌ని టైప్ చేసిన తర్వాత మేము ఇక్కడ “main()” ఫంక్షన్‌ని అమలు చేస్తాము. “int” డేటా రకం యొక్క “my_num” వేరియబుల్ ఇప్పుడు “99” విలువతో ప్రారంభించబడింది.
దీని తర్వాత, మేము “my_ptr” పాయింటర్‌ను ప్రారంభించాము మరియు ఈ పాయింటర్‌కు “my_num” వేరియబుల్ చిరునామాను కేటాయిస్తాము. దీని కింద, మేము పాయింటర్‌ను డీరిఫరెన్స్ చేస్తాము మరియు “*my_ptr”తో “my_value”ని ప్రారంభించినప్పుడు దీని ద్వారా మనకు లభించే విలువను “my_value” వేరియబుల్‌కు కేటాయిస్తాము. ఇప్పుడు, పాయింటర్‌ని డిఫరెన్స్ చేయడం ద్వారా మనకు లభించే పూర్ణాంక విలువను ప్రదర్శించడానికి “my_value” వేరియబుల్‌ను పాస్ చేసే “cout”ని ఉంచుతాము.
కోడ్ 2:
#includeనేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
int my_num = 99 ;
int * my_ptr = & నా_సంఖ్య;
int my_value = * నా_ptr;
కోట్ << 'పాయింటర్‌ను డిఫెరెన్సింగ్ చేయడంతో మనకు లభించే Int విలువ: ' << నా_విలువ << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
మన కోడ్‌లోని పాయింటర్‌ను డిఫెరెన్స్ చేసిన తర్వాత మనకు లభించే పూర్ణాంక విలువ ఇప్పుడు ఇక్కడ ప్రదర్శించబడుతుంది. కాబట్టి, C++లో dereferencingని వర్తింపజేయడానికి ఇది సరైన మార్గం.
ఉదాహరణ 2: Dereferencing Int
ఈ కోడ్‌లో C++లోని “int”ని డీరిఫరెన్స్ చేయడానికి ప్రయత్నిద్దాం. “iostream”లో నిర్వచించబడిన ఫంక్షన్‌లను ఉపయోగించడానికి, మేము కేవలం “iostream” హెడర్ ఫైల్‌ను చేర్చాలి. ఇక్కడే మనం “namespace std”ని ఉపయోగిస్తాము మరియు “main()” ఫంక్షన్‌ని పిలుస్తాము. తరువాత, మేము “a” వేరియబుల్‌ని సృష్టించి, దానికి “75” విలువతో పాటు “int” డేటా రకాన్ని ఇస్తాము.
దీని కింద, మేము 'newPointer' పేరుతో ఒక పాయింటర్‌ని సృష్టిస్తాము మరియు '&' సహాయంతో ఈ పాయింటర్‌కి 'a' వేరియబుల్ చిరునామాను కేటాయిస్తాము. అప్పుడు, మేము '*a'తో దిగువన ఉన్న 'num' వేరియబుల్‌ని ప్రారంభిస్తాము, ఇది 'int' డేటా రకానికి చెందిన 'a' వేరియబుల్‌ని తగ్గించడానికి ప్రయత్నిస్తున్నామని సూచిస్తుంది. మేము “పూర్ణాంకము”ను డీరిఫరెన్స్ చేయలేము కాబట్టి, కంపైలేషన్ సమయంలో ఈ లైన్‌లో ఇప్పుడు లోపం ఏర్పడింది. దీని తర్వాత, మేము 'num' వేరియబుల్‌ని జోడించే 'cout'ని కూడా ఉపయోగిస్తాము.
కోడ్ 2:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
int a = 75 ;
int * newPointer = & a;
పూర్ణాంక సంఖ్య = * a;
కోట్ << 'పూర్ణాంకాన్ని తగ్గించే విలువ:' << ఒకదానిపై << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, విలువ ఏదీ చూపబడలేదని మనం చూడవచ్చు మరియు “యూనరీ యొక్క చెల్లని రకం పరామితి”*” అని పేర్కొంటూ ఒక దోష సందేశం కనిపిస్తుంది. ఇది C++లో “int”ని విడదీయరాదని సూచిస్తుంది.
పరిష్కారం 1: డిఫరెన్సింగ్ లేకుండా
పూర్ణాంక విలువను తక్షణమే పొందేందుకు మేము నిష్క్రమించాల్సిన అవసరం లేదు. “iostream” హెడర్ ఫైల్ నిర్దిష్ట ఫంక్షన్ నిర్వచనాలను కలిగి ఉన్నందున మేము దానిని దిగుమతి చేస్తాము. “ఉపయోగించడం” మరియు “నేమ్‌స్పేస్ std” కీవర్డ్‌లు ఇన్‌పుట్ చేయబడిన తర్వాత “main()” ఫంక్షన్ ప్రారంభించబడుతుంది. “int” డేటా రకం యొక్క “a” వేరియబుల్ ఇప్పుడు “75” విలువతో ప్రారంభించబడింది. ఆ తర్వాత, ఈ పూర్ణాంక విలువను డిఫరెన్స్ చేయకుండా వెంటనే పొందేందుకు మేము 'a'ని 'cout'లోకి చొప్పించాము. ఇది పూర్ణాంక విలువను తిరిగి పొందుతుంది మరియు దానిని ఇక్కడ చూపుతుంది.
కోడ్ 1:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
int a = 75 ;
కోట్ << 'డిఫరెన్స్ లేకుండా మనకు లభించే విలువ:' << a << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
డిఫరెన్సింగ్ లేకుండా మా C++ కోడ్ నుండి పొందిన పూర్ణాంక విలువ ఇక్కడ ప్రదర్శించబడింది. ఈ పూర్ణాంకం విలువ వెంటనే అందుబాటులో ఉంటుంది మరియు ఇక్కడ చూపబడుతుంది.
పరిష్కారం 2:
మేము కొన్ని ఫంక్షన్ నిర్వచనాలను కలిగి ఉన్న 'iostream' హెడర్ ఫైల్‌ను దిగుమతి చేస్తాము. ఇక్కడ, మేము 'main()' ఫంక్షన్‌ని అమలు చేయడానికి ముందు 'namespace std' మరియు 'using' కీవర్డ్‌ని టైప్ చేస్తాము. “75” విలువ “a” వేరియబుల్‌కు కేటాయించబడింది.
తరువాత, మేము 'mypointer' అనే పాయింటర్‌ను ప్రకటించాము మరియు దానికి 'a' వేరియబుల్ చిరునామాతో దాన్ని ప్రారంభించాము. దీని కింద, మేము పాయింటర్‌ను డీరిఫరెన్స్ చేస్తాము మరియు “*మైపాయింటర్”తో “ఫలితాన్ని” ప్రారంభించినప్పుడు దీని నుండి మనకు లభించే విలువను “ఫలితం” వేరియబుల్‌కు కేటాయిస్తాము. పాయింటర్‌ను డిఫెరెన్స్ చేసిన తర్వాత, మేము “కౌట్” ఆదేశాన్ని ఉంచుతాము మరియు పూర్ణాంక విలువను చూపించడానికి “ఫలితం” వేరియబుల్‌ను పాస్ చేస్తాము.
కోడ్ 2:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
int a = 75 ;
int * mypointer = & a;
int result = * మైపాయింటర్;
కోట్ << 'పాయింటర్‌ని డిఫరెన్స్ చేయడం ద్వారా మనకు లభించే విలువ:' << ఫలితం << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
C++లో dereferencingని వర్తింపజేయడానికి ఇది సరైన సాంకేతికత. ఇది “పూర్ణాంకాన్ని” తొలగించే బదులు పాయింటర్‌ను డీఫెరెన్స్ చేసిన తర్వాత మనం పొందిన పూర్ణాంక విలువను రెండర్ చేస్తుంది.
ముగింపు
మేము C++లో “int”ని డిఫెరెన్స్ చేయడం ద్వారా విలువను పొందడానికి ప్రయత్నించినప్పుడు, “int”ని కలిగి ఉన్న unary “*” యొక్క చెల్లని రకం పరామితి దోషం ఏర్పడుతుంది అంటే “C++లో int డిఫరెన్స్ చేయడం సాధ్యం కాదు” అని అన్వేషించాము. మేము ఈ లోపానికి పరిష్కారాన్ని కూడా వివరించాము. మేము ఈ గైడ్‌లో ఎర్రర్‌లు సంభవించిన కోడ్‌ని మరియు ఆ లోపం యొక్క పరిష్కారాన్ని అందించిన కోడ్‌లను ఉపయోగించాము.