C++ program access private members of class

Private members of a class can only be accessed by members of the class. This is done to maintain object-oriented encapsulation principles, ensuring that data and its associated functions are kept in a single unit and can only be accessed from members of the class. C has three different access controls to specify the visibility of members of a class. These three access control characters are −

• Public − If the members of a class have public visibility, then these members can be accessed from any other class.

• Private − Class members with private visibility can only be accessed from within the class.

• Protected − protected class members can be accessed from with9in the class or from its subclasses only.

For this article, we will only focus on accessing private members of a class.

Use getter and setter methods to access data members

The Getter and setter functions are used to access and modify private members of the class. As the name suggests, the getter function returns the data member, while the setter function is used to "set" or modify the data member. We use two examples to further understand this concept, but before that, the basic syntax is given below.

grammar

Getter/ Accessor functions −

private:
   <datatype> value;
public:
   <datatype> getterFunction() {
     return <datatype> this->value;
   }

Setter/Mutator function−

private:
   <datatype> value;
public:
   void setterFunction(<datatype> _value) {
     this->value = _value;
   }

The Chinese translation of

Example

is:

Example

#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;
}

Output

The value we set is: 15

Accessing member functions from within another function

The situation is the same when we access a private member function. We have to access it from inside the class member method in the same way as we access the data members. We can use the "this" pointer to avoid name conflicts.

grammar

private:
   <returntype> function_name(params) {};
public:
   <returntype> another_function(params) {
     <datatype> var = this->function_name(arguments);
   }

Functions that call private member functions should be declared public. The public function will only be executed when called from an object of this class.

The Chinese translation of

Example

is:

Example

#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;
}

Output

The value after setting and multiplying is: 150

Use friend classes

In C, a friend class is a class that can access private and protected members of other classes that are not visible to other classes. To declare a class as a friend of another class, use the keyword ‘friend’. Let's see how it works.

grammar

class A{
   private:
     .....
   friend class B;
};

class B{
   //class body
};

The Chinese translation of

Example

is:

Example

#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;
}

Output

The value of Test1 object is: 15

Use friend function

In C, friend functions are similar to friend classes. Here, we can declare a specific function that is not a member of the class as a "friend" and it will get access to the private members of the class. Let's look at the syntax of how to define a function as "Friend".

grammar

class A{
   private:
     .....
   friend <return_type> function_name(params);
};

<return_type> function_name(params) {
   //function body
}

The Chinese translation of

Example

is:

Example

#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;
}

Output

The value of Test1 object is: 55

in conclusion

When we access private data members of a class, it is best to use accessor/getter and modifier/setter functions. This is the safest way to access data members of a class. One thing to always remember is that functions that access private members should be declared public. Friend functions are not available in other object-oriented languages ​​because this does not always preserve the properties of object-oriented encapsulation. The friend relationship is asymmetric. If class A declares class B as a friend, then class B will have access to all members of A, but A will not be able to access all private members of B.

The above is the detailed content of C++ program access private members of class. For more information, please follow other related articles on the PHP Chinese website!