Halimbawa 1:
Magsisimula lang kami sa aming unang halimbawa dito. Upang gawin ang mga C++ code, kailangan namin ng ilang mga file ng header. Kaya, isinama namin ang mga file ng header na kailangan namin sa code na ito. Ang 'iostream' header file ay mahalaga dahil, sa code na ito, kailangan naming magpakita ng ilang data at sinusuportahan ng header file na ito ang 'cout' function. Pagkatapos, mayroon kaming 'cstdlib'; ang header na ito ay nagbibigay ng isang hanay ng mga pamamaraan tulad ng 'getenv()' na pamamaraan.
Ngayon, idinagdag namin ang 'namespace std' kaya hindi namin kailangang magdagdag ng 'std' sa mga function na 'cout()' sa aming code. Pagkatapos nito, tinawag ang 'pangunahing ()' na function. Pagkatapos, inilalagay namin ang 'char*' na isang pointer dito na may pangalang 'var_1'. Pagkatapos, sa variable na 'var_1' na ito, inilalagay namin ang function na 'getenv()' at ipinapasa ang 'SESSIONNAME' bilang parameter nito.
Pagkatapos nito, nagdaragdag kami ng kundisyon na 'kung' na nagsusuri kung ang 'var_1' ay hindi katumbas ng 'NULL'. Kung ang 'var_1' ay hindi null, ipi-print muna nito ang pangalan ng variable ng kapaligiran. Pagkatapos, sa susunod na linya, ipi-print nito ang halaga ng variable na iyon. Ngunit kung ang 'var_1' ay 'NULL', hindi ito magpapakita ng anumang mensahe doon at magtatapos ang code.
Code 1:
#include
#include
gamit namespace std ;
int pangunahing ( )
{
char * ay_1 ;
ay_1 = gettenv ( 'SESSIONNAME' ) ;
kung ( ay_1 ! = WALA )
cout << 'Ang pangalan ng variable ay SESSIONNAME' << endl ;
cout << 'Ang variable ng kapaligiran ay: ' << ay_1 ;
bumalik 0 ;
}
Output :
Ang output na ito ay nagre-render ng pangalan ng environment variable na idinaragdag namin bilang parameter ng 'getenv()' function at ang value ng environment variable na ito. Nakukuha namin ang halagang ito sa tulong ng function na 'getenv()' sa aming code.
Halimbawa 2:
Ngayon, mayroon tayong isa pang halimbawa. Sinisimulan namin ang aming code sa pamamagitan ng pagsasama ng mga kinakailangang file ng header. Pagkatapos, i-type namin ang 'namespace std'. Pagkatapos nito, ina-access namin ang function na 'main()' kung saan gumagawa kami ng pointer na 'char* ' na pinangalanang 'newEnv_var' at sinisimulan ito gamit ang pangalan ng variable ng environment na 'Path'. Pagkatapos, nagdagdag kami ng isa pang “char* ” na isa ring pointer dito at pinangalanan itong “myValue”.
Ngayon, sinisimulan namin ang variable na 'myValue' gamit ang function na 'getenv()' at ipapasa ang 'newEnv_var' sa function na 'getenv()' na ito; ito ang parameter ng function na ito. Ang variable na 'newEnv_var' na ito ay naglalaman ng pangalan ng variable ng kapaligiran habang sinisimulan namin ito ng 'PATH'. Susunod, ang isang 'kung' kundisyon ay idinagdag upang matukoy kung ang 'myValue' ay katumbas ng 'NULL' o hindi. Kung ang 'myValue' ay hindi null, ang pangalan ng variable ng kapaligiran ay ipi-print muna, na sinusundan ng halaga ng variable sa susunod na linya. Gayunpaman, kung ang 'myValue' ay nakatakda sa 'NULL', walang mensahe na ipinapakita at ang code ay nagtatapos dito.
Code 2:
#include#include
gamit namespace std ;
int pangunahing ( )
{
char * newEnv_var = 'PATH' ;
char * myValue ;
myValue = gettenv ( newEnv_var ) ;
kung ( myValue ! = WALA ) {
cout << 'Ang variable =' << newEnv_var << endl ;
cout << 'Ang halaga =' << myValue << endl ;
}
iba pa
cout << 'Walang variable!' << myValue ;
bumalik 0 ;
}
Output:
Ngayon, sa terminal, ipinapakita nito ang halaga ng variable na kapaligiran ng 'PATH' na nakukuha namin gamit ang function na 'getenv()' sa aming code. Nag-iiba ito sa bawat computer dahil iba ang path sa bawat computer.
Halimbawa 3:
Narito ang isa pang halimbawa: nagta-type kami ng 'namespace std' sa simula ng aming code pagkatapos isama ang kinakailangang 'iostream' at 'cstdlib' na mga file ng header. Susunod, ilalagay namin ang 'pangunahing()' na paraan kung saan bumubuo kami ng 'char*' na pointer na tinatawag na 'myVar' at sinisimulan ang 'PUBLIC' na pangalan ng variable ng kapaligiran.
Susunod, gumawa kami ng bagong 'char*' na tinatawag na 'myValue'; ito ay isa ring pointer. Ngayon na ang 'myVar' ay ibinibigay sa function na 'getenv()', kung saan sinisimulan natin ang variable na 'myValue', ito ay isang function argument. Dahil sinisimulan namin ito sa 'PUBLIC', ang pangalan ng variable ng kapaligiran ay nakapaloob sa variable na 'myVar' na ito.
Pagkatapos, upang matiyak kung ang 'myValue' ay katumbas ng 'NULL' o hindi, isang 'kung' kundisyon ay idinagdag. Ang pangalan ng variable ng kapaligiran ay unang lalabas sa screen kung ang 'myValue' ay hindi null, at ang halaga ng variable ay lalabas sa susunod na linya. Pagkatapos, mayroon kaming iba pang bahagi na idinagdag dito na ipapatupad kung ang ibinigay na kondisyon ay hindi nasiyahan. Dito, nag-print kami ng mensahe na nagsasabi sa amin na ang 'Variable ay hindi matatagpuan dito'.
Code 3:
#include#include
gamit namespace std ;
int pangunahing ( )
{
char * myVar = 'PUBLIC' ;
char * myValue ;
myValue = gettenv ( myVar ) ;
kung ( myValue ! = WALA ) {
cout << 'Ang Variable =' << myVar << endl ;
cout << 'Ito ay Halaga = ' << myValue << endl ;
}
iba pa
cout << 'Hindi nakita ang variable dito..!!' << myValue ;
bumalik 0 ;
}
Output:
Ang pangalan ng environment variable na idinaragdag namin bilang parameter sa 'getenv()' function, kasama ang value nito, ay nai-render sa output na ito. Makukuha namin ang halagang ito gamit ang function na 'getenv()' ng aming code.
Halimbawa 4:
Gumagawa kami ng pare-parehong char array na pinangalanang 'NewEnv_var[]' dito na may sukat na '6'. Pagkatapos, ipinapasa namin ang lahat ng posibleng mga variable ng kapaligiran sa array na ito. Sa ibaba nito, mayroon kaming isa pang array na pinangalanang 'char *env_value[]' na may parehong laki ng '6'. Ngayon, mayroon kaming loop na 'para sa' at ini-loop namin ang lahat ng mga variable ng kapaligiran na ito mula sa function na 'getenv()' upang makuha ang mga halaga ng lahat ng mga variable na ito at iimbak ang mga ito sa array na 'env_value'. Sa loob ng loop na 'for' na ito, naglalagay din kami ng kundisyon na 'kung' na nagsusuri kung null ang value ng environment. Kung hindi null ang value, ipi-print nito ang value at ang variable na pangalan. Kung ito ay null, ito ay nagpapakita ng isang mensahe na ang environment variable ay hindi umiiral dito.
Code 4:
#include#include
gamit namespace std ;
int pangunahing ( )
{
const char * NewEnv_var [ 6 ] = { 'PUBLIC' , 'BAHAY' , 'SESSIONNAME' , 'LIB' , 'SystemDrive' , 'DELTREE' } ;
char * env_value [ 6 ] ;
para sa ( int a = 1 ; a <= 6 ; a ++ )
{
env_value [ a ] = gettenv ( NewEnv_var [ a ] ) ;
kung ( env_value [ a ] ! = WALA )
cout << 'Ang variable ay' << NewEnv_var [ a ] << ', at ito ay 'Value=' << env_value [ a ] << endl ;
iba pa
cout << NewEnv_var [ a ] << 'wala dito' << endl ;
}
}
Output:
Dito, ipinapakita nito ang lahat ng posibleng value ng environment variable at ipinapakita rin ang mensahe na 'HOME', 'LIB', at 'DELTREE' ay hindi umiiral na nangangahulugan na ang kanilang value ay NULL.
Halimbawa 5:
Ngayon, mauna tayo. Ito ang huling halimbawa ng tutorial na ito. Dito, nagtatag kami ng pare-parehong char array na may sukat na '4' na tinatawag na 'Variable[]' kung saan ibinibigay namin ang lahat ng potensyal na variable ng kapaligiran. Gumagamit na kami ngayon ng 'para' na loop. Sa ibaba nito, may isa pang array na may parehong laki ng '4' na tinatawag na 'char *values[]' at inilalagay namin ang 'getenv()' function doon at ipinapasa ang 'variable[i]' bilang parameter nito. Ang loop na ito ay ginagamit upang umulit sa lahat ng mga variable ng kapaligiran, na kinukuha ang kanilang mga halaga mula sa function na 'getenv()' at i-save ang mga ito sa array na 'mga halaga[]'.
Isinasama namin ang kundisyon na 'kung' sa loob ng loop na 'para sa' na tumutukoy kung null o hindi ang value ng environment. Ang halaga at ang variable na pangalan ay naka-print kung ang halaga ay hindi null, at isang mensahe ay ipinapakita kung ito ay NULL na ibinigay sa 'iba' na bahagi.
Code 5:
#includegamit namespace std ;
int pangunahing ( ) {
const char * variable [ 4 ] = { 'PUBLIC' , 'BAHAY' , 'DELTREE' , 'LOGNAME' } ;
para sa ( int i = 0 ; i <= 4 ; i ++ )
{
const char * mga halaga = gettenv ( variable [ i ] ) ;
kung ( mga halaga ! = WALA ) {
cout << variable [ i ] << '=' << mga halaga << endl ;
}
iba pa {
cout << variable [ i ] << 'Hindi matatagpuan dito!' << endl ;
}
}
bumalik 0 ;
}
Output:
Sa kasong ito, ipinapakita ang mga posibleng value ng environment variable kasama ng notification na ang mga value ng 'HOME', 'DELTREE', at 'LONGNAME' ay hindi matatagpuan dito na nangangahulugan na ang mga ito ay NULL value.
Konklusyon
Ang tutorial na ito ay tungkol sa 'kung paano i-access ang kapaligiran sa C++'. Ginalugad namin ang mga halimbawa kung saan natutunan namin kung paano i-access ang variable ng kapaligiran nang paisa-isa o gamit ang array kung saan ipinapasa namin ang lahat ng posibleng variable ng kapaligiran at pagkatapos ay makuha ang mga value sa pamamagitan ng paggamit ng function na 'getenv()'. Ang pamamaraang 'getenv()' na ito ay ibinibigay ng wikang C++ upang makuha ang mga kinakailangang value ng variable ng kapaligiran.