Namespace (Lecture 35)-DOhMUTHrdJI

 ప్రోగ్రామింగ్ ఇన్ C ++ మాడ్యూల్ 20 కు స్వాగతం.
 ఈ మాడ్యూల్ లో మనము నేమ్ స్పేస్ ల గురించి మాట్లాడతాము.
 నేమ్ స్పేసులు అనేవి లెక్సికల్ స్కోపింగ్ యొక్క భావన, వీటిలో మీకు ఇప్పటికే C ++ లో మీకు తెలిసిన అనేక ఎంపికలు ఉన్నాయి.
 కానీ, మనము స్కాపింగ్ యొక్క ఈ అదనపు భావనను మరియు ఇది కోడ్ స్ట్రక్చర్ కు ఎలా సహాయం చేస్తుంది అని మీకు బహిర్గతం చేస్తాము.
 ఇది సరిహద్దు, మరియు మేము ప్రతి స్లయిడ్ యొక్క ఎడమ వైపున ముందుకు వెళ్తాము.
 కాబట్టి, మొదటి నేమ్ స్పేస్ నామమును పరిచయం చేద్దాం.
 ఒక నేమ్ స్పేస్, నేను చెప్పినట్లుగా ఒక declarative region; ఇది ఒక స్కోప్ ని కలిగి ఉంది.
 సో, మేము ఇప్పటికే బ్లాక్ వంటి స్కోప్ తెలుసు, మేము ప్రతి ఫంక్షన్ ఒక స్కోప్ ని కలిగి తెలుసు; క్లాస్ కి ఒక స్కోప్ ఉంది, క్లాస్ కొన్ని, క్లాస్ నేమ్ స్కోప్ ని కలిగి ఉంది.
 కాబట్టి, నేమ్స్పేస్ అంటే ఖచ్చితంగా ఉంది.
 ఇక్కడ మనము ఒక declarative region, అది విభిన్న ఐడెంటిఫైర్లను, విభిన్న చిహ్నాల కలిగి ఉంటుంది.
 మనకు టైప్స్, ఫంక్షన్స్, వేరియబుల్స్, క్లాస్ మరియు ఇతర నేమ్ స్పేస్లు ఉన్నాయి.
 నేను చెప్పిన ప్రధాన ఉద్దేశ్యం logical groups కు కోడింగ్ను నిర్వహించడం.
 మరియు ఇది చాలా ముఖ్యమైన అవసరం.
 మరియు, నేమ్స్పేస్ ఉన్న ప్రధాన కారణాల్లో ఒకటి name clash, name collision జరగకుండా నివారించడం.
 ముఖ్యంగా, కోడ్ బేస్లో మల్టిపుల్ లైబ్రరీలు ఉంటాయి, కోడ్ బేస్ లైబ్రరీలు లేదా standard లైబ్రరీలు ద్వారా కేటాయించబడే నేమ్స్ ను ఉపయోగించడం కోడెడ్, లేదా కోడ్ బేస్ independent డెవలపర్లు అభివృద్ధి చేయబడుతున్నాయి మరియు అనుకోకుండా అదే నేమ్స్ యొక్క సెట్ ను ఉపయోగించారు.
 కాబట్టి, ఇది ప్రధాన ఉద్దేశ్యం, నేమ్స్పేస్ ఏమిటి, ఇది ఒక స్కోప్ నిర్వచిస్తుంది మరియు కోడ్ను నిర్వహించడానికి ఇది ప్రధాన ఉద్దేశం.
 ప్రతి క్లాస్ డెఫినిషన్ మాడ్యులర్ డెఫినిషన్ రకంగా ఉంటుంది, కాని వ్యత్యాసం ఏ సెమాంటిక్స్ ఉండదు అని తెలిసినట్లుగా నేమ్ స్పేస్ మాడ్యులరైజేషన్ వంటి క్లాస్ ని అందిస్తుంది.
 ఇది కేవలం ఒక స్కోపింగ్ నియమం, క్లాస్కి కూడా స్కోపింగ్ చేస్తుంది, కానీ ఇది క్లాస్ సెమాంటిక్స్తో స్కోపింగ్ చేస్తుంది.
 నేమ్ స్పేస్ ప్రత్యేకంగా ఏ సెమాంటిక్స్ను కలిగి ఉండదు.
 మరియు, సి లోని ఫైల్ స్కోప్ గురించి మీకు తెలిసిన వారికి, ఒక ఫైల్ స్టాటిక్ వేరియబుల్ లేదా ఫైల్ స్టాటిక్ ఫంక్షన్ (ఫైల్ స్టాటిక్ ఫంక్షన్) అని మేము చెప్పినట్లుగా, నేమ్‌స్పేస్ యూజ్ ఫైల్ స్కోప్ యొక్క అవసరాన్ని తొలగిస్తుంది. సి.
 మీరు అదే ఉపయోగిస్తుంటే, మీకు అవసరమైనప్పుడు మీరు దానిని ఉపయోగించకూడదు మరియు ఆ ప్రదేశంలో నేమ్‌స్పేస్ (నేమ్‌స్పేస్) ను ఉపయోగించకూడదు.
 అసలు కోడ్‌ను మీకు పరిచయం చేద్దాం, ఎలా రాయాలో అర్ధవంతమైన ఉదాహరణ కాదు.
 కాబట్టి ఇక్కడ, నేమ్‌స్పేస్ ఒక కీవర్డ్ అని నేను చెప్తున్నాను, దానితో క్లాస్ మీరు చేసే కీవర్డ్ మరియు నేమ్‌స్పేస్ నేమ్‌స్పేస్‌ను అనుసరించాలి.
 కాబట్టి, వాక్యనిర్మాణం మీరు తరగతిని ఎలా నిర్వచించాలో చాలా ఇష్టం.
 సరిపోయే వంకర కలుపుల పరంగా ఇది అనుబంధ పరిధిని కలిగి ఉంది మరియు ఆ నేమ్‌స్పేస్‌లో మీరు వ్రాసే ప్రతిదీ నేమ్‌స్పేస్‌కు సంబంధించినది, అంటే దాని లోపల మీరు వ్రాసే ఏ గుర్తు అయినా నేమ్‌స్పేస్.
 కాబట్టి, ఇక్కడ నేను 3 రకాల ఎంట్రీలను చూపిస్తాను.
 ఒక వేరియబుల్‌కు నా డేటా అని పేరు పెట్టబడింది, ఒక ఫంక్షన్ మరియు క్లాస్ myData, myFunction, MyClass.
 ఆపై, ప్రధానంగా నేను దానిని ఎలా ఉపయోగించాలో చూపిస్తాను.
 నేను డేటాను ఉపయోగించాలనుకుంటే, నేను దీనిని ఇలా వ్రాయాలి.
 కాబట్టి, వేరియబుల్ పేరు నా డేటా అని మీరు చూడవచ్చు, ఇది నేమ్‌స్పేస్ నేమ్‌స్పేస్ ద్వారా అర్హత పొందింది.
 తరగతి పేర్లు ఎలా అర్హత సాధించాయో ఇది సమానంగా ఉంటుంది, ఉదాహరణకు, క్లాస్‌ఎస్‌లోని స్టాటిక్ డేటా సభ్యుల గురించి మీరు క్లాస్‌ఎస్‌లో స్టాటిక్ అని నేను వెంటనే మీకు గుర్తు చేస్తాను.
 కాబట్టి, సింబల్ పేరు, నేమ్‌స్పేస్ పేరు తరువాత, స్కోప్ రిజల్యూషన్ ఆపరేటర్ ద్వారా వేరు చేయబడుతుంది, ఇది నేమ్‌స్పేస్ ఆబ్జెక్ట్‌ను సూచించే మార్గం.
 ఉదాహరణకు, మనకు ఉన్న ఫంక్షన్, ఈ పేరు, తరగతి కోసం, ఇది పేరు.
 నేమ్‌స్పేస్ యొక్క ఈ సందర్భంలో, ఇక్కడ నేను మైఫంక్షన్ వ్రాసి, దాన్ని ప్రారంభించడానికి ప్రయత్నిస్తే, అప్పుడు నాకు సంకలన లోపం వస్తుంది.
 ఎందుకంటే, ఈ కార్యక్రమంలో నా పని అని పిలువబడే చిహ్నం లేదు.
 నా ఫంక్షన్ (మైఫంక్షన్) సింబల్ నేమ్‌స్పేస్‌లో ఉంది మరియు అందువల్ల ఎల్లప్పుడూ నేమ్‌స్పేస్‌తో ప్రిఫిక్స్ చేయాలి.
 కాబట్టి, ఇది మీరు నేమ్‌స్పేస్ (నేమ్‌స్పేస్) ను నిర్వచించే ప్రాథమిక మార్గం మరియు మీరు నేమ్‌స్పేస్ (నేమ్‌స్పేస్) ను ఉపయోగిస్తారు.
 రెండు దృశ్యాలపై దృష్టి పెడదాం, ఒకటి సరళమైనది మరియు కొంచెం ఎక్కువ ప్రమేయం.
 లైబ్రరీ ఫంక్షన్‌ను పునర్నిర్వచించటానికి నేను ప్రయత్నిస్తున్న దృశ్యం ఇక్కడ ఉంది.
 అందువల్ల, లైబ్రరీ ఫంక్షన్‌లో ABS ఫంక్షన్ ఉందని, ప్రామాణిక లైబ్రరీకి ABS ఫంక్షన్ ఉందని మనందరికీ తెలుసు, ఇది సంపూర్ణ విలువను కనుగొంటుంది, కాని నేను దీనికి భిన్నమైన ప్రవర్తనను ఇవ్వాలనుకుంటున్నాను.
 -128 మరియు 127 లోపు ఇది పూర్తి మనస్సును కలిగిస్తుందని నేను చెప్పాలనుకుంటున్నాను, లేకపోతే అది ఆ పరిధికి వెలుపల ఉంటే అది శూన్యంగా తిరిగి వస్తుంది.
 కాబట్టి, దీన్ని చేయటానికి సరళమైన మార్గం, నేను అబ్స్ ఫంక్షన్ (ఫంక్షన్) ను నిర్వచించి దానిని ఉపయోగించడం ప్రారంభించాను, మరియు దాని యొక్క ఇతర కోణం ఏమిటంటే, మనం ఇలా చేస్తే, సి స్టాండర్డ్ లైబ్రరీలో ఉన్న అబ్స్ ఫంక్షన్ (ఫంక్షన్) హిడెన్, నేను నా అబ్స్ ఫంక్షన్‌ను నిర్వచించిన తర్వాత, లైబ్రరీ నుండి లభించే అబ్స్ ఫంక్షన్ (ఫంక్షన్) ఇకపై అందుబాటులో ఉండదు.
 నేను అబ్స్ ను ఉపయోగిస్తే, అది నా అబ్స్ అని అర్ధం, ఇది లైబ్రరీలోని ఎబిఎస్ అని ఎప్పటికీ అర్ధం కాదు.
 కాబట్టి, నేను దాని ద్వారా కోల్పోతాను. నేను దీనిని సి లో చేస్తే, మనం సి ++ లో చేయవచ్చు.
 అసలు లైబ్రరీ ఫంక్షన్‌ను సూచించే సామర్థ్యాన్ని నేను నిజంగా కోల్పోతాను.
 అందువల్ల, నేమ్‌స్పేస్ మంచి పరిష్కారాన్ని అందిస్తుంది.
 నేను దీన్ని చేయాలనుకుంటే మరియు లైబ్రరీ ఫంక్షన్‌ను కూడా ప్రస్తావించాలనుకుంటే, నేను ఇప్పటికీ నా అబ్స్ ఫంక్షన్‌ను నిర్వచించగలను, కాని నేను దానిని కొత్త నేమ్‌స్పేస్‌లో ఉంచుతాను.
 అందువల్ల, నేను దానిని నా ఎన్ఎన్ఎస్ అని పేరు పెట్టాను.
 కాబట్టి, దీనితో నేను ABS ఫంక్షన్ (ఫంక్షన్) ను దాని ns :: abs గా సూచిస్తే, అది ఈ ఫంక్షన్ (ఫంక్షన్) ను సూచిస్తుంది.
 నేను ఇప్పుడు చెబితే, అబ్స్ అందుబాటులో లేదు, ఎందుకంటే ఈ కొత్త కొత్త అబ్స్ వెర్షన్ నా ఎన్ఎన్ఎస్ పేరు పరిధిలో ఉంది.
 కాబట్టి, నేను అబ్స్ అని చెబితే, ప్రామాణిక లైబ్రరీలో అబ్స్ లేకపోవడం అంటే.
 ఈ విధంగా నేను లైబ్రరీ పేరు లేకుండా ఉన్న నా కొత్తగా ప్రవేశపెట్టిన నిర్వచనాలను రక్షించగలను.
 ఇది మీరు చాలా తరచుగా ఎదుర్కొనే చాలా ప్రత్యేకమైన అవసరం మరియు నేమ్‌స్పేస్‌లను ఉపయోగించడం మంచి పరిష్కారం.
 అభివృద్ధి దృష్టాంతంలో నేను త్వరగా నడుస్తాను.
 ఏ సంస్థలోనైనా ఇది క్రమం తప్పకుండా జరుగుతుంది.
 విద్యార్థుల రికార్డులను ప్రాసెస్ చేయడానికి ఒక సంస్థ ఒక అప్లికేషన్‌ను అభివృద్ధి చేస్తుందని అనుకుందాం మరియు రెండు తరగతులు ఉన్నాయని పేర్కొనండి; విద్యార్థులకు ఒకటి.
 కాబట్టి, మాకు రెండు తరగతులు ఉన్నాయి; ఇది విద్యార్థిని సూచిస్తుంది మరియు ఇది విద్యార్థుల జాబితాను సూచిస్తుంది.
 వాస్తవానికి ఇది సరైన ప్రోగ్రామ్ అయినప్పటికీ మీరు వివరాల గురించి నిజంగా బాధపడలేరు.
 కాబట్టి, మీరు చదివిన సమయానికి మీరు తరువాత చదవవచ్చు మరియు ఈ ప్రోగ్రామ్ ఏమి చేస్తుందో ఖచ్చితంగా కనుగొనవచ్చు.
 ఇది ఖచ్చితంగా భిన్నంగా ఉంటుంది, దీనికి కన్స్ట్రక్టర్ ఉంది, దీనికి కొన్ని సెట్లు మరియు ఫంక్షన్లు ఉన్నాయి మరియు ఇది విద్యార్థి రికార్డ్ రాయగల సామర్థ్యం గల అవుట్పుట్ ఆపరేటర్‌ను కలిగి ఉంది.
 మరియు, దీనికి ఒక జాబితా ఉంది మరియు ఇది హాజరైన విద్యార్థుల సంఖ్యను పర్యవేక్షిస్తుంది మరియు ఈ జాబితాలో ఒక విద్యార్థిని చేర్చే అవకాశం ఉంది.
 అందువల్ల, మీరు విద్యార్థిని జోడించినప్పుడల్లా, ఆ విద్యార్థి యొక్క రోల్ నంబర్ కేటాయించబడుతుంది.
 ఈ ప్రాసెసింగ్ అనువర్తనాన్ని అభివృద్ధి చేసే విషయంలో, సంస్థ ఏమి చేస్తుంది మరియు చాలా నిర్దిష్టంగా ఉంటుంది, డిజైనర్లలో ఒక సీనియర్ బహుశా ఈ క్లాస్ఎస్ (క్లాసులు) ను డిజైన్ చేసి ఉండవచ్చు.
 ఆపై చాలా మంది డెవలపర్లు సిస్టమ్ యొక్క వివిధ భాగాలను అభివృద్ధి చేయటానికి బాధ్యత వహిస్తారు.
 కాబట్టి, ఈ తరగతులు తరగతులను రూపొందించాయి మరియు స్టూడెంట్స్ హెచ్ అనే హెడర్ ఫైల్‌లో ఇవ్వబడ్డాయి.
 ఈ సమయంలో బాధ్యత ఇవ్వబడుతుంది; మగ విద్యార్థులకు మరియు మహిళా విద్యార్థుల కోసం విడిగా అభివృద్ధిని విభజించమని ఇంజనీర్లను అడుగుదాం.
 వారికి వేర్వేరు హాస్టల్ అవసరాలు, విభిన్న విషయ వర్గీకరణ అవసరాలు మొదలైనవి ఉంటాయి.
 కాబట్టి, ఇది మగ విద్యార్థుల కోసం సవిత చేత చేయబడుతోంది; మహిళా విద్యార్థులకు నీలోయ్ సమాన అభివృద్ధి; మరియు పూర్ణిమా అతని నాయకుడు, చివరికి ఈ రెండు అనువర్తనాలను మీ తుది అనువర్తనాలతో అనుసంధానించాలి.
 కాబట్టి ఏమి జరుగుతుంది, ఇది ప్రమాదవశాత్తు, యాదృచ్చికంగా, ఏమైనా కావచ్చు, సవిత ఈ మొత్తం ప్రాసెసింగ్ అప్లికేషన్‌ను మగ విద్యార్థుల కోసం ప్రాసెస్ స్టూడెంట్స్‌గా పిలుస్తుంది; మరియు, నీలోయ్ ఫంక్షన్ యొక్క అదే పేరును కూడా ఎంచుకుంటాడు.
 ఆపై, వారు అభివృద్ధి చేసిన వాటిని పరీక్షించడానికి స్వతంత్ర కోర్ అనువర్తనాలను వ్రాస్తారు.
 మీరు ఏమి చేస్తున్నారనే దాని గురించి మీరు బాధపడవలసిన అవసరం లేదు, ఇది ప్రాథమికంగా, ఈ అనువర్తనం మగ విద్యార్థులను ముద్రించినట్లయితే, ఈ అనువర్తనం మహిళా విద్యార్థులను ముద్రిస్తుంది, కానీ ఇది కేవలం ప్రాసెసింగ్ ఏమి జరుగుతుందో నేను నిజంగా ఆందోళన చెందడం లేదు అనే సూచన ఉంది .
 వాస్తవం ఏమిటంటే, వారు యాదృచ్చికంగా ఒకే ఫంక్షన్ పేరును ఎంచుకున్నారు మరియు స్వతంత్రంగా కలిసి అభివృద్ధి చేశారు.
 ఇప్పుడు, ఇద్దరూ పూర్ణిమకు కోడ్ను సమర్పించారు, ఇది ప్రధానమైనది, ఇప్పుడు పూర్ణిమ వాటిని కలిసి ఉంచాలి.
 కాబట్టి, వాస్తవానికి, మేము ఒక్కసారి తిరిగి వస్తే, పౌర్ణమి ఈ కీని ఉపయోగించదు, లేదా ఈ కీని ఉపయోగించదు, ఎందుకంటే ఈ రెండు కోడ్‌లను ఇది సమగ్రపరచాలి.
 కాబట్టి, ఇది అందరికీ ఒక ప్రధాన ఇంటిగ్రేటెడ్ అప్లికేషన్ రాయాలి.
 కాబట్టి, ఆమె రాయడానికి ప్రయత్నిస్తుంది.
 కాబట్టి, అతను ఈ ఫంక్షన్లను పిలవాలి, విద్యార్థుల ఫంక్షన్లను ప్రాసెస్ చేయాలి.
 అతను తన నిర్వచనాలను ఉంచాలి మరియు రెండూ ఒకే ఫంక్షన్ పేరును ఉపయోగిస్తాయని అతను కనుగొన్నాడు.
 కాబట్టి, ఆమె అతని కోడ్‌ను కాపీ చేస్తే, ఇది ఇలా ఉంటుంది.
 మీరు అర్థం చేసుకోగలిగినట్లుగా ఇది పేరు ఘర్షణను ఇస్తుంది మరియు అది ఒకేలా ఉండకపోవచ్చు, ఇది కంపైల్ చేయదు.
 ఇప్పుడు, మొత్తం సమైక్యత ప్రక్రియ విఫలమైంది.
 నేను ఒక ఫంక్షన్ పేరును సూచనగా మాత్రమే చూపించాను, కాని వాస్తవానికి, అనువర్తనం వేలాది పంక్తుల జతలలో ఉంటుంది.
 అనేక చిహ్నాలు, అనేక విధులు, గ్లోబల్ వేరియబుల్స్, క్లాస్ పేర్లు, అనేక రకాలు మరియు మొదలైనవి ఉండవచ్చు, ఇవి రెండు డెవలపర్‌ల మధ్య ఒకే పేరు కావచ్చు.
 ఎక్కువ మంది డెవలపర్లు కూడా ఉండవచ్చు.
 కొన్ని సందర్భాల్లో, ఒకే పేరు అంటే ప్రోగ్రామ్‌లు లేదా ఇద్దరు డెవలపర్‌ల కోడ్ మధ్య ఒకే విషయం; కొన్ని సందర్భాల్లో, సవిత ఉపయోగించిన అదే పేరు నిలోయ్ వేరే అర్థంలో ఉపయోగించబడుతుంది.
 కాబట్టి, ఇది చాలా కష్టమైన సమస్య.
 పౌర్ణమిని ఏకీకృతం చేయాలంటే, అది మొత్తం కోడ్‌ను అర్థం చేసుకోవాలి, ఆపై దాన్ని సవరించాలి మరియు దానిలో మార్పులు చేయాలి మరియు ఇది పూర్తి పీడకల అవుతుంది.
 కాబట్టి, దీనిని సాధారణంగా సంస్థలో సంభవించే ఇంటిగ్రేషన్ పీడకల అంటారు.
 కానీ, వాస్తవం యొక్క ఇతర అంశం ఏమిటంటే, రెండు అనువర్తనాలు మగ విద్యార్థుల కోసం సవిత మరియు స్వతంత్రంగా పనిచేసే మహిళా విద్యార్థుల కోసం నీలోయ్ చేత అభివృద్ధి చేయబడ్డాయి, అది మాత్రమే, వారు కొన్ని సాధారణ పేర్లను పంచుకుంటారు. అందువల్ల నేమ్‌స్పేస్ పరిష్కరించగల ఒక వినాశనం అవుతుంది ఈ సమస్య చాలా సులభంగా.
 పూర్ణిమా ఇప్పుడు సవిత అభివృద్ధి చేసిన మరియు నిలోయ్ అభివృద్ధి చేసిన అన్ని అనువర్తనాలను తీసుకొని వాటిని రెండు వేర్వేరు నేమ్‌స్పేస్‌లలో ఉంచాలి.
 ఆమె యాప్ 1 మరియు యాప్ 2 అనే రెండు పేర్లను నిర్ణయిస్తుంది మరియు సవిత యొక్క సంఘటనలను, నీలోయ్ యొక్క సంఘటనలను అందులో ఉంచుతుంది.
 కాబట్టి, అది పూర్తయిన తర్వాత, ఈ అనువర్తనంలో, ఇవన్నీ ఒకే నేమ్‌స్పేస్‌లో ఉంటాయి.
 కాబట్టి, అప్లికేషన్ ఇప్పటికీ పనిచేస్తుంది.
 ఈ భాగం ఇప్పటికీ పని చేస్తుంది, కానీ మీరు ప్రధాన ఫంక్షన్ల కోణం నుండి చూస్తున్నప్పుడు మీరు బయట ఉన్నప్పుడు, ఈ రెండు రెండు వేర్వేరు నేమ్‌స్పేస్‌లలో ఉంటాయి.
 కాబట్టి, అవి ప్రాథమికంగా, విభిన్న విధులు.
 అందువల్ల, వాటిని నేమ్‌స్పేస్‌కు జోడించిన తర్వాత తిరిగి వస్తుంది.
 ఇప్పుడు, అతను తిరిగి సమైక్యతలోకి వచ్చాడు.
 అంటే, సావిత యొక్క అనువర్తనాలు ఇప్పుడు యాప్ 1 నేమ్‌స్పేస్ (నేమ్‌స్పేస్) లో పనిచేసే విద్యార్థుల కోసం చాలా ప్రక్రియ. నిలోయ్ కోసం, ఈ అనువర్తనం 2 నేమ్‌స్పేస్‌లలో ఉంది.
 అందువల్ల, అతను చేయవలసినది చేస్తూ, అతను రెండు అభివృద్ధి యూనిట్ల మధ్య పేరు ఘర్షణను పరిష్కరించాడు మరియు అప్లికేషన్ సందర్భంలో, అతను చేయాల్సిందల్లా నేమ్‌స్పేస్ (నేమ్‌స్పేస్) ఉపసర్గను ఉపయోగించడం. మరియు రెండు పనులను స్వతంత్రంగా కాల్ చేయండి, ఒకటి తరువాత మరొకటి లేదా ఆమె చేయాలనుకుంటున్నది.
 కాబట్టి, ఇది చాలా నిర్దిష్టమైన విధానం, ఇది పెద్ద మొత్తంలో ప్రాక్టికల్ ఇంటిగ్రేషన్ సమస్యను పరిష్కరించగలదు మరియు దానిని పరిగణనలోకి తీసుకోవాలి.
 వాస్తవానికి, ఒకే వ్యవస్థలోని చాలా మంది డెవలపర్లు (డెవలపర్లు) వేర్వేరు పేర్లను సమన్వయం చేసుకోలేరు మరియు పరిష్కరించలేరు అనేది మంచి ఆలోచన కాదు, అయితే తరచుగా వేర్వేరు మాడ్యూల్స్ (మాడ్యూల్) కోసం నేమ్‌స్పేస్‌లను ఉపయోగించడం మంచిది. పేర్లు, వేర్వేరు సహాయక విధులు, సహాయక తరగతులు మరియు వేర్వేరు మాడ్యూళ్ల మధ్య మీరు నిజంగా బాధపడవలసిన అవసరం లేదు.
 అందువల్ల, మేము విద్యార్థుల రికార్డును అభివృద్ధి చేస్తుంటే, ప్రధానంగా విద్యార్థుల విద్యా భాగాలతో పనిచేసే మాడ్యూల్ ఉండవచ్చు; ఒక మాడ్యూల్ విద్యార్థుల ఫీజులకు సంబంధించినది; మాడ్యూల్ హాస్టల్‌తో సంబంధం కలిగి ఉంటుంది; మరొక మాడ్యూల్ వారి టైమ్‌టేబుల్‌తో వ్యవహరిస్తుంది.
 కాబట్టి, కోడ్‌ను నిర్వహించడానికి మరియు రూపకల్పన చేయడానికి ఒక మంచి మార్గం ఈ మాడ్యూల్‌కు ప్రత్యేక నేమ్‌స్పేస్‌ను కేటాయించడం మరియు ప్రాథమికంగా కోడ్‌ను ఆ విధంగా వేరు చేయడం, తద్వారా ఇది ఎప్పటికీ .ీకొనకుండా చూసుకోండి.
 అందువల్ల, నేమ్‌స్పేస్ ఎందుకు ముఖ్యమో మీరు అర్థం చేసుకున్న చర్చను మాత్రమే నేను పూర్తి చేయాలి.
 కాబట్టి, నేను నేమ్‌స్పేస్ అయిన శీఘ్ర లక్షణాలకు మాత్రమే వెళ్లాలి.
 నేను చెప్పినట్లు, ఇది ఒక తరగతికి సమానం; తరగతి వలె, నేమ్‌స్పేస్ గూడు చేయవచ్చు.
 కాబట్టి, నాకు ఇక్కడ 1 అనే నేమ్‌స్పేస్ ఉంది మరియు దాని లోపల నాకు మరొక నేమ్‌స్పేస్ ఉంది.
 కాబట్టి, ఇదంతా జరుగుతుంది, నేను ఒక నేమ్‌స్పేస్ (నేమ్‌స్పేస్) ను మరొకదానికి గూడు చేస్తే, ఈ నెస్టెడ్ నేమ్‌స్పేస్ (నేమ్‌స్పేస్) పేరు బాహ్య నేమ్‌స్పేస్ (నేమ్‌స్పేస్) ద్వారా అర్హత పొందుతుంది.
 కాబట్టి, ఇది చాలా సులభం.
 కాబట్టి, ఈ డేటా నేమ్‌స్పేస్ నేమ్స్ 1 లో ఉందని అర్థం, అయితే, ఇది డేటా 1 డేటా పేర్ల నేమ్‌స్పేస్‌లో ఉంది :: పేర్లు 2, ఎందుకంటే ఇది సొంత పేరు 1 :: పేర్లు. 2
 కాబట్టి, మేము ఈ కోడ్ వ్రాస్తే, నేను డేటాను వ్రాస్తే, అప్పుడు డేటా మాత్రమే అయిపోతుంది, అంటే డేటా అని అర్ధం.
 నేను name1 :: data అని వ్రాస్తే, ఈ డేటా అంటే, నేను name1 :: name2 :: data (data) అని వ్రాస్తే, అంటే డేటా.
 అందువల్ల, మీరు నేమ్‌స్పేస్‌ను గూడులో ఉంచుకున్నప్పుడు, మరింత ఎక్కువ ఉపసర్గలు జోడించబడతాయి.
 కాబట్టి, నేమ్‌స్పేస్ కోసం ఏ స్థాయిలోనైనా ఒక గూడును సృష్టించడం సాధ్యపడుతుంది.
 తరచుగా, మీరు ఈ విధంగా చేస్తే మీకు చాలా గూళ్ళు మరియు మీరు ఉపయోగించాలనుకునే అనేక చిహ్నాలు ఉన్నందున, ప్రతిసారీ మీరు నేమ్‌స్పేస్ (నేమ్‌స్పేస్) ను నమోదు చేయాలి.
 కాబట్టి, మీరు ఉపయోగించగల సత్వరమార్గం ఉంది.
 మీరు ఉపయోగించగల ప్రాథమికంగా రెండు సత్వరమార్గాలు ఉన్నాయి; వీటిలో ఒకదాన్ని ఉపయోగించడం అంటారు.
 కాబట్టి, మీరు చేయగలిగే ఒక సత్వరమార్గం మిమ్మల్ని ఉపయోగించడం, ఆపై మీరు నేమ్‌స్పేస్‌కు పేరు పెట్టండి.
 కాబట్టి, నేమ్‌స్పేస్ నేమ్స్ 1 ను ఉపయోగించమని మీరు అంటున్నారు.
 ఇది తరువాత ఉపయోగించబడే చిహ్నం ఉందని దీని అర్థం; ఈ నేమ్‌స్పేస్ పేరు 1 లో చిహ్నంగా ఉందో లేదో తనిఖీ చేయడానికి మీరు ప్రయత్నిస్తారు.
 మరియు ఆ చిహ్నం ఉంటే మీరు ఆ గుర్తును ప్రస్తావిస్తారు.
 కాబట్టి, నేమ్‌స్పేస్‌ను ఉపయోగించడం యొక్క లక్షణం ఇది.
 మరొక లక్షణం ఉపయోగిస్తోంది, మీరు ఉపయోగించమని చెప్పవచ్చు మరియు మీరు చెప్పవచ్చు, వాస్తవానికి ఇది విలువైన చిహ్నం.
 కాబట్టి, మీరు అర్హతగల చిహ్నాన్ని పేర్కొంటే, అర్హత గల చిహ్నానికి పేరు పెట్టండి, తరువాత మీరు చిహ్నం పేరు గురించి మాట్లాడినప్పుడల్లా, అది అర్హత కలిగిన చిహ్నం అని అర్ధం.
 కాబట్టి, ఈ ఉదాహరణ సహాయపడాలి.
 కాబట్టి, నాకు రెండు నేమ్‌స్పేస్‌లు ఉన్నాయి, పేరు 1 మరియు పేరు 2; name1 కి రెండు చిహ్నాలు ఉన్నాయి; పేరు 2 రెండు చిహ్నాలుగా; మరియు, నేమ్ 1, నేమ్‌స్పేస్ నేమ్ 1 పై నాకు ఉపయోగం ఉంది మరియు ఈ ప్రత్యేక చిహ్నం, నేమ్ 2 యొక్క వేరియబుల్‌పై నాకు ఒక ప్రయోగం ఉంది.
 కాబట్టి, ఏమి జరుగుతుంది? నేను v11 అని చెబితే, అది ఏమి తనిఖీ చేస్తుంది? నేను నేమ్‌స్పేస్ నేమ్స్ 1 ఉపయోగిస్తున్నానని ఇది తనిఖీ చేస్తుంది.
 కాబట్టి, ఆ నేమ్‌స్పేస్‌లో V11 ఉందా? అది జరుగుతుంది.
 కాబట్టి, అది దానితో కలుపుతుంది.
 నేను పేరు 1: v 12 అని చెబితే, అది ఇక్కడ అనుబంధించబడుతుంది.
 అందువల్ల, నేను దాన్ని ఉపయోగిస్తున్నప్పుడు కూడా, నేను చిన్న రూపాన్ని ఉపయోగించడం తప్పనిసరి కాదని మీరు చూడవచ్చు.
 అలా చెప్పే బదులు, నేను v12 మాత్రమే వ్రాయగలను; ఇది నేమ్ 1 లో కూడా అదే వేరియబుల్ గురించి ప్రస్తావించింది, ఎందుకంటే నేను నేమ్‌పేస్ నేమ్ 1 ఉపయోగిస్తున్నాను.
 కానీ, నేను ఉపయోగించే సత్వరమార్గాన్ని ఉపయోగించడం తప్పనిసరి కాదు లేదా నేను ఇక్కడ చేసినట్లుగా పూర్తి అర్హత గల పేరును కూడా ఉపయోగించగలను.
 V21.v21 గురించి ఆలోచించండి దీని అర్థం.
 ఎందుకు? నేను నేమ్‌స్పేస్ నేమ్‌లను ఉపయోగించను.
 కానీ, నేను ఈ ప్రత్యేక చిహ్నంపై మాత్రమే ప్రయోగాలు చేస్తున్నాను.
 కాబట్టి, నేను v21 అని చెబితే దాని అర్థం, ఇది పేరు 2 :: v21 మరియు అది సరైనది.
 అదేవిధంగా, పేరు 2 :: v21 అని చెప్పి, స్టిల్ పద్ధతుల ద్వారా నేను దీన్ని నేరుగా సూచించగలను. ఇది కూడా అనుమతించబడుతుంది; పేరు యొక్క స్పష్టమైన ఉపయోగం అనుమతించబడుతుంది.
 V22 గురించి ఆలోచించండి; v22 ఇక్కడ ఉంది.
 నేమ్‌స్పేస్‌లో నేమ్ 2 ను ఉపయోగించాల్సిన అవసరం లేదు.
 కాబట్టి, v22 అని అర్ధం కాకపోవచ్చు, ఈ ప్రత్యేక సంస్థ పేరు 2: v22 వంటి ఉపయోగం నాకు లేదు. అది నా దగ్గర లేదు.
 కాబట్టి, కంపైలర్ ఈ కోడ్‌లో ఏ v22 చిహ్నాలను చూడలేరు మరియు కంపైలర్ దానిని నిర్వచించనిదిగా పరిగణిస్తుంది.
 ఇది వి 22 అనే గుర్తు లేదు.
 ఇది ఉపయోగించడానికి ప్రాథమిక ఉపయోగం; ఉదాహరణకు, మీరు దీన్ని కోడ్‌లో చూస్తున్నారు, ప్రామాణిక లైబ్రరీలోని అన్ని చిహ్నాలు నేమ్‌స్పేస్‌లో ఉన్నందున మేము దీనిని వ్రాస్తూనే ఉంటామని నేను మొదట్లో పేర్కొన్నాను.
 కాబట్టి, ఇది రాయడం మన జీవితాన్ని సులభతరం చేస్తుంది, మీ కౌట్ ను std :: out; సిన్ గా std :: cin et cetera.
 ఇప్పుడు, మేము గ్లోబల్ నేమ్‌స్పేస్ గురించి కూడా మాట్లాడుతాము.
 నాకు ఒక ఉదాహరణ ఉందని అనుకుందాం.
 ఉదాహరణ అర్థం చేసుకోండి; గ్లోబల్ స్కోప్ డేటాకు వ్రాయబడిన వేరియబుల్ నాకు ఉంది.
 నేమ్‌స్పేస్ నేమ్స్ 1 లో, నాకు వేరియబుల్ డేటా ఉంది.
 ఇప్పుడు, మీరు ఈ ప్రోగ్రామ్ గురించి క్రింద ఆలోచించకపోతే అవి పరిష్కరించగలవు, ఎందుకంటే అవి పరిష్కరించబడతాయి, ఎందుకంటే నేను డేటాను వ్రాస్తే, దీని అర్థం మరియు నేను పేరు 1 :: డేటాను వ్రాస్తే, దీని అర్థం, స్పష్టంగా.
 కానీ, ఈ ఫంక్షన్ (ప్రధాన) లో అనుకుందాం, నాకు నేమ్ 1 :: డేటా వాడకం ఉంది.
 కాబట్టి దీని అర్థం ఏమిటి? దీని అర్థం, ఇప్పుడు నేను డేటా గురించి మాట్లాడితే, ఈ డేటా అని అర్థం; ఇప్పుడు ఈ డేటా అర్థం కాదు; ఎందుకంటే, నేను నేమ్ 1 :: డేటాను ఉపయోగించాలి.
 కాబట్టి, నేమ్ 1 :: డేటా ఈ సమయం నుండి డేటాగా పిలువబడుతుంది.
 కాబట్టి, నేను డేటా చెబితే, నేను దాన్ని పొందుతాను.
 నేను name1 :: data అని చెబితే, నేను కూడా దీన్ని పొందుతాను.
 కాబట్టి, దీని అర్థం నేమ్‌స్పేస్‌లో నిర్వచించబడని డేటాను యాక్సెస్ చేసే సామర్థ్యాన్ని నేను కోల్పోయాను, ఇది బయట నిర్వచించబడింది.
 కాబట్టి, గ్లోబల్ రాజ్యంలో ఉన్న గ్లోబల్ స్పేస్‌లో ఉన్న చిహ్నాలను యాక్సెస్ చేయగలిగేలా సి ++ మాకు ఒక యంత్రాంగాన్ని ఇస్తుంది.
 మీరు ఏమి చేసినా, మీరు అదే సంజ్ఞామానాన్ని ఉపయోగిస్తారు, కానీ ప్రపంచ, ఆలోచన అనేది ఒక రకమైనది, నేమ్‌స్పేస్ వంటి ప్రపంచ పరిధి కూడా, కానీ ఆ నేమ్‌స్పేస్ (నేమ్‌స్పేస్) కు పేరు లేదు
 కాబట్టి, ఇది కేవలం ఖాళీ పేరు.
 కాబట్టి, మీరు చేసే ప్రతిదాన్ని :: డేటా.
 కాబట్టి, ఇది ఎల్లప్పుడూ గ్లోబల్ స్కోప్‌లోని పేరును సూచిస్తుంది.
 కాబట్టి, ఇది ఉనికిలో ఉన్న గ్లోబల్ నేమ్‌స్పేస్ యొక్క ప్రాథమిక భావన.
 ప్రామాణిక నేమ్‌స్పేస్, కాబట్టి మేము దాని గురించి మాట్లాడుతున్నాము, అన్ని C ++ దాని ప్రామాణిక లైబ్రరీ చిహ్నాలు, తరగతులు, విధులు, ప్రతిదీ std నేమ్‌స్పేస్‌లో ఉంచుతుంది.
 కాబట్టి, మేము IO స్ట్రీమ్‌ను మాత్రమే చేర్చుకుని, దీన్ని చేయాలనుకుంటే, దాన్ని ఉపయోగించి ఒక ప్రోగ్రామ్‌ను రాయండి, అప్పుడు ప్రతిసారీ మనం గుర్తును std :: తో ప్రిఫిక్స్ చేయాలి.
 ఉదాహరణకు, నేను ఎండ్ల్ రాయాలనుకుంటే, నేను దానిని std :: endl, endline అని వ్రాయాలి.
 అందువల్ల, మేము నేమ్‌స్పేస్ std ఉపయోగించి సత్వరమార్గాన్ని చేయవచ్చు.
 దీని అర్థం ఏమిటంటే, నేను కౌట్ వ్రాస్తే, అది std నేమ్‌స్పేస్ (నేమ్‌స్పేస్) కు కౌట్ ఉందో లేదో కూడా తనిఖీ చేస్తుంది; ఇది ఒకటి.
 కాబట్టి, std అదే సంబంధం ఉంటుంది.
 కాబట్టి, std నేమ్‌స్పేస్ మనకు అందుబాటులో ఉన్న అతి ముఖ్యమైన నేమ్‌స్పేస్.
 మరిన్ని నేమ్‌స్పేస్‌ల జతలు కూడా నిర్వచించబడ్డాయి.
 మేము తరువాత వాటి గురించి మాట్లాడుతాము.
 నేమ్‌స్పేస్‌ల గురించి చాలా ఆసక్తికరమైన అంశం ఏమిటంటే, నేమ్‌స్పేస్‌లు తెరిచి ఉన్నాయి, ఆ కోణంలో; ఒక తరగతి గురించి ఆలోచించండి. మీరు ఒక తరగతిని మాత్రమే నిర్వచించినట్లయితే, మీరు ఆ తరగతి, డేటా సభ్యుడు, ఫంక్షన్ మరియు మొదలైన వాటిలో ఏ చిహ్నాన్ని ఉంచారో., స్నేహితులు మరియు తరగతి యొక్క సమగ్ర నిర్వచనంలో చేర్చబడిన వారందరూ.
 మరియు, ఆ పరిధి ముగిసిన తర్వాత, మీరు తరగతి యొక్క పరిధికి కొత్త చిహ్నాలను జోడించలేరు.
 కానీ నేమ్‌స్పేస్‌లో ఇది భిన్నంగా ఉంటుంది.
 కాబట్టి, నేమ్‌స్పేస్ ఓపెన్‌గా ఉండటానికి దీని అర్థం.
 ఇక్కడ, నేను నేమ్‌స్పేస్‌ను సృష్టించాను, అక్కడ నేను x చిహ్నాన్ని ఉంచాను.
 పరిధి మూసివేయబడింది; ఇది ఇక్కడ నుండి ప్రారంభమైంది, ఇది ఇక్కడ మూసివేయబడింది.
 కానీ, నేమ్‌స్పేస్ తెరిచి, మరొక గుర్తును ఉంచానని నేను మళ్ళీ చెప్తున్నాను; అంటే ... కాబట్టి, ఏది జరిగినా అది అదే రాజ్యంలో కలుస్తుంది.
 ఇప్పుడు, ఇది ప్రాథమికంగా చెబుతుంది, నేమ్‌స్పేస్ ఓపెన్‌కు రెండు చిహ్నాలు ఉన్నాయి, x చిహ్నం అలాగే y చిహ్నం.
 కాబట్టి, నేమ్‌స్పేస్ (ఓపెన్) ను ఉపయోగించమని మేము చెబితే, నేను X మరియు Y రెండింటినీ ఉపయోగించవచ్చు మరియు ఒకే నేమ్‌స్పేస్ (నేమ్‌స్పేస్) నుండి, అవి, X ఇక్కడ బంధిస్తాయి మరియు Y ఇక్కడ బంధిస్తాయి.
 కాబట్టి, ఈ నిష్కాపట్యత చాలా సరళమైన ఒక ఆసక్తికరమైన భావన, తద్వారా, మీరు నేమ్‌స్పేస్ యొక్క వివిధ భాగాలను చాలా, వేర్వేరు ఫైళ్ళలో కూడా పేర్కొనవచ్చు.
 ఇది ఆ పోలిక యొక్క సారాంశం, ఎందుకంటే మేము తరగతి భావన గురించి పదేపదే మాట్లాడుతున్నాము మరియు దానిని నేమ్‌స్పేస్‌తో పోల్చాము.
 నేమ్‌స్పేస్ మరియు క్లాస్ మధ్య ప్రతి నేమ్‌స్పేస్ క్లాస్ కాదు, మరియు ప్రతి క్లాస్ నేమ్‌స్పేస్‌ను నిర్వచిస్తుంది.
 ఇది మీకు అదే అర్హత సామర్థ్యాన్ని ఇస్తుంది.
 నేమ్‌స్పేస్‌ను తిరిగి తెరవవచ్చు, కాని మరిన్ని డిక్లరేషన్లలో ఉంచవచ్చు.
 తరగతి పరంగా, ఇలాంటిదేమీ లేదు.
 వాస్తవానికి, నేమ్‌స్పేస్‌ను తక్షణం చేయలేము; క్లాస్ఎస్ వస్తువులకు తక్షణమే పరిగణించబడుతుంది.
 నేమ్‌స్పేస్‌ల కోసం ఒక యంత్రాంగాన్ని ఉపయోగించడం అందుబాటులో ఉంది; ఖచ్చితంగా, ఒక తరగతి కోసం అలా చేయడంలో అర్థం లేదు.
 మరింత ఆసక్తికరంగా, నేమ్‌స్పేస్ అనామకంగా ఉంటుంది; కొన్ని చిహ్నాలను వేరు చేయడానికి మరియు వాటిని కలిసి ఉంచడానికి నేను నేమ్‌స్పేస్ కలిగి ఉంటాను, కానీ వాటిని బాహ్యంగా యాక్సెస్ చేయకూడదు.
 మీకు నేమ్‌స్పేస్ పేర్లు ఎందుకు అవసరమో చూడండి, తద్వారా మీరు బయటి నుండి, డిక్లరేషన్‌లను ఉపయోగించి లేదా నేమ్‌స్పేస్‌ల లోపల నేరుగా చిహ్నాలను ఉపయోగించవచ్చు.
 ఇప్పుడు, నేను కొన్ని చిహ్నాలను దృశ్యమానంగా దాచాలనుకుంటే మరియు వాటితో సంభాషించాలనుకుంటే, నేను వాటిని నేమ్‌స్పేస్‌లో ఉంచగలను మరియు ఆ నేమ్‌స్పేస్‌కు పేరు ఇవ్వలేను.
 నేను ఆ నేమ్‌స్పేస్‌కు పేరు ఇవ్వకపోతే, ఆ నేమ్‌స్పేస్‌కు వెలుపల ఎవరికీ ఆ నేమ్‌స్పేస్‌కు గుర్తు లేదు.
 కాబట్టి, అనామక నేమ్‌స్పేస్‌కు ఒక అర్థం ఉంది; అనామక తరగతి స్పష్టంగా అర్ధం కాదు.
 ఇది అనుమతించబడదు.
 నేను మూసివేసే ముందు, C ++ నిర్వచించే వివిధ లెక్సికల్ తరగతులలో నేమ్‌స్పేస్ ఒకటి అని మీకు గుర్తు చేయాలనుకుంటున్నాను.
 మరియు, ఇవి మీ వద్ద ఉన్న విభిన్న లెక్సికల్ స్కోప్‌లు.
 వ్యక్తీకరణ యొక్క పరిధి అనేది వ్యక్తీకరణ యొక్క వివిధ భాగాలను లెక్కించడానికి తాత్కాలిక వాటిని ఉపయోగిస్తారు మరియు అవి వ్యక్తీకరణలో పరిధిని కలిగి ఉంటాయి.
 చాలా తరచుగా, మేము ఈ తాత్కాలిక విషయాలను చూడలేము.
 కాబట్టి, కంపైలర్ మాత్రమే దీన్ని నిర్వహిస్తుంది.
 అయినప్పటికీ, మేము తరచుగా బ్లాక్ మరియు ఫంక్షన్ స్కోప్‌తో వ్యవహరిస్తున్నాము, ముఖ్యంగా సి లో; మరియు, C లో ఫైల్ మరియు గ్లోబల్ స్కోప్, మరియు, C ++ కి వచ్చిన తరువాత, ఇవి ఉనికిలో ఉన్నాయి మరియు దానికి తోడు మనకు క్లాస్ స్కోప్ మరియు నేమ్‌స్పేస్ స్కోప్ ఉన్నాయి, వీటిని మనం చర్చించాము.
 మీరు గమనించినట్లుగా, స్కోప్‌లకు పేరు పెట్టవచ్చు లేదా అనామకంగా ఉంటుంది; తరగతి పరిధి వలె ఎల్లప్పుడూ పేరు ఉండాలి.
 నేమ్‌స్పేస్ స్కోప్ సాధారణంగా పేరుగా ఉంటుంది, కానీ అనామకంగా కూడా ఉంటుంది.
 గ్లోబల్ స్కోప్‌కు పేరు లేదు, కానీ ఈ స్కోప్‌ను స్కోప్ ఆపరేటర్ గుర్తించవచ్చు.
 వ్యక్తీకరణలు, బ్లాక్ ఫంక్షన్ మరియు ఫైల్ స్కోప్ వంటి ఈ స్కోప్‌లు అవి అనామక పేర్లు కావు.
 ఇంకా, బ్లాక్ స్కోప్, క్లాస్ స్కోప్, నేమ్‌స్పేస్ స్కోప్ వంటి స్కోప్‌లను సమూహపరచవచ్చు; వారు గూడు చేయవచ్చు.
 అయినప్పటికీ, ఫంక్షన్ స్కోప్ లేదా ఎక్స్‌ప్రెషన్ స్కోప్ వంటి కొన్ని స్కోప్‌లు ఉన్నాయి, అవి గూడులో ఉండవు.
 కానీ వాటిలో కొన్ని ఇతర స్కోప్‌లను కలిగి ఉండవచ్చు, కానీ వాటి స్వంతం కాదు.
 కాబట్టి, ఇది సంగ్రహంగా చెప్పాలంటే ఇది చాలా ముఖ్యమైనది, ముఖ్యంగా లెక్సికల్ పరిధిని తెలుసుకోవడం, ఎందుకంటే సి ++ ఒక బలమైన లెక్సికల్ స్కోప్ భాష.
 దీనికి డైనమిక్ స్కోపింగ్ లేదు; అంటే, దీనికి ఎగ్జిక్యూషన్ డిపెండెంట్ నేమ్ బైండింగ్ లేదు.
 ఇది పూర్తి పేరు బైండింగ్, ఇది అనుబంధించేది, ఇది వేరియబుల్ పేరుతో జ్ఞాపకశక్తిని ఎలా అనుబంధిస్తుంది అనేది పూర్తిగా లెక్సికల్ పరిధిపై ఆధారపడి ఉంటుంది, ఇది స్టాటిక్ సమయంపై పూర్తిగా ఆధారపడి ఉంటుంది.
 అందువల్ల, వేరియబుల్ పేర్లను పేర్కొనడం మరియు వాటి దృశ్యమానత మరియు ప్రాప్యతను పరిమితం చేసే ఈ విభిన్న ఎంపికల నుండి, ఇది డిజైన్ స్థితిలో ఉంది మరియు దానిని ఉపయోగించడం చాలా ముఖ్యం.
 మరియు, నేమ్‌స్పేస్ లెక్సికల్ స్కోప్‌ల కిట్టిని విస్తరించడానికి మాత్రమే సహాయపడుతుంది మరియు ప్రత్యేకించి, మీ కోడ్‌ను నిర్వహించడానికి మరియు ప్రత్యేకంగా లైబ్రరీలను యాక్సెస్ చేయడానికి మరియు మీ లైబ్రరీలోని చిహ్నాల నుండి మీ లైబ్రరీని ఇతర మూడవ పార్టీ లైబ్రరీల నుండి వేరు చేయడానికి ఒక శక్తివంతమైన సాధనం. .
 ఉదాహరణకు, మీరు ఇతరులతో పంచుకోవాలనుకునే లైబ్రరీని అభివృద్ధి చేస్తుంటే, ఆ మొత్తం విషయానికి అర్ధవంతమైన నేమ్‌స్పేస్ అని పేరు పెట్టడం మంచిది మరియు నేమ్‌స్పేస్ (నేమ్‌స్పేస్) ఆ మొత్తం అభివృద్ధిని లోపల ఉంచండి, ప్రామాణిక లైబ్రరీ వంటివి std ఉపయోగించి .
 ఆపై దానిని వినియోగదారుకు ఇవ్వండి, తద్వారా మీరు మీ లైబ్రరీలో కొన్ని ఫంక్షన్ పేర్లు లేదా తరగతి పేర్లను ఉపయోగించినట్లు చెప్పలేము, ఇది వినియోగదారు కూడా ఉపయోగించాలనుకుంటుంది, కానీ చేయలేకపోతుంది.
 కాబట్టి, ఇది నేమ్‌స్పేస్‌ల గురించి మరియు మేము ఇక్కడ మూసివేస్తాము.