ಪ್ರವೇಶಿಸುವವರು (ಪಡೆಯುವವರು) ಮತ್ತು ಪರಿವರ್ತಕಗಳು (ಸೆಟ್ಟರ್‌ಗಳು)


ವರ್ಗದ ಡೇಟಾ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸುವುದು ಈ ಸದಸ್ಯರ ಪ್ರವೇಶ ಸೂಚಕಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಕೆಲವೊಮ್ಮೆ ಖಾಸಗಿ ಡೇಟಾ ಸದಸ್ಯರಿಗೆ ಸಹ ಪ್ರವೇಶವನ್ನು ಒದಗಿಸುವ ಅವಶ್ಯಕತೆಯಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ತಂತ್ರ ಪ್ರವೇಶಿಸುವವರು (ಪಡೆಯುವವರು) ಮತ್ತು ರೂಪಾಂತರಗಳು (ಸೆಟ್ಟರ್‌ಗಳು) ಬಳಸಲಾಗುತ್ತದೆ.

ನಾವು ಬಳಸಬಹುದು ವ್ಯಕ್ತಿ ವಿಭಿನ್ನ ಪ್ರವೇಶ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ನೀವು ಡೇಟಾ ಸದಸ್ಯರನ್ನು ಹೇಗೆ ಪ್ರವೇಶಿಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸಲು ಹಿಂದಿನ ವಿಷಯದಿಂದ ವರ್ಗ ಮಾಡಿ:

class Person
{
public://access control
	string firstName;//these data members
	string lastName;//can be accessed
	tm dateOfBirth;//from anywhere
protected:
	string phoneNumber;//these data members can be accessed inside this class,
	int salary;// by friend functions/classes and derived classes
private:
	string address;//these members can be accessed inside the class
	unsigned long int insuranceNumber;//and by friend classes/functions
};

ಗೆ ಪ್ರವೇಶ ಸಾರ್ವಜನಿಕ ಡೇಟಾ ಸದಸ್ಯರನ್ನು ಬಳಸಿಕೊಂಡು ಮಾಡಬಹುದು ಡಾಟ್ ಆಪರೇಟರ್ (ಪಾಯಿಂಟರ್‌ಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಬಾಣ ಆಪರೇಟರ್):
Person person1;//declare a person
//access public data members
person1.firstName = "Smith";//set first name of person1 to Smith
person1.lastName = "James";//set last name of person1 to James
person1.dateOfBirth.tm_year = 1980;//set  year of birth of person1 to 1980

ವ್ಯಕ್ತಿಯ ಪಾಯಿಂಟರ್ ಸಂದರ್ಭದಲ್ಲಿ ಸಾರ್ವಜನಿಕ ಡೇಟಾ ಸದಸ್ಯರಿಗೆ ಪ್ರವೇಶವನ್ನು ಈ ಕೆಳಗಿನ ರೀತಿಯಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ:
Person* person2 = new Person();//declare a person
//access public data members
person2->firstName = "Moore";
person2->lastName = "Daniel";
person2->dateOfBirth.tm_year = 1988;

ಡೇಟಾ ಸದಸ್ಯರನ್ನು ಸಹ ಈ ಕೆಳಗಿನಂತೆ ಬಳಸಬಹುದು:
string pName = person1.firstName;
cout << "First name " << pName << endl;

ಈ ಕೋಡ್ ಈ ಕೆಳಗಿನ output ಟ್‌ಪುಟ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ:

ಮೊದಲ ಹೆಸರು ಸ್ಮಿತ್

ಗೆ ಪ್ರವೇಶ ಖಾಸಗಿ ವರ್ಗದ ಹೊರಗಿನ ಡೇಟಾ ಸದಸ್ಯರನ್ನು ಸ್ನೇಹಿತ ತರಗತಿಗಳು ಅಥವಾ ಕಾರ್ಯಗಳಿಗೆ ಮಾತ್ರ ಅನುಮತಿಸಲಾಗಿದೆ. ಆದರೆ ನೀವು ವಿಶೇಷ ಕಾರ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು ಪ್ರವೇಶಕ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ಖಾಸಗಿ ಡೇಟಾ ಸದಸ್ಯ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಈ ಕಾರ್ಯದ ಹೆಸರನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಉತ್ತಮ ಶೈಲಿಯಾಗಿದೆ ಪಡೆಯಲು, ನಂತರ ಡೇಟಾ ಸದಸ್ಯ ಗುರುತಿಸುವಿಕೆ. ರಿಟರ್ನ್ ಪ್ರಕಾರವು ಡೇಟಾ ಸದಸ್ಯರ ಪ್ರಕಾರಕ್ಕೆ ಸಮನಾಗಿರಬೇಕು. ಉದಾಹರಣೆಗೆ ನಾವು 2 ಗೆಟರ್ ಕಾರ್ಯಗಳನ್ನು ರಚಿಸಬಹುದು ವಿಳಾಸ ಮತ್ತು ವಿಮೆ ಸಂಖ್ಯೆ ಡೇಟಾ ಸದಸ್ಯರು:

public:
	string getAddress()
	{
		return address;
	}

	long int getInsuranceNumber()
	{
		return insuranceNumber;
	}

 

ಈ ಖಾಸಗಿ ಡೇಟಾ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಲು ಈಗ ನಾವು ಗೆಟ್ಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು:

cout << "Person1 address: " << person1.getAddress();

ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುವ ಮೊದಲು ಕೆಲವು ಹೆಚ್ಚುವರಿ ತಪಾಸಣೆಗಳನ್ನು ಮಾಡಲು ಪ್ರವೇಶಕಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ವಿಳಾಸ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುವ ಮೊದಲು ವಿಳಾಸವು ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್ ಅಲ್ಲವೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬಹುದು. ಇದು ಚಾಲನಾಸಮಯದಲ್ಲಿನ ಕೆಲವು ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಬಹುದು:
string getAddress()
{
	if (!address.empty())
		return address;
	else
		return "Attention!!! Address is empty";
}

