కింది ప్రోగ్రామ్‌లో గ్లోబల్ స్కోప్‌లో కింది రెండు స్కేలార్ స్టేట్‌మెంట్‌లను పరిగణించండి:
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
intvarId= 5;
తేలుతాయిvarId= 2.3;
intప్రధాన()
{
తిరిగి 0;
}
ఈ ప్రోగ్రామ్‌ను కంపైల్ చేయడానికి చేసిన ప్రయత్నం కంపైలేషన్ లోపానికి దారితీస్తుంది. ఒకే పేరుతో రెండు వేరియబుల్స్ ఉన్నాయి, varId . అవి రెండు వేర్వేరు రకాల రెండు వేర్వేరు వేరియబుల్స్ అయినప్పటికీ, int మరియు తేలుతాయి , కంపైలర్ రెండు డిక్లరేషన్‌లను తిరస్కరిస్తుంది ఎందుకంటే అవి ఒకే పేరుతో ఉంటాయి. కింది ప్రోగ్రామ్ ఈ సమస్యను ఒకే పేరుతో ఉన్న వేరియబుల్స్‌ని రెండు వేర్వేరు సాధారణ పరిధులలో డిక్లేర్ చేయడం ద్వారా పరిష్కరిస్తుంది:
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
నేమ్‌స్పేస్ NA
{
intvarId= 5;
}
నేమ్‌స్పేస్ NB
{
తేలుతాయిvarId= 2.3;
}
intప్రధాన()
{
ఖరీదు<<NA::varId << ' n';
ఖరీదు<<NB::varId << ' n';
తిరిగి 0;
}
అవుట్‌పుట్ క్రింది విధంగా ఉంది:
5
2.3
పై ప్రోగ్రామ్‌లో రెండు నేమ్‌స్పేస్‌లు ఉన్నాయి: NA , ఇది ఒక పూర్ణాంకం యొక్క నిర్వచనాన్ని కలిగి ఉంటుంది మరియు NB , ఇది ఒక ఫ్లోట్ యొక్క నిర్వచనాన్ని కలిగి ఉంది కానీ NA కొరకు పూర్ణాంకం వలె అదే పేరుతో ఉంటుంది. చివరగా, ప్రోగ్రామ్ రన్ అయినప్పుడు, రెండు వేర్వేరు వేరియబుల్స్ కోసం ఒకే పేరు ఉపయోగించబడింది. రెండు వేర్వేరు వేరియబుల్స్ యొక్క ఒకే పేరును యాక్సెస్ చేయడానికి, నేమ్‌స్పేస్ కోసం నిర్దిష్ట పేరు తప్పనిసరిగా ఉపయోగించబడాలి, తర్వాత సాధారణ ఐడెంటిఫైయర్ ఉండాలి. నేమ్‌స్పేస్ పేరు మరియు సాధారణ ఐడెంటిఫైయర్ స్కోప్ రిజల్యూషన్ ఆపరేటర్ ద్వారా వేరు చేయబడతాయి, :: . నేమ్‌స్పేస్‌ల పేరు వస్తువులను వేరు చేస్తుంది.
ఈ వ్యాసం నేమ్‌స్పేస్ యొక్క ప్రాథమిక భావన మరియు C ++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో దాని వినియోగాన్ని వర్తిస్తుంది. ఈ కథనాన్ని అనుసరించడానికి, మీకు C ++ భాషపై ప్రాథమిక పరిజ్ఞానం ఉండాలి. ఈ కథనంలో క్లుప్తంగా వివరించినప్పటికీ, మీకు C ++ స్కోప్ గురించి కూడా అవగాహన ఉండాలి. C ++ స్కోప్ గురించి మరింత తెలుసుకోవడానికి, ఏదైనా linuxhint.com వెబ్ పేజీలోని సెర్చ్ బాక్స్‌లో C ++ లో స్కోప్ (కోట్స్ లేకుండా) మరియు ఎంటర్ నొక్కండి. ఇది ఈ రచయిత వ్రాసిన వ్యాసానికి దారి తీస్తుంది.
వ్యాసం కంటెంట్
- నేమ్‌స్పేస్ అంటే ఏమిటి?
- ది డైరెక్టివ్ ఉపయోగించి
- నెస్టెడ్ నేమ్‌స్పేస్‌లు
- ప్రామాణిక నేమ్‌స్పేస్
- ముగింపు
నేమ్‌స్పేస్ అంటే ఏమిటి?
డిక్లరేటివ్ రీజియన్ అనేది ప్రోగ్రామ్‌లో అతిపెద్ద భాగం, దీనిలో ఎంటిటీ (వేరియబుల్) పేరు చెల్లుబాటు అవుతుంది. ఈ ప్రాంతాన్ని స్కోప్ అంటారు. C ++ లో నేమ్‌స్పేస్ అనేది సాధారణీకరించిన పరిధి, దీని ప్రధాన ఉద్దేశ్యం పేరు వైరుధ్యాలను పరిష్కరించడం. నేమ్‌స్పేస్ ప్రాథమిక డిక్లరేషన్‌లు మరియు/లేదా ఎంటిటీల నిర్వచనాలను కలిగి ఉంటుంది.
గ్లోబల్ నేమ్‌స్పేస్ మరియు దాని సమస్య
గ్లోబల్ నేమ్‌స్పేస్ అనేది గ్లోబల్ స్కోప్. కింది చిన్న కార్యక్రమాన్ని పరిగణించండి:
#చేర్చండినేమ్స్పేస్ std ఉపయోగించి;
intగుర్తింపు= 55;
తేలుతాయిగుర్తింపు= 12.17;
intప్రధాన()
{
తిరిగి 0;
}
పై ప్రోగ్రామ్‌లో, రెండు వేరియబుల్స్ ఉన్నాయి, రెండూ అంటారు గుర్తింపు . ఈ వేరియబుల్స్ ప్రపంచ పరిధిలో ఉన్నాయి; అంటే, అవి గ్లోబల్ నేమ్‌స్పేస్‌లో ఉన్నాయి. ఈ ప్రోగ్రామ్‌ను కంపైల్ చేసే ప్రయత్నం ఎర్రర్ మెసేజ్‌తో విఫలమవుతుంది. గ్లోబల్ స్కోప్ ఒకే పేరుతో ఒకటి కంటే ఎక్కువ వేరియబుల్‌లను అంగీకరించదు, కాబట్టి అనుకూల నేమ్‌స్పేస్ అవసరం ఉంది.
అనుకూల నేమ్‌స్పేస్
నేమ్‌స్పేస్‌కు ఒకే పేరు లేదు. బదులుగా, నేమ్‌స్పేస్ ఇతర పేర్లతో విభేదాలను నివారించడానికి పేర్ల సమితిని కలిగి ఉంది. కోడ్‌లో సంఘర్షణను నివారించడానికి, ప్రతి పేరును నేమ్‌స్పేస్ పేరుతో మరియు ముందు :: . కింది ప్రోగ్రామ్ దీనిని రెండు అనుకూల నేమ్‌స్పేస్‌లను ఉపయోగించి వివరిస్తుంది:
#చేర్చండినేమ్స్పేస్ std ఉపయోగించి;
నేమ్‌స్పేస్ NA
{
intవేరియంట్= 6;
తేలుతాయిflt;
}
నేమ్‌స్పేస్ NB
{
intవేరియంట్= 7;
తేలుతాయిflt;
}
intప్రధాన()
{
ఖరీదు<<NA::వేరియంట్ << ' n';
ఖరీదు<<NB::వేరియంట్ << ' n';
NA::flt = 2.5;
NB::flt = 4.8;
ఖరీదు<<NA::flt << ' n';
ఖరీదు<<NB::flt << ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
67
2.5
4.8
పేర్లు గమనించండి NA :: flt మరియు NB :: flt చివరికి నిర్వచించబడ్డాయి ప్రధాన () ఫంక్షన్ C ++ గ్లోబల్ స్కోప్‌లో అలాంటి నిర్వచనాన్ని అనుమతించదు.
కస్టమ్ నేమ్‌స్పేస్ అనేది గ్లోబల్ నేమ్‌స్పేస్ కోసం ఒక నేమ్‌స్పేస్ అని గమనించండి.
ది డైరెక్టివ్ ఉపయోగించి
నేమ్‌పేస్‌ను టైప్ చేయకుండా ఉండటానికి :: నేమ్‌స్పేస్‌ను ప్రకటించిన తర్వాత కేవలం పేరుకు బదులుగా అన్ని సమయాలలో పేరు పెట్టండి, మీరు దీనిని ఉపయోగించవచ్చు ఉపయోగించి నిర్దేశకం. ఉపయోగించడానికి వాక్యనిర్మాణం ఉపయోగించి ఆదేశం క్రింది విధంగా ఉంది:
నేమ్‌స్పేస్ నేమ్‌స్పేస్_పేరును ఉపయోగించడం;ది ఉపయోగించి ఆదేశం అనేది ప్రీప్రాసెసర్ ఆదేశం కాదు, కనుక ఇది సెమికోలన్‌తో ముగుస్తుంది (;).
కింది ప్రోగ్రామ్ దీని వినియోగాన్ని వివరిస్తుంది ఉపయోగించి ఆదేశం మరియు మరిన్ని:
#చేర్చండినేమ్స్పేస్ std ఉపయోగించి;
నేమ్‌స్పేస్ NB
{
intవేరియంట్= 7;
intఫంక్షన్()
{
తిరిగివేరియంట్;
}
}
intfn()
{
నేమ్‌స్పేస్ NB ని ఉపయోగిస్తోంది;
intmyVar2=ఫంక్షన్();
// NB నుండి ఇతర వస్తువులు మరియు విధులు అనుసరిస్తాయి.
తిరిగిmyVar2;
}
intmyVar3=NB::ఫంక్షన్();
intప్రధాన()
{
ఖరీదు<<fn() << '' <<myVar3<< ' n';
తిరిగి 0;
}
ఈ కార్యక్రమం యొక్క అవుట్‌పుట్ 7 7 . పదం నేమ్‌స్పేస్ NB ఉపయోగించి; ప్రారంభంలో ఉంచబడింది fn () నిర్వచనం. ది func () NB నేమ్‌స్పేస్ నుండి ముందు కంటే ముందుగానే పిలవబడుతుంది NB :: .
గ్లోబల్ స్కోప్‌లో ప్రకటించిన వేరియబుల్ (గ్లోబల్ నేమ్‌స్పేస్) డిక్లరేషన్ పాయింట్ నుండి ఫైల్ చివరి వరకు కనిపిస్తుంది. ఇది గూడు వంటి నేస్ట్ నేమ్‌స్పేస్‌లలో (నెస్టెడ్ స్కోప్స్) కూడా కనిపిస్తుంది fn () పైన ఫంక్షన్ స్కోప్. ది ఉపయోగించి నిర్దేశకం దాని నేమ్‌స్పేస్‌ని అది ఉంచిన స్థానం నుండి అది ఉంచిన స్కోప్ చివరి వరకు చేరుతుంది.
పేరు func () NB నేమ్‌స్పేస్ నుండి క్రింద చూడలేము fn () నిర్వచనం ఎందుకంటే నేమ్‌స్పేస్ NB ఉపయోగించి; ఫంక్షన్ పరిధిలో (బ్లాక్) ఉంచబడింది. ఈ పరిస్థితిలో, ఉపయోగించడానికి func () NB నేమ్‌స్పేస్ బ్లాక్ (స్కోప్) వెలుపల, దాని ముందు ఉండాలి NB :: , కింది ప్రకటనలో వలె:
intmyVar3=NB::ఫంక్షన్();ది ఉపయోగించి నిర్దేశకం దాని నేమ్‌స్పేస్‌ని బయటి గూడు నేమ్‌స్పేస్‌తో కలుపుతుంది, అది ఉంచిన స్థానం నుండి బయటి గూడు నేమ్‌స్పేస్ చివరి వరకు ఉంటుంది. కింది ప్రోగ్రామ్‌లో, NA నేమ్‌స్పేస్ గ్లోబల్ నేమ్‌స్పేస్‌తో జతచేయబడింది. రెండు నేమ్‌స్పేస్‌లు అప్పుడు లోకి విస్తరించాయి fn () ఫంక్షన్ డెఫినిషన్ నేమ్‌స్పేస్, దీనిలో అవి NB నేమ్‌స్పేస్‌తో జతచేయబడతాయి. NB నేమ్‌స్పేస్ చివరలో ముగుస్తుంది fn () ఫంక్షన్ నిర్వచనం మరియు మునుపటి రెండు నేమ్‌స్పేస్‌లు ఫైల్ చివరి వరకు కొనసాగుతాయి (కోడ్ ద్వారా చదవండి).
#చేర్చండినేమ్స్పేస్ std ఉపయోగించి;
నేమ్‌స్పేస్ NA
{
intవేరియంట్= 6;
intఫంక్షన్()
{
తిరిగివేరియంట్;
}
}
నేమ్‌స్పేస్ NB
{
intవేరియంట్= 7;
intఫంక్షన్()
{
తిరిగివేరియంట్;
}
}
నేమ్‌స్పేస్ NA ఉపయోగించి;
intmyVar0=వేరియంట్;
// మరియు NB నుండి ఇతర వస్తువులు మరియు విధులు అనుసరిస్తాయి.
intfn()
{
intmyVar1=వేరియంట్;
నేమ్‌స్పేస్ NB ని ఉపయోగిస్తోంది;
intmyVar2=NB::ఫంక్షన్();
// NB నుండి ఇతర వస్తువులు మరియు విధులు ఈ పరిధి ముగిసే వరకు అనుసరిస్తాయి.
తిరిగిmyVar1+myVar2;
}
// :: మరియు NB నుండి వస్తువులు మరియు విధులు మాత్రమే అనుసరించబడతాయి.
intmyVar3=NB::ఫంక్షన్();
intప్రధాన()
{
ఖరీదు<<myVar0<< '' <<fn() << '' <<myVar3<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్ ఉంది 6, 13, 7 .
గమనిక: గ్లోబల్ నేమ్‌స్పేస్ దీనితో సూచించబడింది :: , అంటే స్కోప్ రిజల్యూషన్ ఆపరేటర్ ముందు ఏదీ లేదు.
ప్రకటన క్రింద, ది నేమ్‌స్పేస్ NA ఉపయోగించి; గ్లోబల్ మరియు NA నేమ్‌స్పేస్‌ల నుండి వేరియబుల్స్ వాటి సోర్స్ నేమ్‌స్పేస్ సూచన లేకుండా ఉపయోగించవచ్చు. తదుపరి ప్రకటన దీనిని ఉపయోగిస్తుంది వేరియంట్ NA నేమ్‌స్పేస్. గ్లోబల్ మరియు NA కంబైన్డ్ నేమ్‌స్పేస్ ప్రాంతం విస్తరించి ఉంది fn () ఫంక్షన్ నేమ్‌స్పేస్. కాబట్టి, ది వేరియంట్ లోని మొదటి స్టేట్మెంట్ fn () ఫంక్షన్ స్కోప్, NA నేమ్‌స్పేస్‌లో ఉంది.
గ్లోబల్ మరియు NA నేమ్‌స్పేస్‌ల కోసం ప్రాంతం అంతటా విస్తరించి ఉంది fn () పరిధి, తర్వాత int myVar2 = NB :: func (); , NB నేమ్‌స్పేస్ నుండి ఏదైనా పేరు మాత్రమే దీనిలో ఉపయోగించబడుతుంది fn () దాని ముందు లేకుండా స్కోప్ NB :: , ఇది NA మరియు గ్లోబల్ నేమ్‌స్పేస్‌లలో (బ్లాక్స్) జరగకపోతే మాత్రమే. లేకపోతే, దానికి ముందు ఉండాలి NB :: . NA మరియు గ్లోబల్ కోసం కలిపి నేమ్‌స్పేస్‌ల ప్రాంతం దిగువన కొనసాగుతుంది fn () నిర్వచనం మరియు లోకి ప్రధాన () ఫైల్ చివరి వరకు ఫంక్షన్.
NB నేమ్‌స్పేస్ పొడిగింపు దీని నుండి ప్రారంభమవుతుంది int myVar2 = NB :: func (); లో fn () బ్లాక్ మరియు చివరలో ముగుస్తుంది fn () నిర్వచన బ్లాక్.
గమనిక: ప్రాంతాలు చేరిన నేమ్‌స్పేస్‌లు వాటి విభిన్న నేమ్‌స్పేస్ బ్లాక్‌లలో ఒకే వేరియబుల్ పేరును కలిగి ఉండకూడదు, ఎందుకంటే ఇది ఇప్పటికీ సంఘర్షణకు కారణమవుతుంది.
నేమ్‌స్పేస్ ప్రాంతాలు
నేమ్‌స్పేస్ ఒక పరిధి. గ్లోబల్ నేమ్‌స్పేస్ (గ్లోబల్ స్కోప్) కాకుండా, ఏదైనా నేమ్‌స్పేస్‌ను బ్లాక్‌లో ప్రకటించాలి. నేమ్‌స్పేస్ యొక్క పంపిణీ చేయబడిన ప్రాంతాలలో మొదటి భాగం ఆ బ్లాక్. ఉపయోగించే ఆదేశంతో, నేమ్‌స్పేస్ ఇతర స్కోప్‌లలో ప్రాంతాలుగా విస్తరించబడుతుంది.
నేమ్‌స్పేస్ బాడీలో ప్రకటించబడిన ఎంటిటీలు నేమ్‌స్పేస్‌లో సభ్యులుగా పేర్కొనబడతాయి మరియు నేమ్‌స్పేస్ యొక్క డిక్లరేటివ్ రీజియన్‌లోకి ఈ డిక్లరేషన్‌ల ద్వారా ప్రవేశపెట్టిన పేర్లు నేమ్‌స్పేస్ సభ్యుల పేర్లుగా చెప్పబడుతున్నాయి.
నెస్టెడ్ నేమ్‌స్పేస్‌లు
కింది ప్రోగ్రామ్ సమూహ నేమ్‌స్పేస్‌లను చూపుతుంది:
#చేర్చండినేమ్స్పేస్ std ఉపయోగించి;
నేమ్‌స్పేస్ A
{
inti= 1;
నేమ్‌స్పేస్ B
{
inti= 2;
నేమ్‌స్పేస్ సి
{
inti= 3;
}
}
}
intప్రధాన()
{
ఖరీదు<<కు::i << '' <<కు::బి::i << '' <<కు::బి::సి::i << ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
1 2 3స్కోప్ రిజల్యూషన్ ఆపరేటర్‌ను ఉపయోగించి మూడు విలువలు యాక్సెస్ చేయబడ్డాయని గమనించండి.
ప్రామాణిక నేమ్‌స్పేస్
C ++ లో స్టాండర్డ్ లైబ్రరీ అనే లైబ్రరీ ఉంది. ఈ లైబ్రరీలోని వస్తువులు, విధులు మరియు ఇతర సంస్థల పేర్లు ప్రామాణిక నేమ్‌స్పేస్ అనే నేమ్‌స్పేస్ నుండి వ్రాయబడ్డాయి గంటలు . ప్రామాణిక గ్రంథాలయంలో ఉప గ్రంథాలయాలు ఉన్నాయి మరియు ఈ ఉప గ్రంథాలయాలలో ఒకటి iostream . ది iostream లైబ్రరీలో ఆబ్జెక్ట్ ఉంది ఖరీదు , ఇది కన్సోల్ (టెర్మినల్) కు ఫలితాలను పంపడానికి ఉపయోగించబడుతుంది.
పేరు ఖరీదు లో ఉండాలి గంటలు నేమ్‌స్పేస్. ఉపయోగించడానికి iostream దానితో గంటలు నేమ్‌స్పేస్, ప్రోగ్రామ్ క్రింది విధంగా ఉండాలి:
#చేర్చండినేమ్స్పేస్ std ఉపయోగించి;
యొక్క ఉపయోగాన్ని గమనించండి ఉపయోగించి నిర్దేశకం మరియు గంటలు . పదం #చేర్చండి అనేది ప్రీప్రాసెసర్ ఆదేశం మరియు సెమికోలన్‌తో ముగియదు. ఇది దాని డైరెక్టివ్ స్థానంలో iostream ఫైల్‌ను కలిగి ఉంటుంది.
ముగింపు
నేమ్‌స్పేస్ ఒక పరిధి. నేమ్‌స్పేస్ వివరణ (నిర్వచనం) ప్రాథమిక ప్రకటనలు మరియు/లేదా C ++ వస్తువులు, విధులు మరియు ఇతర సంస్థల నిర్వచనాలను కలిగి ఉంటుంది. నేమ్‌స్పేస్ నిర్వచనం వెలుపల, సింటాక్స్‌తో పేరును యాక్సెస్ చేయవచ్చు, namespaceName :: పేరు . గ్లోబల్ నేమ్‌స్పేస్ (గ్లోబల్ స్కోప్) కాకుండా, ఏదైనా నేమ్‌స్పేస్‌ను బ్లాక్‌లో ప్రకటించాలి. నేమ్‌స్పేస్ యొక్క పంపిణీ చేయబడిన ప్రాంతాలలో మొదటి భాగం ఆ బ్లాక్. తో ఉపయోగించి నిర్దేశకం, నేమ్‌స్పేస్‌ను ఇతర స్కోప్‌లలో ప్రాంతాలుగా విస్తరించవచ్చు. ప్రాంతాలు చేరిన నేమ్‌స్పేస్‌లు వాటి విభిన్న నేమ్‌స్పేస్ బ్లాక్‌లలో ఒకే వేరియబుల్ పేరును కలిగి ఉండకూడదు, ఎందుకంటే ఇది ఇప్పటికీ పేరు వివాదానికి కారణమవుతుంది.
క్రిస్