Exempel 1:
Vi börjar helt enkelt med vårt första exempel här. För att göra C++-koderna behöver vi några rubrikfiler. Så vi inkluderar rubrikfilerna som vi behöver i den här koden. 'iostream'-huvudfilen är viktig eftersom vi i den här koden måste visa vissa data och den här rubrikfilen stöder 'cout'-funktionen. Sedan har vi 'cstdlib'; denna rubrik tillhandahåller en uppsättning metoder som 'getenv()'-metoden.
Nu lägger vi till 'namespace std' så att vi inte behöver lägga till 'std' med 'cout()'-funktionerna i vår kod. Efter detta anropas funktionen 'main()'. Sedan placerar vi 'char*' som är en pekare här med namnet 'var_1'. Sedan, i denna 'var_1'-variabel, placerar vi 'getenv()'-funktionen och skickar 'SESSIONNAME' som parameter.
Efter detta lägger vi till ett 'if'-villkor som kontrollerar om 'var_1' inte är lika med 'NULL'. Om 'var_1' inte är null, skrivs miljövariabelns namn först. Sedan, på nästa rad, skriver den ut värdet på den variabeln. Men om 'var_1' är 'NULL', kommer det inte att visa något meddelande där och koden avslutas.
Kod 1:
#include
#include
använder sig av namnutrymme std ;
int huvud ( )
{
röding * var_1 ;
var_1 = gettenv ( 'SESSIONNAME' ) ;
om ( var_1 ! = NULL )
cout << 'Variabelnamnet är SESSIONNAME' << endl ;
cout << 'Miljövariabeln är:' << var_1 ;
lämna tillbaka 0 ;
}
Produktion :
Denna utdata återger namnet på miljövariabeln som vi lägger till som parameter för funktionen 'getenv()' och värdet på denna miljövariabel. Vi får detta värde med hjälp av 'getenv()'-funktionen i vår kod.
Exempel 2:
Nu har vi ett annat exempel. Vi startar vår kod genom att inkludera de nödvändiga rubrikfilerna. Sedan skriver vi 'namespace std'. Efter detta kommer vi åt funktionen 'main()' där vi skapar en 'char*'-pekare med namnet 'newEnv_var' och initierar den med miljövariabelns 'Path'-namn. Sedan lägger vi till ytterligare en 'char*' som också är en pekare här och ger den namnet 'myValue'.
Nu initierar vi variabeln 'myValue' med funktionen 'getenv()' och skickar 'newEnv_var' till denna 'getenv()'-funktion; det är parametern för denna funktion. Denna 'newEnv_var'-variabel innehåller namnet på miljövariabeln när vi initierar den med 'PATH'. Därefter läggs ett 'om'-villkor till för att avgöra om 'myValue' är ekvivalent med 'NULL' eller inte. Om 'myValue' inte är null, skrivs miljövariabelns namn ut först, följt av variabelns värde på nästa rad. Men om 'myValue' är inställt på 'NULL', visas inget meddelande och koden slutar här.
Kod 2:
#include#include
använder sig av namnutrymme std ;
int huvud ( )
{
röding * newEnv_var = 'VÄG' ;
röding * mitt värde ;
mitt värde = gettenv ( newEnv_var ) ;
om ( mitt värde ! = NULL ) {
cout << 'Variabeln = ' << newEnv_var << endl ;
cout << 'Värdet = ' << mitt värde << endl ;
}
annan
cout << 'Variabel finns inte!' << mitt värde ;
lämna tillbaka 0 ;
}
Produktion:
Nu, på terminalen, visar den värdet på miljövariabeln 'PATH' som vi får med funktionen 'getenv()' i vår kod. Det skiljer sig på varje dator eftersom sökvägen på varje dator är olika.
Exempel 3:
Här är ett annat exempel: vi skriver 'namespace std' i början av vår kod efter att ha införlivat de nödvändiga 'iostream'- och 'cstdlib'-huvudfilerna. Därefter anger vi metoden 'main()' där vi genererar en 'char*'-pekare som heter 'myVar' och initierar miljövariabelns namn 'PUBLIC'.
Därefter skapar vi en ny 'char*' som heter 'myValue'; den här är också en pekare. Nu när 'myVar' levereras till 'getenv()'-funktionen, med vilken vi initierar variabeln 'myValue', är det ett funktionsargument. Eftersom vi initierar den med 'PUBLIC', finns miljövariabelns namn i denna 'myVar'-variabel.
Sedan, för att kontrollera om 'myValue' är lika med 'NULL' eller inte, läggs ett 'if'-villkor till. Miljövariabelns namn visas först på skärmen om 'myValue' inte är null, och variabelns värde visas på nästa rad. Sedan har vi lagt till den andra delen här som körs om det givna villkoret inte är uppfyllt. Här skriver vi ut ett meddelande som talar om för oss att 'variabeln finns inte här'.
Kod 3:
#include#include
använder sig av namnutrymme std ;
int huvud ( )
{
röding * myVar = 'OFFENTLIG' ;
röding * mitt värde ;
mitt värde = gettenv ( myVar ) ;
om ( mitt värde ! = NULL ) {
cout << 'Variabeln = ' << myVar << endl ;
cout << 'Det är värde = ' << mitt värde << endl ;
}
annan
cout << 'Det finns ingen variabel här..!!' << mitt värde ;
lämna tillbaka 0 ;
}
Produktion:
Namnet på miljövariabeln som vi lägger till som en parameter till 'getenv()'-funktionen, tillsammans med dess värde, återges i denna utdata. Vi kan få detta värde med hjälp av vår kods 'getenv()'-funktion.
Exempel 4:
Vi skapar en konstant char-array med namnet 'NewEnv_var[]' här med storleken '6'. Sedan skickar vi alla möjliga miljövariabler till denna array. Under detta har vi en annan array som heter 'char *env_value[]' med samma storlek på '6'. Nu har vi en 'for'-loop och vi loopar alla dessa miljövariabler från 'getenv()'-funktionen för att få värdena för alla dessa variabler och lagra dem i 'env_value'-matrisen. Inuti denna 'för'-loop placerar vi också ett 'om'-villkor som kontrollerar om miljövärdet är null. Om värdet inte är null skrivs värdet och variabelnamnet ut. Om den är null visar den ett meddelande om att miljövariabeln inte finns här.
Kod 4:
#include#include
använder sig av namnutrymme std ;
int huvud ( )
{
konst röding * NewEnv_var [ 6 ] = { 'OFFENTLIG' , 'HEM' , 'SESSIONNAME' , 'LIB' , 'SystemDrive' , 'DELTREE' } ;
röding * env_värde [ 6 ] ;
för ( int a = 1 ; a <= 6 ; a ++ )
{
env_värde [ a ] = gettenv ( NewEnv_var [ a ] ) ;
om ( env_värde [ a ] ! = NULL )
cout << 'Variabeln är' << NewEnv_var [ a ] << ', och det är 'Värde = ' << env_värde [ a ] << endl ;
annan
cout << NewEnv_var [ a ] << 'finns inte här' << endl ;
}
}
Produktion:
Här visar den alla möjliga värden för miljövariabeln och visar även meddelandet att 'HOME', 'LIB' och 'DELTREE' inte existerar vilket betyder att deras värde är NULL.
Exempel 5:
Nu, låt oss framåt. Detta är det sista exemplet på denna handledning. Här etablerar vi en konstant char-array med storleken '4' som kallas 'Variable[]' till vilken vi tillhandahåller alla potentiella miljövariabler. Vi använder nu en 'för'-loop. Under detta finns en annan array med samma storlek på '4' som kallas 'char *values[]' och vi placerar 'getenv()'-funktionen där och skickar 'variabeln[i]' som parameter. Denna loop används för att iterera över alla miljövariabler, hämta deras värden från 'getenv()'-funktionen och spara dem i 'values[]'-matrisen.
Vi inkluderar villkoret 'om' i denna 'för'-loop som avgör om miljövärdet är null eller inte. Värdet och variabelnamnet skrivs ut om värdet inte är null, och ett meddelande visas om det är NULL som anges i 'annat'-delen.
Kod 5:
#includeanvänder sig av namnutrymme std ;
int huvud ( ) {
konst röding * variabel [ 4 ] = { 'OFFENTLIG' , 'HEM' , 'DELTREE' , 'LOGNAME' } ;
för ( int i = 0 ; i <= 4 ; i ++ )
{
konst röding * värden = gettenv ( variabel [ i ] ) ;
om ( värden ! = NULL ) {
cout << variabel [ i ] << ' = ' << värden << endl ;
}
annan {
cout << variabel [ i ] << 'finns inte här!' << endl ;
}
}
lämna tillbaka 0 ;
}
Produktion:
I det här fallet visas miljövariabelns möjliga värden tillsammans med meddelandet om att värdena för 'HOME', 'DELTREE' och 'LONGNAME' inte finns här, vilket betyder att de är NULL-värden.
Slutsats
Denna handledning handlar om 'hur man kommer åt miljön i C++'. Vi utforskade exemplen där vi lärde oss att komma åt miljövariabeln individuellt eller med hjälp av arrayen där vi skickar alla möjliga miljövariabler och sedan hämtar värdena genom att använda 'getenv()'-funktionen. Denna 'getenv()'-metod tillhandahålls av C++-språket för att få de nödvändiga miljövariabelvärdena.