విషయము

• పోలిక చార్ట్:
• కీలకపదాల నిర్వచనం
• ఉదాహరణ:
• ఐడెంటిఫైయర్ యొక్క నిర్వచనం
• ఉదాహరణ:
• ఐడెంటిఫైయర్‌ను నిర్మించడానికి తప్పనిసరిగా అనుసరించాల్సిన నియమాలు
• కీవర్డ్ మరియు ఐడెంటిఫైయర్ మధ్య కీ తేడాలు
• ముగింపు:

ప్రతి భాషకు కీలకపదాలు మరియు ఐడెంటిఫైయర్‌లు ఉన్నాయి, వీటిని దాని కంపైలర్ ద్వారా మాత్రమే అర్థం చేసుకోవచ్చు. కీవర్డ్లు ముందే నిర్వచించిన రిజర్వ్డ్ పదాలు, ఇవి ప్రత్యేక అర్ధాన్ని కలిగి ఉంటాయి. ప్రతి కీవర్డ్ “రకం” డిక్లేర్డ్ డేటాను నిర్వచిస్తుంది. కీలకపదాలను ఐడెంటిఫైయర్‌లుగా ఉపయోగించకూడదు. ఒక ఐడెంటిఫైయర్ ప్రోగ్రామ్‌లోని ఒక నిర్దిష్ట వేరియబుల్, ఫంక్షన్ లేదా క్లాస్ లేబుల్‌కు ఇచ్చిన ప్రత్యేక పేరు. వేరియబుల్ సృష్టించడానికి, ఒక కీవర్డ్ మరియు ఐడెంటిఫైయర్ రెండూ కలిసి ఉంటాయి.

అవసరమైతే ఐడెంటిఫైయర్‌లను మార్చవచ్చు, ఇది కీలకపదాల విషయంలో కాదు, అవి పరిష్కరించబడ్డాయి, మన అవసరానికి అనుగుణంగా దాన్ని మార్చలేము. ఈ కంటెంట్ కీవర్డ్ మరియు ఐడెంటిఫైయర్ మధ్య వ్యత్యాసాన్ని మరింత వివరిస్తుంది.

1. పోలిక చార్ట్
2. నిర్వచనం
3. కీ తేడాలు
4. ముగింపు

పోలిక చార్ట్:

పోలిక కోసం ఆధారం	కీవర్డ్	గుర్తించేది
ప్రాథమిక	కీవర్డ్లు ఒక భాష యొక్క రిజర్వు చేయబడిన పదాలు.	ఐడెంటిఫైయర్స్ అంటే వేరియబుల్, ఫంక్షన్ మరియు లేబుల్స్ యొక్క వినియోగదారు నిర్వచించిన పేర్లు.
వా డు	ఎంటిటీ రకం / రకాన్ని పేర్కొనండి.	ఒక నిర్దిష్ట సంస్థ పేరును గుర్తించండి.
ఫార్మాట్	అక్షరాలను మాత్రమే పరిగణించండి.	అక్షరాలు, అండర్ స్కోర్, అంకెలను పరిగణించండి.
కేసు	చిన్న అక్షరాలను మాత్రమే ఉపయోగించండి.	దిగువ మరియు ఎగువ కేసులు, రెండూ అనుమతించబడతాయి.
చిహ్నం	ప్రత్యేక చిహ్నం లేదు, విరామచిహ్నాలు ఉపయోగించబడవు.	అండర్ స్కోర్ మినహా పంక్చుయేషన్ లేదా ప్రత్యేక చిహ్నం ఉపయోగించబడదు.
వర్గీకరణ	కీలకపదాలు మరింత వర్గీకరించబడలేదు.	ఐడెంటిఫైయర్ బాహ్య పేరు మరియు అంతర్గత పేరుగా వర్గీకరించబడింది.
ప్రారంభ లేఖ	ఇది ఎల్లప్పుడూ చిన్న అక్షరంతో మొదలవుతుంది.	మొదటి అక్షరం పెద్ద అక్షరం, చిన్న అక్షరం లేదా అండర్ స్కోర్ కావచ్చు.
ఉదాహరణ	int, char, if, while, do, class etc.	పరీక్ష, కౌంట్ 1, హై_స్పీడ్ మొదలైనవి.

కీలకపదాల నిర్వచనం

C ++ చేత రిజర్వు చేయబడిన పదాలను “కీవర్డ్లు". ఐడెంటిఫైయర్ పేరు పెట్టడానికి మరియు ప్రోగ్రామ్ యొక్క ఇతర ఎంటిటీకి పేరు పెట్టడానికి ఈ కీలకపదాలు ఉపయోగించబడవు. ప్రతి కీవర్డ్‌కు ప్రత్యేకమైన అర్ధం ఉంది మరియు కంపైలర్ ఒక నిర్దిష్ట చర్యను చేయడానికి ఉపయోగిస్తారు. ఉదాహరణకు, పూర్ణాంక రకం యొక్క ఐడెంటిఫైయర్‌ను సృష్టించడానికి ‘పూర్ణాంకానికి’ ఉపయోగించబడుతుంది, ఫ్లోట్ రకం యొక్క ఐడెంటిఫైయర్‌ను సృష్టించడానికి ‘ఫ్లోట్’ ఉపయోగించబడుతుంది.

ఉదాహరణ:

కీలకపదాల యొక్క స్పష్టమైన చిత్రాన్ని పొందడానికి, నిజ జీవిత ఉదాహరణను అవలోకనం చేద్దాం. మాకు ‘కంప్లీట్ రిఫరెన్స్’ అనే ‘పుస్తకం’ ఉంది. ఇక్కడ ‘బుక్’ అనే పదం కీవర్డ్, మరియు “కంప్లీట్_రెఫరెన్స్” అనే పేరు ‘బుక్’ అనే కీవర్డ్‌కు ఐడెంటిఫైయర్. ఇప్పుడు, కీవర్డ్ నిర్దేశిస్తుంది, “కంప్లీట్_ రిఫరెన్స్” అంటే ఏమిటి, సమాధానం, ఇది “బుక్”.

ఇప్పుడు, మేము ‘ఫ్లోట్ జీతం’ వ్రాస్తే ప్రోగ్రామ్ యొక్క ఉదాహరణ తీసుకుందాం. ఇక్కడ, ‘కీవర్డ్’ ‘ఫ్లోట్’ మరియు ‘జీతం’ ఒక ‘ఐడెంటిఫైయర్’. ఇప్పుడు, మీరు ‘జీతం’ అంటే ఏమిటి అని అడిగితే, సమాధానం, ఇది ‘వేరియబుల్’ అని పేర్కొంటుంది, ఇది ప్రకృతిలో ‘ఫ్లోట్’ మరియు ‘ఫ్లోట్ విలువలు’ అంగీకరిస్తుంది.

ఐడెంటిఫైయర్ యొక్క నిర్వచనం

ప్రోగ్రామ్‌లోని ఎంటిటీకి మీరు అందించే పేరును ప్రత్యేకంగా గుర్తించగలిగేలా పిలుస్తారు “ఐడెంటిఫైయర్". వేరియబుల్స్, ఫంక్షన్లు, క్లాస్ యొక్క లేబుల్స్ మరియు ఇతర వినియోగదారు నిర్వచించిన ఎంటిటీల పేర్లు ‘ఐడెంటిఫైయర్స్’. ఐడెంటిఫైయర్‌ను ఎప్పుడూ ‘కీవర్డ్’గా ఉపయోగించలేరు.

ఉదాహరణ:

దీన్ని మరింత బాగా అర్థం చేసుకోవడానికి, పైన పేర్కొన్న ‘కీవర్డ్’ ఉదాహరణను వివరించండి. “పుస్తకం” ఒక ‘కీవర్డ్’ మరియు “కంప్లీట్_ రిఫరెన్స్” ఒక ఐడెంటిఫైయర్. ఇప్పుడు, మనకు ‘బుక్ ఆఫ్ కంప్లీట్ రిఫరెన్స్’ కావాలంటే. మేము దుకాణదారుని అడిగినప్పుడు, మనకు “పుస్తకం” కావాలని అడిగినప్పుడు, అతను / ఆమె పుస్తకాల పేరును పేర్కొనకపోతే, ఏ ‘పుస్తకం’ గుర్తించదు, అనగా “కంప్లీట్_ రిఫరెన్స్”.

ఇప్పుడు, ఒక ప్రోగ్రామ్ యొక్క పై ఉదాహరణను తీసుకోండి, మనకు తెలుసు ‘ఫ్లోట్’ ఒక ‘కీవర్డ్’, మరియు ‘జీతం’ ఒక ‘ఐడెంటిఫైయర్’. ఇప్పుడు, మీరు వేరియబుల్ ‘జీతం’ విలువను కోరుకుంటే, మీరు వేరియబుల్ పేరును ‘జీతం’ అని స్పష్టంగా పిలవాలి, ఇక్కడ, ‘ఫ్లోట్’ అని పిలవడం పనిచేయదు.

కాబట్టి ఐడెంటిఫైయర్ అనేది ఒక ప్రోగ్రామ్‌లో మన సృష్టించిన ఎంటిటీని పిలవగల పేరు.

