What is the difference between private and protected members of C++ classes?

The primary difference between private and protected members in C++ lies in their accessibility within a class hierarchy. Both private and protected members are not accessible outside the class by default, but they differ in their behavior when it comes to inheritance.

Differences Between Private and Protected Members

1. Accessibility

• Private Members:
  • Can only be accessed within the class where they are defined.
  • They are not accessible in derived classes, even through inheritance.
• Protected Members:
  • Can be accessed within the class where they are defined, as well as in derived classes.

Example:

#include <iostream>
using namespace std;

class Base {
private:
    int privateVar = 10; // Private
protected:
    int protectedVar = 20; // Protected
public:
    int getPrivateVar() const {
        return privateVar; // Can only access within the class
    }
};

class Derived : public Base {
public:
    void accessMembers() {
        // cout << privateVar; // Error: privateVar is not accessible
        cout << "Protected Var: " << protectedVar << endl; // Accessible
    }
};

int main() {
    Derived d;
    d.accessMembers(); // Output: Protected Var: 20
    // cout << d.privateVar; // Error: privateVar is not accessible
    // cout << d.protectedVar; // Error: protectedVar is not accessible outside the class or derived class
}

2. Visibility in Inheritance

• Private Members:

  • Private members remain inaccessible to derived classes regardless of the type of inheritance (public, protected, or private).

• Protected Members:

  • Protected members remain accessible to derived classes but are not accessible to non-member functions or objects.

3. Use Cases

• Private:

  • Use for members that should not be accessible outside the defining class. These are implementation details that should remain encapsulated.
  • Example: Internal helper methods or sensitive data.

• Protected:

  • Use when you want to allow derived classes to access or modify the member but still prevent direct access from outside the class hierarchy.
  • Example: Base class members that subclasses need to work with but should not expose publicly.

Access Levels Summary

Example of Inheritance with Protected Members

class Base {
protected:
    int protectedVar = 42;
};

class Derived : public Base {
public:
    void printProtectedVar() {
        cout << "Protected Var: " << protectedVar << endl; // Accessible
    }
};

int main() {
    Derived obj;
    obj.printProtectedVar(); // Output: Protected Var: 42
    // cout << obj.protectedVar; // Error: Not accessible outside the class
}

Best Practices

1. Use private for encapsulation of internal details that no other class should access.
2. Use protected when designing class hierarchies where derived classes need controlled access to base class members.
3. Avoid overusing protected unless inheritance explicitly requires it, as it weakens encapsulation compared to private.

By understanding these distinctions, you can design robust and secure class hierarchies in C++. For deeper insights into object-oriented programming, explore Grokking Advanced Coding Patterns for Interviews or Grokking System Design Fundamentals on DesignGurus.io!