ನೀವು ನೋಡುವಂತೆ, ಸ್ಟ್ರಿಂಗ್ ಒಂದು ವರ್ಗವೂ ಆಗಿದೆ. ನಾವು ಅದರ ಸಾರ್ವಜನಿಕ ಸದಸ್ಯರ ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತಿದ್ದೇವೆ ಖಾಲಿ () ಸ್ಟ್ರಿಂಗ್ ಖಾಲಿಯಾಗಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸಲು.

ರೂಪಾಂತರಗಳು (ಸೆಟ್ಟರ್‌ಗಳು) ಖಾಸಗಿ ಡೇಟಾ ಸದಸ್ಯರ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಡೇಟಾ ಸದಸ್ಯರಿಗೆ ಹೊಂದಿಸಬೇಕಾದ ಮೌಲ್ಯದ ನಿಖರತೆಯನ್ನು ಪರಿಶೀಲಿಸುವುದು ರೂಪಾಂತರದ ಮುಖ್ಯ ಗುರಿಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಒಂದು ಸೆಟ್ಟರ್ ಹೆಸರು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಸೆಟ್, ನಂತರ ಡೇಟಾ ಸದಸ್ಯರ ಹೆಸರು. ಸೆಟ್ಟರ್ ಹೊಂದಿಸಿದ ಬೆಟ್ ಮಾಡಲು ಸೆಟ್ಟರ್ ಡೇಟಾ ಸದಸ್ಯರಂತೆಯೇ ಒಂದೇ ರೀತಿಯ ಒಂದು ನಿಯತಾಂಕವನ್ನು ಹೊಂದಿರಬೇಕು. ವಿಮಾ ಸಂಖ್ಯೆಗೆ ಸೆಟ್ಟರ್ ರಚಿಸುವ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ: ಸೆಟ್ಟರ್‌ಗೆ 9 ಅಂಕೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ರವಾನಿಸಲಾಗಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬಹುದು ಮತ್ತು ಪ್ರಕರಣದಲ್ಲಿ ದೋಷ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುವುದು ತಪ್ಪಾದ ಸಂಖ್ಯೆ:

public:
	void setInsuranceNumber(unsigned long int insurance)
	{
		if (insurance >= 100000000 && insurance <= 999999999)
			insuranceNumber = insurance;//a correct value is set
		else
			//display only error message and do not set incorrect value
			cout << "Incorect Insurance number" << endl;
}

ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಲಾಗಿದೆಯೆ ಎಂದು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಕೆಲವೊಮ್ಮೆ ನೀವು ಸೆಟ್ಟರ್‌ನ ರಿಟರ್ನ್ ಮೌಲ್ಯವನ್ನು ಬಳಸಬಹುದು. ಈ ಕೆಳಗಿನ ರೀತಿಯಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ನಾವು ಮೇಲಿನ ಉದಾಹರಣೆಯನ್ನು ಮಾರ್ಪಡಿಸಬಹುದು: ಸರಿಯಾದ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಿದರೆ ಸೆಟ್ಟರ್ ನಿಜವಾಗುವುದು. ಇಲ್ಲದಿದ್ದರೆ ಅದು ಸುಳ್ಳನ್ನು ನೀಡುತ್ತದೆ:
bool setInsuranceNumber(unsigned long int insurance)
{
	if (insurance >= 100000000 && insurance <= 999999999)
	{
		insuranceNumber = insurance;//a correct value is set
		return true;//everything is ok
	}
	else
		//do not set incorrect value and return false
		return false;
}

ಬಳಕೆದಾರರಿಂದ ಸರಿಯಾದ ಇನ್ಪುಟ್ ಪಡೆಯಲು ಇದನ್ನು ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಬಳಸಬಹುದು:
unsigned long int iNum;
cout << "Please, enter you Insurance Number:" << endl;
cin >> iNum;
//try to set the value
bool result = person1.setInsuranceNumber(iNum);
while (!result)//while result is not true
{
	cout << "Enter a valid Insurance Number:" << endl;
	cin >> iNum;
	//try to set the value again
	result = person1.setInsuranceNumber(iNum);
}

ತಪ್ಪಾದ ಮೌಲ್ಯವನ್ನು ನಮೂದಿಸಲು ನೀವು ಪ್ರಯತ್ನಿಸಬಹುದು:

ದಯವಿಟ್ಟು, ನಿಮಗೆ ವಿಮಾ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ:

1234

ಮಾನ್ಯವಾದ ವಿಮಾ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ:

032

ಮಾನ್ಯವಾದ ವಿಮಾ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ:

123456789

ಸಂರಕ್ಷಿಸಲಾಗಿದೆ ಸ್ನೇಹಿತರ ಕಾರ್ಯಗಳು ಅಥವಾ ತರಗತಿಗಳಿಂದ ಮತ್ತು ಪಡೆದ ವರ್ಗಗಳಿಂದ ಸಾರ್ವಜನಿಕ ದತ್ತಾಂಶ ಸದಸ್ಯರಂತೆಯೇ ಡೇಟಾ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ನೀವು ಪ್ರವೇಶವನ್ನು ಒದಗಿಸಬೇಕಾದರೆ ರಕ್ಷಣೆ ಯಾವುದೇ ಇತರ ಕಾರ್ಯಗಳಿಂದ ಡೇಟಾ ಸದಸ್ಯರು, ನೀವು ಪ್ರವೇಶಿಸಲು ಅದೇ ತಂತ್ರವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ ಖಾಸಗಿ ಡೇಟಾ ಸದಸ್ಯರು.