ఐడెంటిఫైయర్‌ను నిర్మించడానికి తప్పనిసరిగా అనుసరించాల్సిన నియమాలు

• ఐడెంటిఫైయర్ యొక్క మొదటి అక్షరం తప్పనిసరిగా అక్షరంగా ఉండాలి. (‘_’ అండర్ స్కోర్‌ను మొదటి అక్షరంగా కూడా ఉపయోగించవచ్చు)
• ఇది అక్షరాలు, అంకెలు మరియు అండర్ స్కోర్ సమితి కావచ్చు.
• పెద్ద అక్షరాలు మరియు చిన్న అక్షరాలు భిన్నంగా పరిగణించబడతాయి.
• పాత్రలన్నీ ముఖ్యమైనవి.
• ఐడెంటిఫైయర్స్ లేదా వేరియబుల్స్ పేరుగా రిజర్వు చేసిన పదాలను ఉపయోగించడం నిషేధించబడింది.
• తెల్లని ఖాళీలు అనుమతించబడవు.
• ఒక ఐడెంటిఫైయర్ గరిష్టంగా 1024 అక్షరాలను కలిగి ఉంటుంది, ఎందుకంటే ANSI ప్రమాణానికి C ++ కంపైలర్లు కనీసం ఈ అక్షరాల సంఖ్యను అందించాలి.

కీవర్డ్ మరియు ఐడెంటిఫైయర్ మధ్య కీ తేడాలు

1. ఎంటిటీ యొక్క రకాన్ని / రకాన్ని గుర్తించడానికి కీలకపదాలు ఉపయోగించబడతాయి, అయితే ఆ ఎంటిటీకి ప్రత్యేకంగా పేరు పెట్టడానికి ఐడెంటిఫైయర్ ఉపయోగించబడుతుంది. ఉదాహరణకు, మనం ‘పూర్ణాంక సంఖ్య’ అని వ్రాస్తే, ఇక్కడ ‘పూర్ణాంకం’ ఒక కీవర్డ్, మరియు ‘సంఖ్య’ ఒక ఐడెంటిఫైయర్, అనగా, ఈ ప్రకటన స్పష్టంగా మేము ఒక సంఖ్య ‘సంఖ్య’ ను నిర్వచించాము, ఇది రకం int (పూర్ణాంకం).
2. కీవర్డ్లు విభిన్నమైనవి; అవి మరింత వర్గీకరించబడవు. దీనికి విరుద్ధంగా, ఐడెంటిఫైయర్‌లు బాహ్య లింక్ ప్రాసెస్‌లో పాల్గొంటే, అనగా ఫైల్‌ల మధ్య భాగస్వామ్యం చేయబడిన ఫంక్షన్ పేర్లు మరియు గ్లోబల్ వేరియబుల్ ఉంటే, దానిని ‘అంటారు.బాహ్య పేర్లు’, అవి బాహ్య లింక్ ప్రక్రియలో ఉపయోగించబడవు మరియు స్థానిక వేరియబుల్ పేరును కలిగి ఉంటాయి, అప్పుడు దీనిని‘అంతర్గత పేర్లు’.
3. ఐడెంటిఫైయర్ ఎప్పుడూ కీలకపదాలతో సమానంగా ఉండకూడదు మరియు సి ++ లైబ్రరీలో ఉన్న ఫంక్షన్ల పేరు.
4. సి ++ లైబ్రరీలో నిర్వచించిన కీలకపదాలు ఏ గుర్తును కలిగి ఉండవు. దీనికి విరుద్ధంగా, మీరు ఏదైనా ఐడెంటిఫైయర్ను ప్రకటించినప్పుడు మీరు అండర్ స్కోర్ మాత్రమే ఉపయోగించవచ్చు కాని మరే ఇతర చిహ్నాన్ని ఉపయోగించలేరు.
5. ఒక కీవర్డ్ ఎల్లప్పుడూ చిన్న కేసుతో మొదలవుతుంది. దీనికి విరుద్ధంగా, ఒక ఐడెంటిఫైయర్ అప్పర్ కేస్ లేదా లోయర్ కేస్‌తో ప్రారంభించవచ్చు

ముగింపు:

కీవర్డ్లు మరియు ఐడెంటిఫైయర్లు ప్రోగ్రామ్ యొక్క బిల్డింగ్ బ్లాక్స్. రకం / రకాన్ని మరియు ఒక నిర్దిష్ట వేరియబుల్ యొక్క పేరు లేదా తరగతి యొక్క ఫంక్షన్‌ను ప్రత్యేకంగా నిర్వచించడానికి కంపైలర్ చేత వీటిని ప్రత్యేకంగా ఉపయోగిస్తారు.