ఉదాహరణ 1:
మేము ఇక్కడ మా మొదటి ఉదాహరణతో ప్రారంభిస్తాము. C++ కోడ్‌లను చేయడానికి, మనకు కొన్ని హెడర్ ఫైల్‌లు అవసరం. కాబట్టి, ఈ కోడ్‌లో మనకు అవసరమైన హెడర్ ఫైల్‌లను చేర్చుతాము. “iostream” హెడర్ ఫైల్ అవసరం ఎందుకంటే, ఈ కోడ్‌లో, మనం కొంత డేటాను ప్రదర్శించాలి మరియు ఈ హెడర్ ఫైల్ “cout” ఫంక్షన్‌కు మద్దతు ఇస్తుంది. అప్పుడు, మనకు “cstdlib” ఉంది; ఈ హెడర్ “getenv()” పద్ధతి వంటి పద్ధతుల సమితిని అందిస్తుంది.
ఇప్పుడు, మేము 'namespace std'ని జోడిస్తాము కాబట్టి మన కోడ్‌లోని 'cout()' ఫంక్షన్‌లతో 'std'ని జోడించాల్సిన అవసరం లేదు. దీని తరువాత, 'ప్రధాన ()' ఫంక్షన్ అంటారు. అప్పుడు, మేము ఇక్కడ “var_1” పేరుతో పాయింటర్ అయిన “char*”ని ఉంచుతాము. అప్పుడు, ఈ “var_1” వేరియబుల్‌లో, మేము “getenv()” ఫంక్షన్‌ని ఉంచుతాము మరియు “SESSIONNAME”ని దాని పరామితిగా పాస్ చేస్తాము.
దీని తర్వాత, 'var_1' 'NULL'కి సమానం కాదా అని తనిఖీ చేసే 'if' షరతును మేము జోడిస్తాము. “var_1” శూన్యం కాకపోతే, అది ముందుగా ఎన్విరాన్మెంట్ వేరియబుల్ పేరును ప్రింట్ చేస్తుంది. తరువాత, తదుపరి పంక్తిలో, అది వేరియబుల్ విలువను ముద్రిస్తుంది. కానీ “var_1” “NULL” అయితే, అది అక్కడ ఎలాంటి సందేశాన్ని ప్రదర్శించదు మరియు కోడ్ ముగుస్తుంది.
కోడ్ 1:
#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
చార్ * ఉంది_1 ;
ఉంది_1 = గెట్టెన్వ్ ( 'SESSIONNAME' ) ;
ఉంటే ( ఉంది_1 ! = శూన్య )
కోట్ << 'వేరియబుల్ పేరు SESSIONNAME' << endl ;
కోట్ << 'పర్యావరణ వేరియబుల్:' << ఉంది_1 ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
ఈ అవుట్‌పుట్ “getenv()” ఫంక్షన్ యొక్క పారామీటర్‌గా మరియు ఈ ఎన్విరాన్మెంట్ వేరియబుల్ విలువగా మనం జోడించే ఎన్విరాన్మెంట్ వేరియబుల్ పేరును రెండర్ చేస్తుంది. మన కోడ్‌లోని “getenv()” ఫంక్షన్ సహాయంతో మేము ఈ విలువను పొందుతాము.
ఉదాహరణ 2:
ఇప్పుడు, మనకు మరొక ఉదాహరణ ఉంది. అవసరమైన హెడర్ ఫైల్‌లను చేర్చడం ద్వారా మేము మా కోడ్‌ను ప్రారంభిస్తాము. అప్పుడు, మేము 'namespace std' అని టైప్ చేస్తాము. దీని తర్వాత, మేము “main()” ఫంక్షన్‌ని యాక్సెస్ చేస్తాము, దీనిలో మేము “char* ” పాయింటర్‌ను “newEnv_var” పేరుతో సృష్టిస్తాము మరియు దానిని “పాత్” ఎన్విరాన్మెంట్ వేరియబుల్ పేరుతో ప్రారంభించాము. అప్పుడు, మేము ఇక్కడ పాయింటర్ అయిన మరొక “char* ”ని జోడిస్తాము మరియు దానికి “myValue” అని పేరు పెట్టాము.
ఇప్పుడు, మేము “getenv()” ఫంక్షన్‌తో “myValue” వేరియబుల్‌ని ప్రారంభించాము మరియు “newEnv_var”ని ఈ “getenv()” ఫంక్షన్‌కి పాస్ చేస్తాము; ఇది ఈ ఫంక్షన్ యొక్క పరామితి. ఈ “newEnv_var” వేరియబుల్ మనం “PATH”తో ప్రారంభించినప్పుడు పర్యావరణ వేరియబుల్ పేరును కలిగి ఉంటుంది. తర్వాత, “myValue” “NULL”కి సమానమైనదో కాదో నిర్ధారించడానికి “if” షరతు జోడించబడుతుంది. “myValue” శూన్యం కాకపోతే, ఎన్విరాన్మెంట్ వేరియబుల్ పేరు ముందుగా ముద్రించబడుతుంది, దాని తర్వాత వేరియబుల్ విలువ తదుపరి లైన్‌లో ముద్రించబడుతుంది. అయినప్పటికీ, 'myValue'ని 'NULL'కి సెట్ చేస్తే, సందేశం ప్రదర్శించబడదు మరియు కోడ్ ఇక్కడ ముగుస్తుంది.
కోడ్ 2:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
చార్ * కొత్తEnv_var = 'మార్గం' ;
చార్ * నా విలువ ;
నా విలువ = గెట్టెన్వ్ ( కొత్తEnv_var ) ;
ఉంటే ( నా విలువ ! = శూన్య ) {
కోట్ << 'వేరియబుల్ =' << కొత్తEnv_var << endl ;
కోట్ << 'విలువ =' << నా విలువ << endl ;
}
లేకపోతే
కోట్ << 'వేరియబుల్ ఉనికిలో లేదు!' << నా విలువ ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇప్పుడు, టెర్మినల్‌లో, ఇది మన కోడ్‌లోని “getenv()” ఫంక్షన్‌ని ఉపయోగించే “PATH” ఎన్విరాన్మెంట్ వేరియబుల్ విలువను చూపుతుంది. ప్రతి కంప్యూటర్‌లోని మార్గం భిన్నంగా ఉంటుంది కాబట్టి ఇది ప్రతి కంప్యూటర్‌లో భిన్నంగా ఉంటుంది.
ఉదాహరణ 3:
ఇక్కడ మరొక ఉదాహరణ: అవసరమైన 'iostream' మరియు 'cstdlib' హెడర్ ఫైల్‌లను చేర్చిన తర్వాత మేము మా కోడ్ ప్రారంభంలో 'namespace std' అని టైప్ చేస్తాము. తరువాత, మేము 'myVar' అని పిలవబడే 'char*' పాయింటర్‌ను రూపొందించే 'ప్రధాన()' పద్ధతిని నమోదు చేస్తాము మరియు 'పబ్లిక్' ఎన్విరాన్మెంట్ వేరియబుల్ పేరును ప్రారంభించాము.
తరువాత, మేము 'myValue' అనే కొత్త 'char*'ని సృష్టిస్తాము; ఇది కూడా ఒక పాయింటర్. ఇప్పుడు “myVar” “getenv()” ఫంక్షన్‌కు సరఫరా చేయబడింది, దానితో మనం “myValue” వేరియబుల్‌ని ప్రారంభించాము, ఇది ఒక ఫంక్షన్ ఆర్గ్యుమెంట్. మేము దీనిని 'పబ్లిక్'తో ప్రారంభించినందున, పర్యావరణ వేరియబుల్ పేరు ఈ 'myVar' వేరియబుల్‌లో ఉంటుంది.
అప్పుడు, “myValue” “NULL”కి సమానం కాదా అని నిర్ధారించడానికి, “if” షరతు జోడించబడుతుంది. “myValue” శూన్యం కాకపోతే ఎన్విరాన్మెంట్ వేరియబుల్ పేరు మొదట స్క్రీన్‌పై కనిపిస్తుంది మరియు వేరియబుల్ విలువ తదుపరి లైన్‌లో కనిపిస్తుంది. ఆపై, ఇచ్చిన షరతు సంతృప్తి చెందకపోతే అమలు చేసే ఇతర భాగాన్ని ఇక్కడ జోడించాము. ఇక్కడ, 'వేరియబుల్ ఇక్కడ కనుగొనబడలేదు' అని చెప్పే సందేశాన్ని మేము ప్రింట్ చేస్తాము.
కోడ్ 3:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
చార్ * myVar = 'ప్రజా' ;
చార్ * నా విలువ ;
నా విలువ = గెట్టెన్వ్ ( myVar ) ;
ఉంటే ( నా విలువ ! = శూన్య ) {
కోట్ << 'ది వేరియబుల్ =' << myVar << endl ;
కోట్ << 'ఇది విలువ =' << నా విలువ << endl ;
}
లేకపోతే
కోట్ << 'వేరియబుల్ ఇక్కడ దొరకలేదు..!!' << నా విలువ ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
“getenv()” ఫంక్షన్‌కి మనం పారామీటర్‌గా జోడించే ఎన్విరాన్మెంట్ వేరియబుల్ పేరు, దాని విలువతో కలిపి, ఈ అవుట్‌పుట్‌లో రెండర్ చేయబడుతుంది. మన కోడ్ యొక్క “getenv()” ఫంక్షన్‌ని ఉపయోగించి మనం ఈ విలువను పొందవచ్చు.
ఉదాహరణ 4:
మేము ఇక్కడ “6” పరిమాణంతో “NewEnv_var[]” అనే స్థిరమైన చార్ శ్రేణిని సృష్టిస్తాము. అప్పుడు, మేము ఈ శ్రేణికి సాధ్యమయ్యే అన్ని ఎన్విరాన్మెంట్ వేరియబుల్స్‌ను పాస్ చేస్తాము. దీని క్రింద, 'char *env_value[]' అనే పేరు గల మరో శ్రేణిని '6' పరిమాణంతో కలిగి ఉన్నాము. ఇప్పుడు, మనకు “ఫర్” లూప్ ఉంది మరియు ఈ అన్ని వేరియబుల్స్ యొక్క విలువలను పొందడానికి మరియు వాటిని “env_value” శ్రేణిలో నిల్వ చేయడానికి “getenv()” ఫంక్షన్ నుండి ఈ ఎన్విరాన్మెంట్ వేరియబుల్స్ అన్నింటినీ లూప్ చేస్తాము. ఈ 'ఫర్' లూప్ లోపల, పర్యావరణ విలువ శూన్యంగా ఉందో లేదో తనిఖీ చేసే 'if' షరతును కూడా ఉంచుతాము. విలువ శూన్యం కాకపోతే, అది విలువ మరియు వేరియబుల్ పేరును ముద్రిస్తుంది. అది శూన్యంగా ఉంటే, పర్యావరణ వేరియబుల్ ఇక్కడ లేదని సందేశాన్ని చూపుతుంది.
కోడ్ 4:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
స్థిరంగా చార్ * NewEnv_var [ 6 ] = { 'ప్రజా' , 'హోమ్' , 'SESSIONNAME' , 'LIB' , 'సిస్టమ్ డ్రైవ్' , 'డెల్ట్రీ' } ;
చార్ * env_value [ 6 ] ;
కోసం ( int a = 1 ; a <= 6 ; a ++ )
{
env_value [ a ] = గెట్టెన్వ్ ( NewEnv_var [ a ] ) ;
ఉంటే ( env_value [ a ] ! = శూన్య )
కోట్ << 'వేరియబుల్' << NewEnv_var [ a ] << ', మరియు అది 'విలువ=' << env_value [ a ] << endl ;
లేకపోతే
కోట్ << NewEnv_var [ a ] << 'ఇక్కడ లేదు' << endl ;
}
}
అవుట్‌పుట్:
ఇక్కడ, ఇది ఎన్విరాన్మెంట్ వేరియబుల్ యొక్క సాధ్యమయ్యే అన్ని విలువలను చూపుతుంది మరియు 'హోమ్', 'LIB' మరియు 'DELTREE' ఉనికిలో లేవనే సందేశాన్ని కూడా చూపుతుంది అంటే వాటి విలువ NULL అని అర్థం.
ఉదాహరణ 5:
ఇప్పుడు, ముందుకు వెళ్దాం. ఇది ఈ ట్యుటోరియల్ యొక్క చివరి ఉదాహరణ. ఇక్కడ, మేము 'వేరియబుల్[]' అని పిలువబడే '4' పరిమాణం యొక్క స్థిరమైన చార్ శ్రేణిని ఏర్పాటు చేస్తాము, దీనికి మేము అన్ని సంభావ్య పర్యావరణ వేరియబుల్‌లను అందిస్తాము. మేము ఇప్పుడు 'కోసం' లూప్‌ని ఉపయోగిస్తాము. దీని క్రింద, 'char *values[]' అని పిలవబడే '4' పరిమాణంతో మరొక శ్రేణి ఉంది మరియు మేము అక్కడ 'getenv()' ఫంక్షన్‌ను ఉంచాము మరియు దాని పరామితిగా 'వేరియబుల్[i]'ని పాస్ చేస్తాము. ఈ లూప్ అన్ని ఎన్విరాన్మెంట్ వేరియబుల్స్‌పై మళ్ళించడానికి ఉపయోగించబడుతుంది, వాటి విలువలను “getenv()” ఫంక్షన్ నుండి తిరిగి పొందడం మరియు వాటిని “విలువలు[]” శ్రేణిలో సేవ్ చేయడం.
పర్యావరణ విలువ శూన్యం కాదా అని నిర్ణయించే ఈ 'ఫర్' లూప్‌లో మేము 'if' షరతును చేర్చుతాము. విలువ శూన్యం కానట్లయితే విలువ మరియు వేరియబుల్ పేరు ముద్రించబడతాయి మరియు 'else' భాగంలో అందించబడిన NULL అయితే ఒక సందేశం ప్రదర్శించబడుతుంది.
కోడ్ 5:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
స్థిరంగా చార్ * వేరియబుల్ [ 4 ] = { 'ప్రజా' , 'హోమ్' , 'డెల్ట్రీ' , 'LOGNAME' } ;
కోసం ( int i = 0 ; i <= 4 ; i ++ )
{
స్థిరంగా చార్ * విలువలు = గెట్టెన్వ్ ( వేరియబుల్ [ i ] ) ;
ఉంటే ( విలువలు ! = శూన్య ) {
కోట్ << వేరియబుల్ [ i ] << ' = ' << విలువలు << endl ;
}
లేకపోతే {
కోట్ << వేరియబుల్ [ i ] << 'ఇక్కడ దొరకలేదు!' << endl ;
}
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ సందర్భంలో, ఎన్విరాన్మెంట్ వేరియబుల్ యొక్క సాధ్యమైన విలువలు 'హోమ్', 'డెల్ట్రీ' మరియు 'LONGNAME' విలువలు ఇక్కడ కనుగొనబడలేదు అంటే అవి శూన్య విలువలు అని నోటిఫికేషన్‌తో పాటు ప్రదర్శించబడతాయి.
ముగింపు
ఈ ట్యుటోరియల్ అంతా “C++లో పర్యావరణాన్ని ఎలా యాక్సెస్ చేయాలి”. పర్యావరణం వేరియబుల్‌ను వ్యక్తిగతంగా ఎలా యాక్సెస్ చేయాలో లేదా సాధ్యమయ్యే అన్ని ఎన్విరాన్మెంట్ వేరియబుల్స్‌ను పాస్ చేసే శ్రేణిని ఉపయోగించి, ఆపై “getenv()” ఫంక్షన్‌ని ఉపయోగించడం ద్వారా విలువలను ఎలా పొందాలో నేర్చుకున్న ఉదాహరణలను మేము అన్వేషించాము. ఈ “getenv()” పద్ధతి అవసరమైన పర్యావరణ వేరియబుల్ విలువలను పొందడానికి C++ భాష ద్వారా అందించబడుతుంది.