C++ Access Specifiers and Encapsulation

 

Access Specifiers

By now, you are quite familiar with the public keyword that appears in all of our class examples:

अब तक, आप public keyword से काफी परिचित हो चुके हैं जो हमारे सभी class उदाहरणों में दिखाई देता है:

Example

class MyClass {  // The class
  public:        // Access specifier
    // class members goes here
};

The public keyword is an access specifier. Access specifiers define how the members (attributes and methods) of a class can be accessed. In the example above, the members are public - which means that they can be accessed and modified from outside the class.

However, what if we want members to be private and hidden from the outside world?

In C++, there are three access specifiers:

• public - members are accessible from outside the class
• private - members cannot be accessed (or viewed) from outside the class
• protected - members cannot be accessed from outside the class, but, they can be accessed in inherited classes.

In the following example, we demonstrate the differences between public and private members:

public keyword एक access specifier है। access specifier define करते हैं कि किसी class के members (attributes और methods) को कैसे access किया जा सकता है। उपरोक्त उदाहरण में, member public हैं - जिसका अर्थ है कि उन्हें class के बाहर से access और modify किया जा सकता है।

हालाँकि, क्या होगा यदि हम चाहते हैं कि member private हों और बाहरी दुनिया से छिपे हों?

C++ में, तीन access specifier हैं:

• public - member को class के बाहर से access किया जा सकती है

• private - member को class के बाहर से access नहीं किया जा सकता (या देखा नहीं जा सकता)।

• protected - members को class के बाहर से access नहीं किया जा सकता है, लेकिन, उन्हें inherited class में access किया जा सकता है।

निम्नलिखित उदाहरण में, हम public और protected members के बीच difference प्रदर्शित करते हैं:

Example

class MyClass {
  public:    // Public access specifier
    int x;   // Public attribute
  private:   // Private access specifier
    int y;   // Private attribute
};

int main() {
  MyClass myObj;
  myObj.x = 25;  // Allowed (public)
  myObj.y = 50;  // Not allowed (private)
  return 0;
}

If you try to access a private member, an error occurs:

error: y is private

 

Note: By default, all members of a class are private if you don't specify an access specifier:

यदि आप access specifier (public, private, protected) को specify नहीं करते हैं तो default रूप से, कक्षा के सभी सदस्य निजी होते हैं:

Example

class MyClass {
  int x;   // Private attribute
  int y;   // Private attribute
};

C++ Encapsulation

Encapsulation

The meaning of Encapsulation, is to make sure that "sensitive" data is hidden from users. To achieve this, you must declare class variables/attributes as private (cannot be accessed from outside the class). If you want others to read or modify the value of a private member, you can provide public get and set methods.

Encapsulation का अर्थ यह सुनिश्चित करना है कि "sensitive" data users से छिपा हुआ है। इसे access करने के लिए, आपको class variables/attributes को private declare करना होगा (class के बाहर से उनको access नहीं किया जा सकता)। यदि आप चाहते हैं कि अन्य लोग किसी private members के value को read या modify करें, तो आप public get और set method use कर सकते हैं।

---

Access Private Members

To access a private attribute, use public "get" and "set" methods:

किसी private attribute को access करने  के लिये, public "get" और "set" methods का उपयोग करें:

Example

#include <iostream>
using namespace std;

class Employee {
  private:
    // Private attribute
    int salary;

  public:
    // Setter
    void setSalary(int s) {
      salary = s;
    }
    // Getter
    int getSalary() {
      return salary;
    }
};

int main() {
  Employee myObj;
  myObj.setSalary(50000);
  cout << myObj.getSalary();
  return 0;
}

Example explained

The salary attribute is private, which have restricted access.

The public setSalary() method takes a parameter (s) and assigns it to the salary attribute (salary = s).

The public getSalary() method returns the value of the private salary attribute.

Inside main(), we create an object of the Employee class. Now we can use the setSalary() method to set the value of the private attribute to 50000. Then we call the getSalary() method on the object to return the value.

salary attribute private है, जिसका access restricted है।

public setSalary() method एक parameter लेती है और इसे salary attribute (salary = s) को specify करती है।

public getSalary() method private salary attribute का value return करता है।

main() के अंदर, हम employee class का एक object बनाते हैं। अब हम private attribute का value 50000 पर set करने के लिए setSalary() method का उपयोग कर सकते हैं। फिर हम value return करने के लिए object पर getSalary() method को call करते हैं।

---

Why Encapsulation?

• It is considered good practice to declare your class attributes as private (as often as you can). Encapsulation ensures better control of your data, because you (or others) can change one part of the code without affecting other parts
• Increased security of data

• अपनी class की attributes को private (जितनी बार संभव हो) declare करना अच्छा अभ्यास माना जाता है। Encapsulation आपके data का बेहतर control सुनिश्चित करता है, क्योंकि आप (या अन्य) अन्य part को प्रभावित किए बिना code के एक हिस्से को बदल सकते हैं

•      data की सुरक्षा बड जाती है