public, private, protected 访问权限

在C++中，封装（Encapsulation）是面向对象编程的一个基本概念。它通过将数据和方法封装在类中来隐藏内部实现细节，并通过访问控制来保护数据的完整性和安全性。C++提供了三种访问控制权限：public、private 和 protected。下面详细介绍这三种访问权限及其用法。

public 访问权限

public 成员可以被任何地方访问，不受访问限制。它们通常用于接口部分，即希望在类外部访问的方法和数据成员。

示例代码：

#include <iostream>

class MyClass {
public:
    int publicVar;

    void publicMethod() {
        std::cout << "Public method called. PublicVar = " << publicVar << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.publicVar = 42;          // 可以直接访问 public 成员
    obj.publicMethod();          // 可以直接调用 public 方法
    return 0;
}

private 访问权限

private 成员只能在类的内部访问，类的外部无法直接访问。它们通常用于隐藏类的内部实现细节，只能通过类的公有接口进行访问。

示例代码：

#include <iostream>

class MyClass {
private:
    int privateVar;

    void privateMethod() {
        std::cout << "Private method called. PrivateVar = " << privateVar << std::endl;
    }

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

    void showPrivateVar() {
        privateMethod();
    }
};

int main() {
    MyClass obj;
    // obj.privateVar = 42;     // 错误：不能直接访问 private 成员
    // obj.privateMethod();     // 错误：不能直接调用 private 方法
    obj.setPrivateVar(42);       // 通过 public 方法间接访问 private 成员
    obj.showPrivateVar();        // 通过 public 方法间接调用 private 方法
    return 0;
}

protected 访问权限

protected 成员可以在类的内部和派生类中访问，但不能在类的外部访问。它们通常用于基类和派生类之间的共享实现细节。

示例代码：

#include <iostream>

class Base {
protected:
    int protectedVar;

    void protectedMethod() {
        std::cout << "Protected method called. ProtectedVar = " << protectedVar << std::endl;
    }
};

class Derived : public Base {
public:
    void accessProtectedMember() {
        protectedVar = 42;      // 可以在派生类中访问 protected 成员
        protectedMethod();      // 可以在派生类中调用 protected 方法
    }
};

int main() {
    Derived obj;
    // obj.protectedVar = 42;   // 错误：不能在类的外部访问 protected 成员
    // obj.protectedMethod();   // 错误：不能在类的外部调用 protected 方法
    obj.accessProtectedMember(); // 通过派生类的方法访问 protected 成员
    return 0;
}

访问控制总结
public：公共访问权限，任何地方都可以访问。
private：私有访问权限，只能在类的内部访问，外部无法直接访问。
protected：保护访问权限，可以在类的内部和派生类中访问，外部无法直接访问。
访问控制的应用
通过访问控制，可以有效地实现数据封装，隐藏内部实现细节，保护数据的完整性和安全性。同时，访问控制也支持面向对象编程中的继承和多态机制。以下是一个综合示例，展示了如何在实际应用中使用访问控制：

#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    int age;

protected:
    std::string getName() const {
        return name;
    }

    int getAge() const {
        return age;
    }

public:
    Person(const std::string& n, int a) : name(n), age(a) {}

    void display() const {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

class Student : public Person {
private:
    int studentID;

public:
    Student(const std::string& n, int a, int id) : Person(n, a), studentID(id) {}

    void showDetails() const {
        // 可以访问基类的 protected 成员函数
        std::cout << "Student Name: " << getName() << ", Age: " << getAge() << ", ID: " << studentID << std::endl;
    }
};

int main() {
    Person person("Alice", 30);
    person.display();

    Student student("Bob", 20, 12345);
    student.showDetails();

    return 0;
}

在这个示例中，Person 类的成员 name 和 age 是私有的，不能直接在类外部访问。Student 类继承了 Person 类，可以访问其受保护的成员函数 getName 和 getAge，从而实现数据的访问和显示。这展示了封装和访问控制的有效应用。