Членска променлива в C++

Clenska Promenliva V C



В C++, когато дефинираме клас, ние инициализираме някои променливи вътре в този клас. Тези променливи са „променливата член“ на класа. Можем да инициализираме „променливата член“, като използваме метода на конструктора в програмирането на C++. Променлива, която е свързана с конкретен обект на клас и е достъпна за всички негови методи или функции, се нарича „променлива член“ в C++. В тази статия ще декларираме тези „членни променливи“ в C++ кода и ще обясним подробно „членните променливи“ тук.

Пример 1:







Нека започнем малко код тук, като включим „заглавния файл“, който ни е необходим по време на този код. „Iostream“ е заглавният файл, който вмъкваме в този код. Този заглавен файл включва възможно най-много функции, които са ни необходими в този код и са декларирани в него. След това трябва да включим пространството от имена, което е „std“, така че го добавяме тук, като поставим ключовата дума „using“ с „namespace std“.



Не е необходимо да добавяме това „std“ с функциите отделно. След това дефинираме клас с име 'SampleClass' и използваме 'публичния' конструктор. В този „публичен“ конструктор ние декларираме някои членски променливи, до които ще имаме достъп в нашите членски функции по-късно. Членските променливи, които декларираме тук, са „mVar1“ и „mVar2“ от типа данни „int“.



След това декларираме функция под това, която се нарича „setValues()“. В тази функция “setValues()” поставяме “cout” за отпечатване на съобщението, което инструктира потребителя да въведе две стойности. Двете стойности, които потребителят ще въведе, се записват в променливите „mVar1“ и „mVar2“. Получаваме тези стойности с помощта на метода “cin”. След като получим и двете стойности и ги запазим в „mVar1“ и „mVar2“, ние дефинираме друга функция под тази. Името на тази функция е „getValues“, където използваме изразите „cout“.





Тук поставяме „mVar1“ и „mVar2“ отново в „cout“, за да покажем и двете стойности, които получаваме от предишния потребител. Под това извикваме метода „main()“, в който се генерира обектът на класа. Името на обекта на класа е „sc1“. След това извикваме първата функция, която е „setValues“, която дефинираме тук с обекта „sc1“.

След това отново поставяме името на обекта и извикваме втората функция, която е „getValues()“ с името на обекта „sc1“. Сега той първо получава стойностите и след това ги показва на конзолата, докато извикваме и двата метода с обекта на класа, в който членната променлива е достъпна в този код.



Код 1:

#include
използване на пространство от имена std;
клас SampleClass {
публичен:
int mVar1, mVar2;
void setValues ( ) {
cout <> mVar1 >> mVar2;
}
void getValues ( ) {
cout << 'Стойността на първата членска променлива = ' << mVar1 << endl;
cout << 'Стойността на втората членска променлива = ' << mVar2 << endl;
}
} ;
int main ( )
{
Примерен клас sc1;
sc1.setValues ( ) ;
sc1.getValues ( ) ;
връщане 0 ;
}

Изход:

Първо отпечатва съобщението. След това въвеждаме „12“ и „456“ като входни стойности, които се съхраняват в членските променливи, които сме декларирали в кода. След това показва стойностите на двете променливи, когато имаме достъп до тях с помощта на членската функция.

Пример 2:

Сега дефинираме клас с име „ProductClass“, след като добавим заглавния файл „iostream“ и пространството от имена „std“. В този „ProductClass“ ние използваме „публичния“ конструктор, в който декларираме две променливи от тип данни „int“. Това са „стойност“ и „множител“, които са членски променливи.

След това тук дефинираме функция с името „calProductOfTwo()“ функция за достъп до двете променливи. Това е функцията член тук и имаме достъп до променливите член в тази функция. Ние използваме ключовата дума „return“ под това и поставяме „value * multiplier“, който връща произведението на тези две променливи.

