Skip to main content

Private, Protected and Public Members

 In C++ Object-Oriented Programming (OOP), access specifiers control how members (data and functions) of a class can be accessed from different parts of your program. These are crucial for understanding data encapsulation and promoting secure object-oriented design.

Access Specifiers:

  1. Public: Members are accessible from anywhere in your program, including outside the class, its subclasses, and friend functions. Use them cautiously to avoid exposing internal implementation details unnecessarily.
  2. Private: Members are accessible only within the class and its friend functions. This promotes data encapsulation and protects data integrity by restricting direct access from outside.
  3. Protected: Members are accessible within the class, its subclasses, and their friend functions. Useful for inheritance scenarios where subclasses need controlled access to base class members.

Benefits of Each:

  • Public: Provides direct access and flexibility but can lead to tighter coupling and potential misuse.
  • Private: Enforces data encapsulation, improves data integrity, and promotes modularity.
  • Protected: Enables controlled inheritance and code reuse while maintaining some level of protection.

Choosing the Right Access Specifier:

  • Default: Members are private by default. Make members public only when their accessibility is essential for the class's intended use.
  • Private: Prefer private for data members to enforce encapsulation and protect internal state. Public data members should be rare and carefully considered.
  • Protected: Use protected members when controlled inheritance and sharing between base and derived classes are necessary.

Example:

C++
class Account {
private:
    double balance; // Private data member
public:
    void deposit(double amount) { balance += amount; } // Public member function
    double getBalance() const { return balance; } // Public const member function (doesn't modify state)
protected:
    void calculateInterest() { /* Protected member function accessible only in Account and its subclasses */ }
};

class SavingsAccount : public Account {
public:
    void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        }
    }
    // Can access calculateInterest() due to inheritance
};
Use code with caution.

Remember:

  • Access specifiers are essential for good OOP design and data security.
  • Start with private by default and make members public or protected only when necessary.
  • Consider the implications of each access specifier on code maintainability and potential misuse.

Example:

class MyClass {
private:
    int privateVar;

public:
    void setPrivateVar(int value) {
        privateVar = value;
    }

    int getPrivateVar() {
        return privateVar;
    }
};

Example:

class Base {
protected:
    int protectedVar;

public:
    void setProtectedVar(int value) {
        protectedVar = value;
    }
};

class Derived : public Base {
public:
    void accessProtectedVar() {
        protectedVar = 10; // Accessible in derived class
    }
};

Example:

#include <iostream>

class Base {
private:
    int privateVar;
protected:
    int protectedVar;
public:
    int publicVar;

    Base() : privateVar(1), protectedVar(2), publicVar(3) {}

    void accessMembers() {
        std::cout << "Private member: " << privateVar << std::endl;  // Accessible within the class
        std::cout << "Protected member: " << protectedVar << std::endl;  // Accessible within the class
        std::cout << "Public member: " << publicVar << std::endl;  // Accessible anywhere
    }
};

class Derived : public Base {
public:
    void accessBaseMembers() {
        // std::cout << privateVar << std::endl;  // Error: private member inaccessible
        std::cout << "Protected member in derived class: " << protectedVar << std::endl;  // Accessible in derived class
        std::cout << "Public member in derived class: " << publicVar << std::endl;  // Accessible in derived class
    }
};

int main() {
    Base objBase;
    objBase.accessMembers();

    Derived objDerived;
    objDerived.accessBaseMembers();

    return 0;
}


Comments

Post a Comment

Popular posts from this blog

C++ Variable

C++ Variables: Named Storage Units In C++, variables serve as named boxes in memory that hold values during program execution. Each variable has three key aspects: 1. Data Type: Defines the kind of data a variable can store: numbers (integers, floating-point, etc.), characters, boolean values (true/false), or custom data structures (arrays, objects). Common data types: int : Whole numbers (e.g., -10, 0, 23) float : Decimal numbers (e.g., 3.14, -2.5) double : More precise decimal numbers char : Single characters (e.g., 'a', 'Z', '&') bool : True or false values 2. Name: A user-defined label for the variable, chosen according to naming conventions: Start with a letter or underscore. Contain letters, digits, and underscores. Case-sensitive (e.g.,  age  and  Age  are different). Not a reserved keyword (e.g.,  int ,  for ). Choose meaningful names that reflect the variable's purpose. 3. Value: The actual data stored in the variable, which must match its data...
Post a Comment
Read more

C++ Functions

C++ Functions A function is a block of code that performs a specific task. Suppose we need to create a program to create a circle and color it. We can create two functions to solve this problem: a function to draw the circle a function to color the circle Dividing a complex problem into smaller chunks makes our program easy to understand and reusable. There are two types of function: Standard Library Functions:  Predefined in C++ User-defined Function:  Created by users In this tutorial, we will focus mostly on user-defined functions. C++ User-defined Function C++ allows the programmer to define their own function. A user-defined function groups code to perform a specific task and that group of code is given a name (identifier). When the function is invoked from any part of the program, it all executes the codes defined in the body of the function. C++ Function Declaration The syntax to declare a function is: returnType functionName (parameter1, parameter2,...) { // func...
Post a Comment
Read more

C++ Type Conversion

In C++, type conversion, also known as type casting, allows you to change the data type of a variable. This can be useful for various purposes, but it's important to understand the potential risks and use it cautiously. Here's a breakdown of C++ type conversion: Types of Type Conversion: Implicit Conversion: Done automatically by the compiler when necessary. Common cases: Promoting smaller integer types to larger ones (e.g.,  int  to  float ). Converting characters to integer equivalents (e.g.,  'A'  to  65 ). Assigning expressions with mixed types to a variable of higher precedence (e.g.,  int result = age + 3.14; ). Explicit Conversion: Done manually by the programmer using different methods: C-style casting:   (data_type) expression;  (e.g.,  int age = (int) 3.14; ). Functional notation:   static_cast<data_type>(expression);  (e.g.,  int age = static_cast<int>(3.14); ). Type conversion operators: dynamic_cas...
Post a Comment
Read more