Contoh 1:
Kami hanya bermula dengan contoh pertama kami di sini. Untuk melakukan kod C++, kami memerlukan beberapa fail pengepala. Jadi, kami memasukkan fail pengepala yang kami perlukan dalam kod ini. Fail pengepala 'iostream' adalah penting kerana, dalam kod ini, kita perlu memaparkan beberapa data dan fail pengepala ini menyokong fungsi 'cout'. Kemudian, kami mempunyai 'cstdlib'; pengepala ini menyediakan satu set kaedah seperti kaedah 'getenv()'.
Sekarang, kami menambah 'ruang nama std' jadi kami tidak perlu menambah 'std' dengan fungsi 'cout()' dalam kod kami. Selepas ini, fungsi 'utama()' dipanggil. Kemudian, kami meletakkan 'char*' yang merupakan penunjuk di sini dengan nama 'var_1'. Kemudian, dalam pembolehubah 'var_1' ini, kami meletakkan fungsi 'getenv()' dan lulus 'SESSIONNAME' sebagai parameternya.
Selepas ini, kami menambah syarat 'jika' yang menyemak sama ada 'var_1' tidak sama dengan 'NULL'. Jika 'var_1' bukan nol, ia mencetak nama pembolehubah persekitaran terlebih dahulu. Kemudian, dalam baris seterusnya, ia mencetak nilai pembolehubah itu. Tetapi jika 'var_1' ialah 'NULL', ia tidak akan memaparkan sebarang mesej di sana dan kod itu ditamatkan.
Kod 1:
#include
#include
menggunakan ruang nama std ;
int utama ( )
{
char * was_1 ;
was_1 = gettenv ( 'SESSIONNAME' ) ;
jika ( was_1 ! = NULL )
cout << 'Nama pembolehubah ialah SESSIONNAME' << endl ;
cout << 'Pembolehubah persekitaran ialah:' << was_1 ;
kembali 0 ;
}
Pengeluaran :
Output ini menjadikan nama pembolehubah persekitaran yang kami tambahkan sebagai parameter fungsi 'getenv()' dan nilai pembolehubah persekitaran ini. Kami mendapat nilai ini dengan bantuan fungsi 'getenv()' dalam kod kami.
Contoh 2:
Sekarang, kita mempunyai satu lagi contoh. Kami memulakan kod kami dengan memasukkan fail pengepala yang diperlukan. Kemudian, kami menaip 'ruang nama std'. Selepas ini, kami mengakses fungsi 'main()' di mana kami mencipta penunjuk 'char* ' bernama 'newEnv_var' dan memulakannya dengan nama pembolehubah persekitaran 'Path'. Kemudian, kami menambah satu lagi 'char*' yang juga merupakan penunjuk di sini dan menamakannya 'myValue'.
Sekarang, kami memulakan pembolehubah 'myValue' dengan fungsi 'getenv()' dan lulus 'newEnv_var' kepada fungsi 'getenv()' ini; ia adalah parameter fungsi ini. Pembolehubah 'newEnv_var' ini mengandungi nama pembolehubah persekitaran semasa kami memulakannya dengan 'PATH'. Seterusnya, syarat 'jika' ditambah untuk menentukan sama ada 'myValue' bersamaan dengan 'NULL' atau tidak. Jika 'myValue' bukan nol, nama pembolehubah persekitaran dicetak dahulu, diikuti dengan nilai pembolehubah dalam baris seterusnya. Walau bagaimanapun, jika 'myValue' ditetapkan kepada 'NULL', tiada mesej dipaparkan dan kod itu berakhir di sini.
Kod 2:
#include#include
menggunakan ruang nama std ;
int utama ( )
{
char * newEnv_var = 'JALAN' ;
char * myValue ;
myValue = gettenv ( newEnv_var ) ;
jika ( myValue ! = NULL ) {
cout << 'Pembolehubah = ' << newEnv_var << endl ;
cout << 'Nilai = ' << myValue << endl ;
}
lain
cout << 'Pembolehubah tidak wujud!' << myValue ;
kembali 0 ;
}
Pengeluaran:
Sekarang, pada terminal, ia menunjukkan nilai pembolehubah persekitaran 'PATH' yang kami dapat menggunakan fungsi 'getenv()' dalam kod kami. Ia berbeza pada setiap komputer kerana laluan pada setiap komputer adalah berbeza.
Contoh 3:
Berikut ialah contoh lain: kami menaip 'ruang nama std' pada permulaan kod kami selepas memasukkan fail pengepala 'iostream' dan 'cstdlib' yang diperlukan. Seterusnya, kami memasukkan kaedah 'main()' di mana kami menjana penunjuk 'char*' yang dipanggil 'myVar' dan memulakan nama pembolehubah persekitaran 'PUBLIC'.
Seterusnya, kami mencipta 'char*' baharu yang dipanggil 'myValue'; yang ini juga penunjuk. Sekarang bahawa 'myVar' dibekalkan kepada fungsi 'getenv()', yang dengannya kita memulakan pembolehubah 'myValue', ia adalah hujah fungsi. Memandangkan kami memulakannya dengan 'PUBLIC', nama pembolehubah persekitaran terkandung dalam pembolehubah 'myVar' ini.
Kemudian, untuk memastikan sama ada 'myValue' adalah sama dengan 'NULL' atau tidak, syarat 'jika' ditambah. Nama pembolehubah persekitaran akan muncul dahulu pada skrin jika 'myValue' bukan batal, dan nilai pembolehubah akan muncul pada baris seterusnya. Kemudian, kami mempunyai bahagian lain yang ditambahkan di sini yang dilaksanakan jika syarat yang diberikan tidak berpuas hati. Di sini, kami mencetak mesej yang memberitahu kami bahawa 'Pembolehubah tidak ditemui di sini'.
Kod 3:
#include#include
menggunakan ruang nama std ;
int utama ( )
{
char * myVar = 'AWAM' ;
char * myValue ;
myValue = gettenv ( myVar ) ;
jika ( myValue ! = NULL ) {
cout << 'Pembolehubah = ' << myVar << endl ;
cout << 'Nilainya = ' << myValue << endl ;
}
lain
cout << 'Pembolehubah tidak ditemui di sini..!!' << myValue ;
kembali 0 ;
}
Pengeluaran:
Nama pembolehubah persekitaran yang kami tambahkan sebagai parameter kepada fungsi 'getenv()', bersama-sama dengan nilainya, dipaparkan dalam output ini. Kita boleh mendapatkan nilai ini menggunakan fungsi 'getenv()' kod kami.
Contoh 4:
Kami mencipta tatasusunan aksara tetap bernama 'NewEnv_var[]' di sini dengan saiz '6'. Kemudian, kami menghantar semua pembolehubah persekitaran yang mungkin kepada tatasusunan ini. Di bawah ini, kami mempunyai tatasusunan lain bernama 'char *env_value[]' dengan saiz yang sama '6'. Sekarang, kami mempunyai gelung 'untuk' dan kami menggelungkan semua pembolehubah persekitaran ini daripada fungsi 'getenv()' untuk mendapatkan nilai semua pembolehubah ini dan menyimpannya dalam tatasusunan 'env_value'. Di dalam gelung 'untuk' ini, kami juga meletakkan syarat 'jika' yang menyemak sama ada nilai persekitaran adalah batal. Jika nilai bukan nol, ia mencetak nilai dan nama pembolehubah. Jika ia batal, ia menunjukkan mesej bahawa pembolehubah persekitaran tidak wujud di sini.
Kod 4:
#include#include
menggunakan ruang nama std ;
int utama ( )
{
const char * NewEnv_var [ 6 ] = { 'AWAM' , 'RUMAH' , 'SESSIONNAME' , 'LIB' , 'SystemDrive' , 'DELTREE' } ;
char * env_value [ 6 ] ;
untuk ( int a = 1 ; a <= 6 ; a ++ )
{
env_value [ a ] = gettenv ( NewEnv_var [ a ] ) ;
jika ( env_value [ a ] ! = NULL )
cout << 'Pembolehubah ialah' << NewEnv_var [ a ] << ', dan ia ialah 'Value=' << env_value [ a ] << endl ;
lain
cout << NewEnv_var [ a ] << 'tidak wujud di sini' << endl ;
}
}
Pengeluaran:
Di sini, ia menunjukkan semua kemungkinan nilai pembolehubah persekitaran dan juga menunjukkan mesej bahawa 'HOME', 'LIB', dan 'DELTREE' tidak wujud yang bermaksud nilainya adalah NULL.
Contoh 5:
Sekarang, mari ke hadapan. Ini adalah contoh terakhir tutorial ini. Di sini, kami mewujudkan tatasusunan aksara malar bersaiz '4' yang dipanggil 'Pembolehubah[]' yang mana kami menyediakan semua pembolehubah persekitaran yang berpotensi. Kami kini menggunakan gelung 'untuk'. Di bawah ini, terdapat satu lagi tatasusunan dengan saiz '4' yang sama dipanggil 'char *values[]' dan kami meletakkan fungsi 'getenv()' di sana dan lulus 'variable[i]' sebagai parameternya. Gelung ini digunakan untuk mengulangi semua pembolehubah persekitaran, mendapatkan semula nilainya daripada fungsi 'getenv()' dan menyimpannya dalam tatasusunan 'nilai[]'.
Kami memasukkan syarat 'jika' dalam gelung 'untuk' ini yang menentukan sama ada nilai persekitaran adalah batal atau tidak. Nilai dan nama pembolehubah dicetak jika nilainya bukan nol, dan mesej dipaparkan jika ia adalah NULL yang disediakan dalam bahagian 'lain'.
Kod 5:
#includemenggunakan ruang nama std ;
int utama ( ) {
const char * pembolehubah [ 4 ] = { 'AWAM' , 'RUMAH' , 'DELTREE' , 'LOGNAME' } ;
untuk ( int i = 0 ; i <= 4 ; i ++ )
{
const char * nilai = gettenv ( pembolehubah [ i ] ) ;
jika ( nilai ! = NULL ) {
cout << pembolehubah [ i ] << '=' << nilai << endl ;
}
lain {
cout << pembolehubah [ i ] << 'tidak dijumpai di sini!' << endl ;
}
}
kembali 0 ;
}
Pengeluaran:
Dalam kes ini, nilai kemungkinan pembolehubah persekitaran dipaparkan bersama-sama dengan pemberitahuan bahawa nilai 'HOME', 'DELTREE' dan 'LONGNAME' tidak ditemui di sini yang bermaksud bahawa nilai tersebut adalah nilai NULL.
Kesimpulan
Tutorial ini adalah mengenai 'cara mengakses persekitaran dalam C++'. Kami meneroka contoh di mana kami mempelajari cara untuk mengakses pembolehubah persekitaran secara individu atau menggunakan tatasusunan di mana kami melepasi semua pembolehubah persekitaran yang mungkin dan kemudian mendapatkan nilai dengan menggunakan fungsi 'getenv()'. Kaedah 'getenv()' ini disediakan oleh bahasa C++ untuk mendapatkan nilai pembolehubah persekitaran yang diperlukan.