Access specifiers in C++ determine the visibility and accessibility of class members. There are three main access specifiers: `private`, `public`, and `protected`. They control how members of a class can be accessed from outside the class or from derived classes.
1. Private Access Specifier:
- Members declared as `private` are only accessible within the class itself. They cannot be accessed directly by objects of the class or by derived classes.
- Example:
```cpp
class MyClass {
private:
int privateMember;
public:
// Public member function can access private member
void setPrivateMember(int value) {
privateMember = value;
}
};
```
2. Public Access Specifier:
- Members declared as `public` are accessible from outside the class. They can be accessed by objects of the class and by other classes.
- Example:
```cpp
class MyClass {
public:
int publicMember;
// Public member function
void displayInfo() {
cout << "Public Member: " << publicMember << endl;
}
};
```
3. Protected Access Specifier:
- Members declared as `protected` are similar to `private` members but have additional visibility in derived classes.
- They can be accessed by member functions of the same class and by member functions of derived classes.
- Example:
```cpp
class BaseClass {
protected:
int protectedMember;
};
class DerivedClass : public BaseClass {
public:
void setProtectedMember(int value) {
protectedMember = value; // Accessing protected member in derived class
}
};
```
Access specifiers provide a way to implement encapsulation and control the visibility of class members. The choice of access specifier depends on the design of the class and the desired level of encapsulation. By default, members are `private` if no access specifier is specified.
Here's a simple example combining `private`, `public`, and `protected` access specifiers:
#include <iostream>
class MyClass {
private:
int privateMember;
public:
int publicMember;
protected:
int protectedMember;
public:
void setPrivateMember(int value) {
privateMember = value;
}
void setProtectedMember(int value) {
protectedMember = value;
}
void displayInfo() {
cout << "Private Member: " << privateMember << ", Public Member: " << publicMember << ", Protected Member: " << protectedMember << endl;
}
};
int main() {
MyClass obj;
obj.setPrivateMember(42);
obj.publicMember = 10;
obj.setProtectedMember(99);
obj.displayInfo();
return 0;
}
```
In this example, `privateMember` is private and can only be accessed within the class, `publicMember` is public and can be accessed from outside the class, and `protectedMember` is protected and can be accessed in derived classes.
Comments
Post a Comment