Sa C++, kapag tinukoy namin ang isang klase, sinisimulan namin ang ilang mga variable sa loob ng klase na iyon. Ang mga variable na ito ay ang 'miyembro variable' ng klase. Maaari nating simulan ang 'variable ng miyembro' sa pamamagitan ng paggamit ng constructor method sa C++ programming. Ang isang variable na naka-link sa isang partikular na object ng klase at naa-access sa lahat ng mga pamamaraan o function nito ay tinutukoy bilang isang 'variable ng miyembro' sa C++. Sa artikulong ito, idedeklara namin ang 'mga variable ng miyembro' na ito sa C++ code at ipaliwanag ang mga 'variable ng miyembro' nang detalyado dito.
Halimbawa 1:
Magsimula tayo ng ilang code dito sa pamamagitan ng pagsasama ng 'header file' na kailangan namin sa panahon ng code na ito. Ang 'iostream' ay ang header file na ipinapasok namin sa code na ito. Kasama sa header file na ito ang pinakamaraming function hangga't maaari na kailangan namin sa code na ito at ipinahayag dito. Pagkatapos, dapat naming isama ang namespace, na kung saan ay ang 'std', kaya idinagdag namin ito dito sa pamamagitan ng paglalagay ng 'gamit' na keyword na may 'namespace std'.
Hindi namin kailangang idagdag ang 'std' na ito nang hiwalay sa mga function. Pagkatapos, tinukoy namin ang isang klase na pinangalanang 'SampleClass' at ginagamit ang 'pampublikong' constructor. Sa 'pampublikong' constructor na ito, ipinapahayag namin ang ilang variable ng miyembro na maa-access namin sa aming mga function ng miyembro sa ibang pagkakataon. Ang mga variable ng miyembro na idineklara namin dito ay 'mVar1' at 'mVar2' ng 'int' na uri ng data.
Pagkatapos, idedeklara namin ang isang function sa ilalim nito na pinangalanang 'setValues()'. Sa function na 'setValues()', inilalagay namin ang 'cout' upang i-print ang mensahe na nagtuturo sa user na magpasok ng dalawang value. Ang dalawang value na ilalagay ng user ay naka-save sa “mVar1” at “mVar2” na mga variable. Nakukuha namin ang mga halagang ito sa tulong ng pamamaraang 'cin'. Matapos makuha ang parehong mga halaga at i-save ang mga ito sa 'mVar1' at 'mVar2', tinukoy namin ang isa pang function sa ibaba nito. Ang pangalan ng function na iyon ay 'getValues' kung saan ginagamit namin ang mga 'cout' na pahayag.
Dito, inilalagay namin muli ang 'mVar1' at 'mVar2' sa 'cout' upang ipakita ang parehong mga halaga na nakuha namin mula sa nakaraang user. Sa ilalim nito, tinatawag namin ang 'pangunahing()' na pamamaraan kung saan nabuo ang object ng klase. Ang pangalan ng object ng klase ay 'sc1'. Pagkatapos, tinatawag namin ang unang function na 'setValues' na aming tinukoy dito gamit ang 'sc1' object.
Pagkatapos nito, inilalagay namin muli ang pangalan ng bagay at tinawag ang pangalawang function na 'getValues()' na may pangalan ng object na 'sc1'. Ngayon, kinukuha muna nito ang mga value at pagkatapos ay ipinapakita ang mga ito sa console habang tinatawag natin ang parehong mga pamamaraan na may object ng klase kung saan naa-access ang variable ng miyembro sa code na ito.
Code 1:
#includegamit ang namespace std;
klase SampleClass {
publiko:
int mVar1, mVar2;
void setValues ( ) {
cout <> mVar1 >> mVar2;
}
void getValues ( ) {
cout << 'Ang halaga ng unang memeber variable = ' << mVar1 << endl ;
cout << 'Ang halaga ng pangalawang memeber variable = ' << mVar2 << endl;
}
} ;
int pangunahing ( )
{
SampleClass sc1;
sc1.setValues ( ) ;
sc1.getValues ( ) ;
bumalik 0 ;
}
Output:
Ini-print muna nito ang mensahe. Pagkatapos, ipinasok namin ang '12' at '456' bilang mga halaga ng input na naka-imbak sa mga variable ng miyembro na aming idineklara sa code. Pagkatapos, ipinapakita nito ang mga halaga ng parehong variable habang ina-access namin ang mga ito gamit ang function ng miyembro.
Halimbawa 2:
Ngayon, tinukoy namin ang isang klase na pinangalanang 'ProductClass' pagkatapos idagdag ang 'iostream' header file at ang 'std' namespace. Sa 'ProductClass' na ito, ginagamit namin ang 'pampublikong' constructor kung saan ipinapahayag namin ang dalawang variable ng 'int' na uri ng data. Ito ay 'halaga' at 'multiplier' na mga variable ng miyembro.
Pagkatapos, tinutukoy namin ang isang function dito na may pangalan, 'calProductOfTwo()' function, upang ma-access ang parehong mga variable. Ito ang function ng miyembro dito at ina-access namin ang mga variable ng miyembro sa function na ito. Ginagamit namin ang keyword na 'return' sa ilalim nito at inilalagay ang 'value * multiplier' na nagbabalik ng produkto ng dalawang variable na ito.
Pagkatapos, ginagamit namin ang function na 'main()' kung saan ginagawa namin ang object ng 'ProductClass' na may pangalang 'p_obj' at pagkatapos ay italaga ang mga value sa mga variable ng miyembro na dati naming idineklara. Sinisimulan namin ang mga variable na ito sa tulong ng object na 'class'. Inilalagay muna namin ang pangalan ng object at pagkatapos ay ang pangalan ng variable ng miyembro na 'p_obj.value' at itinalaga ang '33' sa variable na 'value'.
Pagkatapos, sinisimulan namin ang variable na 'multiplier' at itinalaga ang '98' sa variable na ito. Ngayon, tinatawag namin ang function na 'calProductOfTwo()' sa 'cout' na may object ng klase na 'p_obj' na nagpapakita ng produkto ng parehong mga variable ng miyembro.
Code 2:
#includegamit ang namespace std;
klase ProductClass {
publiko:
int na halaga;
int multiplier;
int calProductOfTwo ( ) {
bumalik halaga * multiplier;
}
} ;
int pangunahing ( ) {
ProductClass p_obj;
p_obj.value = 33 ;
p_obj.multiplier = 98 ;
cout << 'Ang produkto ng dalawang halaga = ' << p_obj.calProductOfTwo ( ) << endl;
bumalik 0 ;
}
Output:
Ang produkto ng mga halaga ng mga variable na 'miyembro' ay ipinapakita dito. Makikita namin na ina-access namin ang mga variable na 'miyembro' sa loob ng function na 'miyembro' at sinisimulan ang mga ito pagkatapos gawin ang object na 'class' at tawagan ang function na 'miyembro' sa aming code. Ang produkto ng mga halaga ng parehong mga variable ng miyembro ay ibinibigay sa mga sumusunod:
Halimbawa 3:
Ang 'SumClass' ay tinukoy dito sa code na ito. Pagkatapos, sa 'pampubliko', idedeklara namin ang tatlong variable ng miyembro na may mga pangalan na 's_val_1', 's_val_2', at 's_val_3' at ang uri ng data ng lahat ng mga variable ay 'int'. Pagkatapos, tinukoy namin ang isang function na 'calSumOfTwo()' na siyang function na 'miyembro' at ina-access namin ang mga variable sa function na ito. Sa 'calSumOfTwo()', ginagamit namin ang keyword na 'return'. Dito, inilalagay namin ang 's_val_1 + s_val_2'.
Ngayon, binibigyan nito ang kabuuan ng dalawang variable na ito. Sa ilalim nito, tinukoy namin ang isa pang function na 'calSumOfThree()'. Sa function na ito, ina-access namin ang lahat ng tatlong variable upang mahanap ang kanilang kabuuan at ibalik ang kanilang resulta dito. Pagkatapos, tinatawag namin ang 'pangunahing ()' na pamamaraan. Ang object na 'class' na nabuo dito ay 'sObj1'.
Pagkatapos nito, sinisimulan namin ang lahat ng tatlong variable ng miyembro dito sa tulong ng object na 'class' at itinalaga ang '33', '98', at '195' sa 's_val_1', 's_val_2', at 's_val_3', ayon sa pagkakabanggit. Pagkatapos, tinatawag namin ang parehong function na 'miyembro' sa 'cout' kung saan ipinapakita ng 'calSumOfTwo()' ang kabuuan ng unang dalawang variable at ipinapakita ng 'calSumOfThree()' ang kabuuan ng lahat ng tatlong variable ng miyembro.
Code 3:
#includegamit ang namespace std;
klase SumClass {
publiko:
int s_val_1;
int s_val_2;
int s_val_3;
int calSumOfTwo ( ) {
bumalik s_val_1 + s_val_2;
}
int calSumOfThree ( ) {
bumalik s_val_1 + s_val_2 + s_val_3;
}
} ;
int pangunahing ( ) {
SumClass sObj1;
sObj1.s_val_1 = 33 ;
sObj1.s_val_2 = 98 ;
sObj1.s_val_3 = 195 ;
cout << 'Ang kabuuan ng dalawang halaga = ' << sObj1.calSumOfTwo ( ) << endl;
cout << 'Ang kabuuan ng tatlong halaga = ' << sObj1.calSumOfThree ( ) << endl;
bumalik 0 ;
}
Output:
Ang kabuuan ng unang dalawang variable na miyembro ay '131' na nakukuha natin dito sa pamamagitan ng pagtawag sa unang function na 'miyembro'. Ang kabuuan ng lahat ng tatlong variable ng miyembro ay “326″ na nakukuha namin sa pamamagitan ng pagtawag sa pangalawang function na “miyembro” sa aming code.
Konklusyon
Ang 'mga variable ng miyembro' sa C++ programming ay malalim na ginalugad sa artikulong ito. Ipinaliwanag namin na ang 'mga variable ng miyembro' ay idineklara pagkatapos tukuyin ang klase. Ang mga variable na ito ay naa-access mula sa lahat ng dako sa code pagkatapos gawin ang object na 'class'. Maa-access din namin ang mga variable na ito ng miyembro sa mga function na 'miyembro'. Sinimulan namin ang mga variable na ito pagkatapos gawin ang object na 'class'. Dito, ipinahayag, sinimulan, at na-access namin ang 'mga variable ng miyembro' sa aming C++ code.