類別的私有成員只能被類別的成員存取。這樣做是為了保持物件導向的封裝原則，確保資料及其相關函數被保存在一個單元中，並且只能從該類別的成員存取。 C 有三種不同的存取控制符來指定類別的成員的可見性。這三種存取控制符是−
Public − 如果一個類別的成員具有public可見性，那麼這些成員可以從任何其他類別中存取。
Private − 具有私有可見性的類別成員只能從類別內部存取。
Protected − protected class members can be accessed from with9in the class or from its subclasses only.
#對於這篇文章，我們將只關注存取類別的私有成員。
Getter和setter函數用於存取和修改類別的私有成員。顧名思義，getter函數傳回資料成員，而setter函數用於「設定」或修改資料成員。我們透過兩個例子來進一步理解這個概念，但在此之前，先給出基本語法如下。
Getter/ Accessor functions −
private:
<datatype> value;
public:
<datatype> getterFunction() {
return <datatype> this->value;
}
Setter/Mutator函數−
private:
<datatype> value;
public:
void setterFunction(<datatype> _value) {
this->value = _value;
}
#include <iostream>
using namespace std;
class Test{
private:
int value;
public:
//the getter function
int getValue() {
return this->value;
}
//the setter function
void setValue(int _value) {
this->value = _value;
}
};
int main(){
Test test;
test.setValue(15);
cout << "The value we set is: " << test.getValue() << endl;
return 0;
}
The value we set is: 15
當我們存取一個私有成員函數時，情況是一樣的。我們必須以與存取資料成員相同的方式從類別成員方法內部存取它。我們可以使用「this」指標來避免名稱衝突。
private:
<returntype> function_name(params) {};
public:
<returntype> another_function(params) {
<datatype> var = this->function_name(arguments);
}
呼叫私有成員函數的函數應該宣告為公共的。只有當從該類別的物件呼叫公共函數時，該函數才會執行。
#include <iostream>
using namespace std;
class Test{
private:
int value;
//multiplies the member value by 10
void multiplyValue() {
this->value = this->value * 10;
}
public:
//the getvalue function calls the multiply value function
int multiplyAndGetValue() {
this->multiplyValue();
return this->value;
}
//the setter function
void setValue(int _value) {
this->value = _value;
}
};
int main(){
Test test;
test.setValue(15);
cout << "The value after setting and multiplying is: " << test.multiplyAndGetValue() << endl;
return 0;
}
The value after setting and multiplying is: 150
在C 中，友元類別是一種可以存取其他類別中不對其他類別可見的私有和受保護成員的類別。要將一個類別宣告為另一個類別的友元類，需要使用關鍵字‘friend’。讓我們看看它是如何工作的。
class A{
private:
.....
friend class B;
};
class B{
//class body
};
#include <iostream>
using namespace std;
class Test1{
private:
int value;
public:
Test1(int _value) {
this->value = _value;
}
//we declare another class as a friend
friend class Test2;
};
class Test2{
public:
//displays the value of the other class object
void display(Test1 &t) {
cout << "The value of Test1 object is: " << t.value;
}
};
int main(){
//creating two class objects of the two classes
Test1 test1(15);
Test2 test2;
//calling the friend class function
test2.display(test1);
return 0;
}
The value of Test1 object is: 15
在C 中，友元函數類似友元類別。在這裡，我們可以將一個不是類別成員的特定函數聲明為“友元”，並且它將獲得存取類別的私有成員的權限。讓我們來看看如何將一個函數定義為「友元」的語法。
class A{
private:
.....
friend <return_type> function_name(params);
};
<return_type> function_name(params) {
//function body
}
#include <iostream>
using namespace std;
class Test1{
private:
int value;
public:
Test1(int _value) {
this->value = _value;
}
//we declare a friend function
friend void display(Test1);
};
void display(Test1 t) {
cout << "The value of Test1 object is: " << t.value;
}
int main(){
//creating two class objects of the two classes
Test1 test1(55);
//calling the friend class function
display(test1);
return 0;
}
The value of Test1 object is: 55
當我們存取一個類別的私有資料成員時，最好使用存取器/獲取器和修改器/設定器函數。這是存取類別的資料成員的最安全的方式。要始終記住的一件事是，存取私有成員的函數應該聲明為公共的。友元函數在其他物件導向的語言中不可用，因為這並不總是保持物件導向封裝的屬性。友元關係是不對稱的，如果類別A宣告類別B為友元，那麼類別B將可以存取A的所有成員，但A將無法存取B的所有私有成員。
以上是C++程式存取類別的私有成員的詳細內容。更多資訊請關注PHP中文網其他相關文章！