След това извикваме функцията „main()“, в която създаваме обекта на „ProductClass“ с името „p_obj“ и след това присвояваме стойностите на членските променливи, които преди това сме декларирали. Ние инициализираме тези променливи с помощта на обекта “class”. Първо поставяме името на обекта и след това името на членската променлива “p_obj.value” и присвояваме “33” на променливата “value”.

След това инициализираме променливата „multiplier“ и присвояваме „98“ на тази променлива. Сега извикваме функцията „calProductOfTwo()“ в „cout“ с обекта от класа „p_obj“, който показва произведението на двете членски променливи.

Код 2:

#include
използване на пространство от имена std;
клас ProductClass {
публичен:
int стойност;
int множител;
int calProductOfTwo ( ) {
връщане стойност * множител;
}
} ;
int main ( ) {
ProductClass p_obj;
p_obj.value = 33 ;
p_obj.multiplier = 98 ;
cout << „Произведението на две стойности =  “ << p_obj.calProductOfTwo ( ) << endl;
връщане 0 ;
}

Изход:

Тук се показва произведението на стойностите на променливите „член“. Можем да видим, че имаме достъп до променливите „член“ във функцията „член“ и ги инициализираме, след като създадем обекта „клас“ и извикаме функцията „член“ в нашия код. Произведението на стойностите на двете членски променливи е дадено по следния начин:

Пример 3:

„SumClass“ е дефиниран тук в този код. След това в „public“ декларираме три членски променливи с имена „s_val_1“, „s_val_2“ и „s_val_3“ и типът данни на всички променливи е „int“. След това дефинираме функция „calSumOfTwo()“, която е функцията „член“ и имаме достъп до променливите в тази функция. В „calSumOfTwo()“ ние използваме ключовата дума „return“. Тук поставяме „s_val_1 + s_val_2“.

Сега дава сумата на тези две променливи. Под това дефинираме още една функция, която е „calSumOfThree()“. В тази функция имаме достъп до трите променливи, за да намерим тяхната сума и да върнем резултата им тук. След това извикваме метода „main()“. Обектът „клас“, който се генерира тук, е „sObj1“.

След това инициализираме всичките три променливи член тук с помощта на обекта „class“ и присвояваме „33“, „98“ и „195“ съответно на „s_val_1“, „s_val_2“ и „s_val_3“. След това извикваме и двете функции „член“ в „cout“, в който „calSumOfTwo()“ показва сумата от първите две променливи, а „calSumOfThree()“ показва сумата от всичките три променливи членове.

Код 3:

#include
използване на пространство от имена std;
клас SumClass {
публичен:
int s_val_1;
int s_val_2;
int s_val_3;

int calSumOfTwo ( ) {
връщане s_val_1 + s_val_2;
}
int calSumOfThree ( ) {
връщане s_val_1 + s_val_2 + s_val_3;
}
} ;
int main ( ) {
SumClass sObj1;
sObj1.s_val_1 = 33 ;
sObj1.s_val_2 = 98 ;
sObj1.s_val_3 = 195 ;
cout << „Сумата от две стойности =  “ << sObj1.calSumOfTwo ( ) << endl;
cout << „Сумата от три стойности =  “ << sObj1.calSumOfThree ( ) << endl;
връщане 0 ;
}

Изход:

Сумата от първите две членни променливи е „131“, която получаваме тук, като извикаме първата функция „член“. Сумата от всичките три членни променливи е „326″, която получаваме, като извикаме втората функция „член“ в нашия код.

Заключение

„Променливите членове“ в програмирането на C++ са подробно изследвани в тази статия. Обяснихме, че „членните променливи“ се декларират след дефиниране на класа. Тези променливи са достъпни отвсякъде в кода след създаването на обекта „клас“. Можем също така да имаме достъп до тези членски променливи във функциите „член“. Инициализирахме тези променливи след създаването на обекта „клас“. Тук декларирахме, инициализирахме и получихме достъп до „членните променливи“ в нашия C++ код.