Beispiel 1:
Wir beginnen hier einfach mit unserem ersten Beispiel. Um die C++-Codes zu erstellen, benötigen wir einige Header-Dateien. Daher fügen wir die benötigten Header-Dateien in diesen Code ein. Die Header-Datei „iostream“ ist wichtig, da wir in diesem Code einige Daten anzeigen müssen und diese Header-Datei die Funktion „cout“ unterstützt. Dann haben wir „cstdlib“; Dieser Header stellt eine Reihe von Methoden wie die Methode „getenv()“ bereit.
Jetzt fügen wir den „Namespace std“ hinzu, damit wir „std“ nicht mit den „cout()“-Funktionen in unserem Code hinzufügen müssen. Anschließend wird die Funktion „main()“ aufgerufen. Dann platzieren wir „char*“, was hier ein Zeiger mit dem Namen „var_1“ ist. Dann platzieren wir in dieser Variablen „var_1“ die Funktion „getenv()“ und übergeben den „SESSIONNAME“ als Parameter.
Danach fügen wir eine „if“-Bedingung hinzu, die prüft, ob „var_1“ nicht gleich „NULL“ ist. Wenn „var_1“ nicht null ist, wird zuerst der Name der Umgebungsvariablen ausgegeben. Dann gibt es in der nächsten Zeile den Wert dieser Variablen aus. Wenn „var_1“ jedoch „NULL“ ist, wird dort keine Meldung angezeigt und der Code wird beendet.
Code 1:
#include
#include
verwenden Namensraum std ;
int hauptsächlich ( )
{
verkohlen * war_1 ;
war_1 = gettenv ( „SITZUNGSNAME“ ) ;
Wenn ( war_1 ! = NULL )
cout << „Der Variablenname ist SESSIONNAME“ << endl ;
cout << „Die Umgebungsvariable ist:“ << war_1 ;
zurückkehren 0 ;
}
Ausgabe :
Diese Ausgabe gibt den Namen der Umgebungsvariablen, die wir als Parameter der Funktion „getenv()“ hinzufügen, und den Wert dieser Umgebungsvariablen wieder. Diesen Wert erhalten wir mit Hilfe der Funktion „getenv()“ in unserem Code.
Beispiel 2:
Jetzt haben wir ein weiteres Beispiel. Wir beginnen unseren Code mit der Einbindung der notwendigen Header-Dateien. Dann geben wir „namespace std“ ein. Danach greifen wir auf die Funktion „main()“ zu, in der wir einen „char*“-Zeiger mit dem Namen „newEnv_var“ erstellen und ihn mit dem Namen der Umgebungsvariablen „Path“ initialisieren. Dann fügen wir ein weiteres „char*“ hinzu, das hier auch ein Zeiger ist, und nennen es „myValue“.
Nun initialisieren wir die Variable „myValue“ mit der Funktion „getenv()“ und übergeben die „newEnv_var“ an diese Funktion „getenv()“; es ist der Parameter dieser Funktion. Diese „newEnv_var“-Variable enthält den Namen der Umgebungsvariablen, wie wir sie mit „PATH“ initialisieren. Als nächstes wird eine „if“-Bedingung hinzugefügt, um zu bestimmen, ob „myValue“ äquivalent zu „NULL“ ist oder nicht. Wenn „myValue“ nicht null ist, wird zuerst der Name der Umgebungsvariablen gedruckt, gefolgt vom Wert der Variablen in der nächsten Zeile. Wenn „myValue“ jedoch auf „NULL“ gesetzt ist, wird keine Meldung angezeigt und der Code endet hier.
Code 2:
#include#include
verwenden Namensraum std ;
int hauptsächlich ( )
{
verkohlen * newEnv_var = 'WEG' ;
verkohlen * meinWert ;
meinWert = gettenv ( newEnv_var ) ;
Wenn ( meinWert ! = NULL ) {
cout << „Die Variable =“ << newEnv_var << endl ;
cout << „Der Wert =“ << meinWert << endl ;
}
anders
cout << „Variable existiert nicht!“ << meinWert ;
zurückkehren 0 ;
}
Ausgabe:
Jetzt wird auf dem Terminal der Wert der Umgebungsvariablen „PATH“ angezeigt, den wir mithilfe der Funktion „getenv()“ in unserem Code erhalten. Es unterscheidet sich auf jedem Computer, da der Pfad auf jedem Computer unterschiedlich ist.
Beispiel 3:
Hier ist ein weiteres Beispiel: Wir geben „namespace std“ am Anfang unseres Codes ein, nachdem wir die erforderlichen Header-Dateien „iostream“ und „cstdlib“ eingebunden haben. Als nächstes geben wir die Methode „main()“ ein, in der wir einen „char*“-Zeiger namens „myVar“ generieren und den Namen der Umgebungsvariablen „PUBLIC“ initialisieren.
Als nächstes erstellen wir ein neues „char*“ namens „myValue“; Dies ist auch ein Hinweis. Da nun „myVar“ der Funktion „getenv()“ übergeben wird, mit der wir die Variable „myValue“ initialisieren, handelt es sich um ein Funktionsargument. Da wir es mit „PUBLIC“ initialisieren, ist der Umgebungsvariablenname in dieser „myVar“-Variablen enthalten.
Um dann festzustellen, ob „myValue“ gleich „NULL“ ist oder nicht, wird eine „if“-Bedingung hinzugefügt. Der Name der Umgebungsvariablen wird zuerst auf dem Bildschirm angezeigt, wenn „myValue“ nicht null ist, und der Wert der Variablen wird in der nächsten Zeile angezeigt. Dann haben wir hier den anderen Teil hinzugefügt, der ausgeführt wird, wenn die gegebene Bedingung nicht erfüllt ist. Hier geben wir eine Meldung aus, die uns mitteilt, dass die „Variable hier nicht gefunden“ wurde.
Code 3:
#include#include
verwenden Namensraum std ;
int hauptsächlich ( )
{
verkohlen * meineVar = 'ÖFFENTLICH' ;
verkohlen * meinWert ;
meinWert = gettenv ( meineVar ) ;
Wenn ( meinWert ! = NULL ) {
cout << „Die Variable =“ << meineVar << endl ;
cout << „Es ist Wert=“ << meinWert << endl ;
}
anders
cout << „Variable hier nicht gefunden..!!“ << meinWert ;
zurückkehren 0 ;
}
Ausgabe:
Der Name der Umgebungsvariablen, die wir als Parameter zur Funktion „getenv()“ hinzufügen, wird zusammen mit ihrem Wert in dieser Ausgabe gerendert. Wir können diesen Wert mit der Funktion „getenv()“ unseres Codes erhalten.
Beispiel 4:
Wir erstellen hier ein konstantes char-Array mit dem Namen „NewEnv_var[]“ und der Größe „6“. Anschließend übergeben wir alle möglichen Umgebungsvariablen an dieses Array. Darunter haben wir ein weiteres Array namens „char *env_value[]“ mit der gleichen Größe von „6“. Jetzt haben wir eine „for“-Schleife und durchlaufen alle diese Umgebungsvariablen der Funktion „getenv()“, um die Werte aller dieser Variablen abzurufen und sie im Array „env_value“ zu speichern. Innerhalb dieser „for“-Schleife platzieren wir auch eine „if“-Bedingung, die prüft, ob der Umgebungswert null ist. Wenn der Wert nicht null ist, werden der Wert und der Variablenname gedruckt. Wenn es null ist, wird eine Meldung angezeigt, dass die Umgebungsvariable hier nicht vorhanden ist.
Code 4:
#include#include
verwenden Namensraum std ;
int hauptsächlich ( )
{
const verkohlen * NewEnv_var [ 6 ] = { 'ÖFFENTLICH' , 'HEIM' , „SITZUNGSNAME“ , „LIB“ , „SystemDrive“ , „DELTREE“ } ;
verkohlen * env_value [ 6 ] ;
für ( int A = 1 ; A <= 6 ; A ++ )
{
env_value [ A ] = gettenv ( NewEnv_var [ A ] ) ;
Wenn ( env_value [ A ] ! = NULL )
cout << „Die Variable ist“ << NewEnv_var [ A ] << ', und es ist 'Value=' << env_value [ A ] << endl ;
anders
cout << NewEnv_var [ A ] << „existiert hier nicht“ << endl ;
}
}
Ausgabe:
Hier werden alle möglichen Werte der Umgebungsvariablen angezeigt und außerdem die Meldung, dass „HOME“, „LIB“ und „DELTREE“ nicht existieren, was bedeutet, dass ihr Wert NULL ist.
Beispiel 5:
Jetzt machen wir weiter. Dies ist das letzte Beispiel dieses Tutorials. Hier erstellen wir ein konstantes char-Array der Größe „4“ mit dem Namen „Variable[]“, dem wir alle potenziellen Umgebungsvariablen bereitstellen. Wir verwenden jetzt eine „for“-Schleife. Darunter befindet sich ein weiteres Array mit der gleichen Größe von „4“ namens „char *values[]“ und wir platzieren dort die Funktion „getenv()“ und übergeben die „variable[i]“ als Parameter. Diese Schleife wird verwendet, um alle Umgebungsvariablen zu durchlaufen, ihre Werte von der Funktion „getenv()“ abzurufen und sie im Array „values[]“ zu speichern.
Wir schließen die „if“-Bedingung in diese „for“-Schleife ein, die bestimmt, ob der Umgebungswert null ist oder nicht. Der Wert und der Variablenname werden gedruckt, wenn der Wert nicht null ist, und eine Meldung wird angezeigt, wenn er NULL ist, was im „else“-Teil angegeben wird.
Code 5:
#includeverwenden Namensraum std ;
int hauptsächlich ( ) {
const verkohlen * Variable [ 4 ] = { 'ÖFFENTLICH' , 'HEIM' , „DELTREE“ , „LOGNAME“ } ;
für ( int ich = 0 ; ich <= 4 ; ich ++ )
{
const verkohlen * Werte = gettenv ( Variable [ ich ] ) ;
Wenn ( Werte ! = NULL ) {
cout << Variable [ ich ] << ' = ' << Werte << endl ;
}
anders {
cout << Variable [ ich ] << „Hier nicht gefunden!“ << endl ;
}
}
zurückkehren 0 ;
}
Ausgabe:
In diesem Fall werden die möglichen Werte der Umgebungsvariablen zusammen mit der Benachrichtigung angezeigt, dass die Werte von „HOME“, „DELTREE“ und „LONGNAME“ hier nicht gefunden werden, was bedeutet, dass es sich um NULL-Werte handelt.
Abschluss
In diesem Tutorial dreht sich alles um „Wie man in C++ auf die Umgebung zugreift“. Wir haben die Beispiele untersucht, in denen wir gelernt haben, wie man einzeln auf die Umgebungsvariable zugreift oder das Array verwendet, in dem wir alle möglichen Umgebungsvariablen übergeben und dann die Werte mithilfe der Funktion „getenv()“ erhalten. Diese „getenv()“-Methode wird von der C++-Sprache bereitgestellt, um die erforderlichen Umgebungsvariablenwerte abzurufen.