C++学习——访问限定符

在C++中，protected, friend, 和 public 是访问限定符，用于指定类成员的访问级别。

访问限定符

public

public 成员可以从类的任何地方访问，包括类的外部。这通常是你希望外部代码能够直接访问和操作的那些方法和属性。比如，一个类的大多数接口（APIs）都会被声明为 public。

class Base {
private:
    int privateVar; // 只有Base的成员函数可以访问
};

class Derived : public Base {
    void func() {
        // cout << privateVar; // 错误：无法访问Base的private成员
    }
};

protected

protected 成员在类的内部和派生类（子类）中是可见的，但不能从类的外部直接访问。这对于在继承中隐藏实现细节但仍允许子类访问这些细节很有用。

class MyClass {
protected:
    int protectedData; // 只有MyClass的实例和它的子类可以访问
};

private

private 成员只能被类的其他成员（方法或属性）访问，不能从类的外部访问。这是封装的核心概念，意味着类可以隐藏它的内部状态和实现细节。

class MyClass {
private:
    int privateData; // 只有MyClass的方法可以访问
};

friend

friend 关键字允许一个特定的类或函数访问另一个类的 private 或 protected 成员。它通常用于允许两个或更多的类共享实现细节，同时对其他类隐藏这些细节。

class MyClass {
    friend class FriendClass; // FriendClass可以访问MyClass的所有成员

private:
    int privateData; // 私有数据
};

private 和 protect 的区别

private 和 protected 是类成员的两种访问控制级别，在C++中用来实现封装和继承控制。它们之间的主要区别在于从派生类（子类）访问这些成员时的权限。但是friend类既可以访问private，又可以访问protect

private

当成员被声明为 private 时，它们只能被包含它们的类的函数访问。这意味着即使是继承自该类的子类也无法访问 private 成员。private 是类成员的默认访问级别，如果没有指定访问控制关键字，则成员将被认为是私有的。

class Base {
private:
    int privateVar; // 只有Base的成员函数可以访问
};

class Derived : public Base {
    void func() {
        // cout << privateVar; // 错误：无法访问Base的private成员
    }
};

protected

protected 成员类似于 private 成员，但它们提供了一个额外的权限：被声明为 protected 的成员不仅可以被包含它们的类访问，还可以被派生类访问。然而，即使是 protected 成员，也不能从包含它们的类的对象外部访问。

class Base {
protected:
    int protectedVar; // Base的成员和派生自Base的类可以访问
};

class Derived : public Base {
    void func() {
        cout << protectedVar; // 正确：可以访问Base的protected成员
    }
};

示例

#include 
using namespace std;

// 基类
class Base {
private:
    int privateVar; // 基类的私有成员，只能被基类访问

protected:
    int protectedVar; // 基类的受保护成员，可以被派生类访问

public:
    Base() : privateVar(0), protectedVar(0) {} // 构造函数初始化成员变量

    void setPrivateVar(int val) { privateVar = val; } // 设置私有变量的公共函数
    void setProtectedVar(int val) { protectedVar = val; } // 设置受保护变量的公共函数

    int getPrivateVar() const { return privateVar; } // 获取私有变量的公共函数
};

// 派生类
class Derived : public Base {
public:
    void setDerivedProtectedVar(int val) {
        // 设置从基类继承的受保护成员变量
        protectedVar = val;
    }

    int getDerivedProtectedVar() const {
        // 获取从基类继承的受保护成员变量
        return protectedVar;
    }

    void tryAccessPrivateVar() {
        // cout << privateVar; // 错误：派生类无法访问基类的私有成员
    }
};

int main() {
    Base b;
    Derived d;

    // b.privateVar = 1; // 错误：无法直接访问私有成员
    b.setPrivateVar(1); // 正确：通过公共接口设置私有成员
    cout << b.getPrivateVar() << endl; // 正确：通过公共接口获取私有成员的值

    // d.protectedVar = 2; // 错误：无法直接访问受保护成员
    d.setDerivedProtectedVar(2); // 正确：通过派生类的公共接口设置受保护成员
    cout << d.getDerivedProtectedVar() << endl; // 正确：通过派生类的公共接口获取受保护成员的值

    return 0;
}

在这段代码中，Base 类有两个成员变量：privateVar 和 protectedVar。privateVar 为私有成员，只能通过 Base 类的成员函数进行访问和修改。protectedVar 为受保护成员，它可以被派生类 Derived 直接访问和修改。

Derived 类继承了 Base 类，并尝试通过其成员函数 setDerivedProtectedVar 来修改 protectedVar。这是允许的，因为 protectedVar 在 Base 类中是受保护的。然而，Derived 类无法访问 Base 类的 privateVar，即使通过成员函数 tryAccessPrivateVar 尝试也不行。

在 main 函数中，我们创建了 Base 和 Derived 的对象，并展示了如何通过公共接口来设置和获取私有和受保护的成员变量。直接访问这些变量的尝试将会导致编译错误。