Voorbeeld 1:
We beginnen eenvoudigweg met ons eerste voorbeeld hier. Om de C++-codes uit te voeren, hebben we enkele headerbestanden nodig. We nemen dus de headerbestanden op die we nodig hebben in deze code. Het headerbestand “iostream” is essentieel omdat we in deze code enkele gegevens moeten weergeven en dit headerbestand de functie “cout” ondersteunt. Dan hebben we “cstdlib”; deze header biedt een reeks methoden zoals de “getenv()” -methode.
Nu voegen we de “namespace std” toe, zodat we “std” niet hoeven toe te voegen met de “cout()” -functies in onze code. Hierna wordt de functie “main()” aangeroepen. Vervolgens plaatsen we “char*”, wat hier een pointer is met de naam “var_1”. Vervolgens plaatsen we in deze variabele “var_1” de functie “getenv()” en geven we de “SESSIONNAME” door als parameter.
Hierna voegen we een “if” voorwaarde toe die controleert of de “var_1” niet gelijk is aan “NULL”. Als “var_1” niet nul is, wordt eerst de naam van de omgevingsvariabele afgedrukt. Vervolgens wordt op de volgende regel de waarde van die variabele afgedrukt. Maar als “var_1” “NULL” is, wordt daar geen bericht weergegeven en wordt de code beëindigd.
Code1:
#include
#include
gebruik makend van naamruimte soa ;
int voornaamst ( )
{
verkoold * was_1 ;
was_1 = getenv ( 'SESSIENAAM' ) ;
als ( was_1 ! = NUL )
uit << 'De variabelenaam is SESSIONNAME' << eindl ;
uit << 'De omgevingsvariabele is: ' << was_1 ;
opbrengst 0 ;
}
Uitvoer :
Deze uitvoer geeft de naam weer van de omgevingsvariabele die we toevoegen als de parameter van de functie “getenv()” en de waarde van deze omgevingsvariabele. We krijgen deze waarde met behulp van de functie “getenv()” in onze code.
Voorbeeld 2:
Nu hebben we nog een voorbeeld. We beginnen onze code met het opnemen van de benodigde headerbestanden. Vervolgens typen we “namespace std”. Hierna hebben we toegang tot de functie “main()” waarin we een “char*”-aanwijzer maken met de naam “newEnv_var” en deze initialiseren met de naam van de omgevingsvariabele “Path”. Vervolgens voegen we nog een “char*” toe, die hier ook een aanwijzer is, en noemen deze “myValue”.
Nu initialiseren we de variabele “myValue” met de functie “getenv()” en geven we de “newEnv_var” door aan deze functie “getenv()”; het is de parameter van deze functie. Deze “newEnv_var” variabele bevat de naam van de omgevingsvariabele zoals we deze initialiseren met “PATH”. Vervolgens wordt een “if”-voorwaarde toegevoegd om te bepalen of “myValue” gelijk is aan “NULL” of niet. Als “myValue” niet nul is, wordt de naam van de omgevingsvariabele eerst afgedrukt, gevolgd door de waarde van de variabele op de volgende regel. Als “myValue” echter is ingesteld op “NULL”, wordt er geen bericht weergegeven en eindigt de code hier.
Code2:
#include#include
gebruik makend van naamruimte soa ;
int voornaamst ( )
{
verkoold * nieuweEnv_var = 'PAD' ;
verkoold * mijnWaarde ;
mijnWaarde = getenv ( nieuweEnv_var ) ;
als ( mijnWaarde ! = NUL ) {
uit << 'De variabele = ' << nieuweEnv_var << eindl ;
uit << 'De waarde = ' << mijnWaarde << eindl ;
}
anders
uit << 'Variabele bestaat niet!' << mijnWaarde ;
opbrengst 0 ;
}
Uitgang:
Nu toont het op de terminal de waarde van de omgevingsvariabele 'PATH' die we krijgen met behulp van de functie 'getenv()' in onze code. Het verschilt op elke computer, omdat het pad op elke computer anders is.
Voorbeeld 3:
Hier is nog een voorbeeld: we typen “namespace std” aan het begin van onze code nadat we de vereiste “iostream” en “cstdlib” headerbestanden hebben opgenomen. Vervolgens voeren we de “main()”-methode in, waarbij we een “char*”-aanwijzer genereren met de naam “myVar” en de naam van de “PUBLIC”-omgevingsvariabele initialiseren.
Vervolgens maken we een nieuwe “char*” genaamd “myValue”; deze is ook een aanwijzer. Nu “myVar” wordt opgegeven aan de functie “getenv()”, waarmee we de variabele “myValue” initialiseren, is het een functieargument. Omdat we het initialiseren met “PUBLIC”, is de naam van de omgevingsvariabele opgenomen in deze “myVar” -variabele.
Om vervolgens vast te stellen of “myValue” gelijk is aan “NULL” of niet, wordt een “if”-voorwaarde toegevoegd. De naam van de omgevingsvariabele verschijnt als eerste op het scherm als “myValue” niet nul is, en de waarde van de variabele verschijnt op de volgende regel. Vervolgens hebben we hier het andere deel toegevoegd dat wordt uitgevoerd als niet aan de gegeven voorwaarde wordt voldaan. Hier drukken we een bericht af dat ons vertelt dat de 'Variabele hier niet gevonden' is.
Code 3:
#include#include
gebruik makend van naamruimte soa ;
int voornaamst ( )
{
verkoold * mijnVar = 'OPENBAAR' ;
verkoold * mijnWaarde ;
mijnWaarde = getenv ( mijnVar ) ;
als ( mijnWaarde ! = NUL ) {
uit << 'De variabele = ' << mijnVar << eindl ;
uit << 'Het is Waarde=' << mijnWaarde << eindl ;
}
anders
uit << 'Variabele hier niet gevonden..!!' << mijnWaarde ;
opbrengst 0 ;
}
Uitgang:
De naam van de omgevingsvariabele die we als parameter aan de functie “getenv()” toevoegen, samen met de waarde ervan, wordt in deze uitvoer weergegeven. We kunnen deze waarde verkrijgen met behulp van de functie “getenv()” van onze code.
Voorbeeld 4:
We creëren hier een constante char-array met de naam “NewEnv_var[]” met de grootte van “6”. Vervolgens geven we alle mogelijke omgevingsvariabelen door aan deze array. Hieronder hebben we nog een array met de naam “char *env_value[]” met dezelfde grootte van “6”. Nu hebben we een “for”-lus en we herhalen al deze omgevingsvariabelen van de functie “getenv()” om de waarden van al deze variabelen te verkrijgen en deze op te slaan in de array “env_value”. Binnen deze ‘for’-lus plaatsen we ook een ‘if’-voorwaarde die controleert of de omgevingswaarde nul is. Als de waarde niet nul is, worden de waarde en de naam van de variabele afgedrukt. Als deze nul is, wordt er een bericht weergegeven dat de omgevingsvariabele hier niet bestaat.
Code 4:
#include#include
gebruik makend van naamruimte soa ;
int voornaamst ( )
{
const verkoold * NieuweEnv_var [ 6 ] = { 'OPENBAAR' , 'THUIS' , 'SESSIENAAM' , 'LIB' , 'Systeemschijf' , 'DELTREE' } ;
verkoold * env_waarde [ 6 ] ;
voor ( int A = 1 ; A <= 6 ; A ++ )
{
env_waarde [ A ] = getenv ( NieuweEnv_var [ A ] ) ;
als ( env_waarde [ A ] ! = NUL )
uit << 'De variabele is' << NieuweEnv_var [ A ] << ', en het is 'Waarde= ' << env_waarde [ A ] << eindl ;
anders
uit << NieuweEnv_var [ A ] << 'bestaat hier niet' << eindl ;
}
}
Uitgang:
Hier worden alle mogelijke waarden van de omgevingsvariabele weergegeven en wordt ook het bericht weergegeven dat “HOME”, “LIB” en “DELTREE” niet bestaan, wat betekent dat hun waarde NULL is.
Voorbeeld 5:
Laten we nu verder gaan. Dit is het laatste voorbeeld van deze tutorial. Hier stellen we een constante char-array van grootte “4” op, genaamd “Variabele []”, waaraan we alle potentiële omgevingsvariabelen leveren. We gebruiken nu een “for”-lus. Daaronder is er nog een array met dezelfde grootte van '4' genaamd 'char *values[]' en we plaatsen daar de functie 'getenv()' en geven de 'variabele[i]' door als parameter. Deze lus wordt gebruikt om alle omgevingsvariabelen te herhalen, hun waarden op te halen uit de functie “getenv()” en ze op te slaan in de array “values[]”.
We nemen de ‘if’-voorwaarde op in deze ‘for’-lus die bepaalt of de omgevingswaarde null is of niet. De waarde en de naam van de variabele worden afgedrukt als de waarde niet null is, en er wordt een bericht weergegeven als deze NULL is, zoals vermeld in het gedeelte 'else'.
Code 5:
#includegebruik makend van naamruimte soa ;
int voornaamst ( ) {
const verkoold * variabel [ 4 ] = { 'OPENBAAR' , 'THUIS' , 'DELTREE' , 'LOGNAAM' } ;
voor ( int i = 0 ; i <= 4 ; i ++ )
{
const verkoold * waarden = getenv ( variabel [ i ] ) ;
als ( waarden ! = NUL ) {
uit << variabel [ i ] << ' = ' << waarden << eindl ;
}
anders {
uit << variabel [ i ] << 'hier niet gevonden!' << eindl ;
}
}
opbrengst 0 ;
}
Uitgang:
In dit geval worden de mogelijke waarden van de omgevingsvariabele weergegeven samen met de melding dat de waarden van “HOME”, “DELTREE” en “LONGNAME” hier niet worden gevonden, wat betekent dat het NULL-waarden zijn.
Conclusie
Deze tutorial gaat helemaal over “hoe je toegang krijgt tot de omgeving in C++”. We hebben de voorbeelden onderzocht waarin we hebben geleerd hoe we individueel toegang kunnen krijgen tot de omgevingsvariabele of door de array te gebruiken waarin we alle mogelijke omgevingsvariabelen doorgeven en vervolgens de waarden verkrijgen door de functie 'getenv()' te gebruiken. Deze “getenv()”-methode wordt geleverd door de C++-taal om de vereiste waarden voor omgevingsvariabelen te verkrijgen.