Understanding Public and Private Access Specifiers in C++
Table of Contents:
- Introduction
- Public Access Specifier
- Example of Public Access Specifier
- Benefits of Using Public Access Specifier
- Limitations of Using Public Access Specifier
- Private Access Specifier
- Example of Private Access Specifier
- Benefits of Using Private Access Specifier
- Limitations of Using Private Access Specifier
- Using Getter and Setter Functions
- Get Salary and Set Salary Functions
- Benefits of Using Getter and Setter Functions
- Example of Using Getter and Setter Functions
- Information Hiding and Encapsulation
- Meaning of Information Hiding
- Advantages of Information Hiding
- Encapsulation in Object-Oriented Programming
- Private Member Functions
- Example of Private Member Functions
- Purpose of Private Member Functions
- Implementing a Bonus Calculation Function
- Creating a Private Member Function for Bonus Calculation
- Making the Bonus Calculation Function Public
- Example of Using the Bonus Calculation Function
- Conclusion
📝 Public and Private Access Specifiers in C++
C++ provides two access specifiers, namely public and private, to modify the accessibility of the members (variables and functions) inside a class. In this article, we will explore the differences between these access specifiers and understand their implications in class design.
🌟 Public Access Specifier
The public access specifier allows the members of a class to be used and accessed outside of the class definition. This means that the member variables and functions declared as public can be accessed and modified by objects of the class.
Example of Public Access Specifier
Let's consider an example where we create a class called "Employee" to represent employees. We will use the public access specifier to declare a string member variable called "name". This allows us to access and assign a value to the "name" variable from outside the class.
class Employee {
public:
string name;
};
By using the public access specifier, we can access the "name" member variable outside the class definition and modify it as needed:
Employee emp1;
emp1.name = "Kevin";
cout << emp1.name; // Output: Kevin
Benefits of Using Public Access Specifier
- Allows easy access to member variables and functions from outside the class.
- Enables flexibility in modifying and using class members.
Limitations of Using Public Access Specifier
- Can lead to potential security and integrity issues if member variables are modified directly without proper validation.
- May break encapsulation principles if member variables are exposed and manipulated directly.
🔒 Private Access Specifier
The private access specifier restricts the accessibility of the members to within the class definition only. This means that the member variables and functions declared as private can only be accessed and modified by other member functions of the class.
Example of Private Access Specifier
Let's extend our previous example by adding a private member variable called "salary" to the "Employee" class. This member variable will store the salary of the employee, but it cannot be accessed or modified outside the class.
class Employee {
public:
string name;
private:
double salary;
};
If we try to access the private member variable "salary" outside the class, we will encounter a compiler error:
Employee emp1;
emp1.salary = 50000; // Compiler Error: 'salary' is a private member of 'Employee'
Benefits of Using Private Access Specifier
- Protects member variables from direct modification, ensuring data integrity.
- Prevents unauthorized access to sensitive class information.
Limitations of Using Private Access Specifier
- Requires the use of getter and setter functions to access and modify private member variables.
- Can add complexity to the code structure due to the need for additional functions.
🔍 Using Getter and Setter Functions
To work with private member variables and maintain encapsulation, we often use getter and setter functions. Getter functions retrieve the value of a private member variable, while setter functions modify the value of a private member variable.
Get Salary and Set Salary Functions
In our "Employee" class example, we can define getter and setter functions for the private member variable "salary":
class Employee {
public:
string name;
double getSalary() {
return salary;
}
void setSalary(double potentialSalary) {
if (potentialSalary >= 0) {
salary = potentialSalary;
} else {
salary = 0;
}
}
private:
double salary;
};
These functions provide controlled access to the private member variable "salary" and allow us to validate and modify the value before assignment.
Benefits of Using Getter and Setter Functions
- Ensures controlled access to private member variables.
- Enables validation and manipulation of data before assignment.
- Facilitates information hiding and encapsulation.
Example of Using Getter and Setter Functions
We can now use the getter and setter functions to access and modify the private member variable "salary":
Employee emp1;
emp1.setSalary(50000);
cout << emp1.getSalary(); // Output: 50000
By using the getter and setter functions, we can retrieve the value of "salary" and modify it with proper validation.
🛡️ Information Hiding and Encapsulation
Information hiding is a concept where a class exposes only necessary information (members and functions) to the outside world and hides the implementation details. It promotes encapsulation, which is a fundamental principle of object-oriented programming.
Meaning of Information Hiding
By hiding implementation details, such as private member variables and private member functions, we ensure that the class remains a black box to the outside world. The class interface, consisting of public member variables and functions, defines how the class is used and interacted with.
Advantages of Information Hiding
- Improves code maintainability and reduces dependencies between different parts of the codebase.
- Protects sensitive information or variables from direct access and manipulation.
- Allows flexibility in modifying the class implementation without affecting external code.
Encapsulation in Object-Oriented Programming
Encapsulation is achieved by combining information hiding and the use of access specifiers. In C++, the public and private access specifiers play a vital role in implementing encapsulation.
🤝 Private Member Functions
Similar to private member variables, we can also create private member functions in a class. Private member functions can only be accessed and called within the class definition.
Example of Private Member Functions
Let's create a private member function called "calculateBonus" in our "Employee" class. This function will calculate and return the annual bonus based on the employee's salary.
class Employee {
public:
string name;
void printBonus() {
cout << name << " Bonus: " << calculateBonus() << endl;
}
private:
double salary;
double calculateBonus() {
return salary * 0.10; // 10% of the salary
}
};
Due to the private access specifier, we cannot directly call the "calculateBonus" function outside the class. Instead, we can create a public member function, like "printBonus", that internally calls the private member function.
💼 Implementing a Bonus Calculation Function
Let's see how the private member function "calculateBonus" can be used within the class to calculate and display the employee's bonus.
Employee emp1;
emp1.setSalary(50000);
emp1.printBonus(); // Output: Kevin Bonus: 5000
By utilizing a public member function that internally utilizes private member functions, we can effectively create a structured and protected way of accessing and manipulating class-related information.
📚 Conclusion
Understanding the differences between the public and private access specifiers in C++ is crucial for building well-structured classes. The public access specifier allows easy access to class members, while the private access specifier enforces encapsulation and data integrity. By utilizing getter and setter functions and private member functions, we can control and safeguard class information effectively.
For more advanced C++ topics, visit checoportfoliocourses.com, where we'll help you build a portfolio that will impress employers.
Resources:
