C++ 类之访问控制

在C++中，访问控制（Access Control）是指控制类成员（变量和函数）的访问权限。访问控制通过访问说明符（Access Specifiers）来实现，主要有以下三种：

1. public：公有访问权限
2. protected：受保护访问权限
3. private：私有访问权限

此外，C++还提供了友元函数和友元类机制，以允许特定的非成员函数或类访问类的私有和受保护成员。

1. public 访问权限

• 描述：公有成员可以在类的外部被访问。
• 应用场景：用于需要在类的外部访问的成员，如接口函数。

示例

class MyClass {
public:
    int publicVar;

    void publicMethod() {
        // 公有方法
    }
};

int main() {
    MyClass obj;
    obj.publicVar = 10; // 访问公有成员变量
    obj.publicMethod(); // 调用公有成员函数
    return 0;
}

2. protected 访问权限

• 描述：受保护成员可以在类的内部和派生类中被访问，但不能在类的外部被访问。
• 应用场景：用于需要在派生类中访问但不希望在类的外部访问的成员。

示例

class Base {
protected:
    int protectedVar;

    void protectedMethod() {
        // 受保护方法
    }
};

class Derived : public Base {
public:
    void accessProtected() {
        protectedVar = 10; // 访问基类的受保护成员变量
        protectedMethod(); // 调用基类的受保护成员函数
    }
};

int main() {
    Derived obj;
    obj.accessProtected();
    // obj.protectedVar = 10; // 错误：不能在类的外部访问受保护成员
    // obj.protectedMethod(); // 错误：不能在类的外部调用受保护成员函数
    return 0;
}

3. private 访问权限

• 描述：私有成员仅可以在类的内部被访问，不能在类的外部或派生类中被访问。
• 应用场景：用于仅在类的内部访问的成员，通常用于实现细节。

示例

class MyClass {
private:
    int privateVar;

    void privateMethod() {
        // 私有方法
    }

public:
    void accessPrivate() {
        privateVar = 10; // 访问私有成员变量
        privateMethod(); // 调用私有成员函数
    }
};

int main() {
    MyClass obj;
    obj.accessPrivate();
    // obj.privateVar = 10; // 错误：不能在类的外部访问私有成员
    // obj.privateMethod(); // 错误：不能在类的外部调用私有成员函数
    return 0;
}

4. 友元函数和友元类

• 友元函数：非成员函数，但被授予访问类的私有和受保护成员的权限。常用于操作符重载和辅助函数。
• 友元类：一个类，被授予访问另一个类的私有和受保护成员的权限。常用于紧密耦合的类之间的合作。

友元函数示例

class MyClass {
private:
    int privateVar;

public:
    MyClass(int x) : privateVar(x) {}

    // 声明友元函数
    friend void printPrivateVar(const MyClass& obj);
};

// 定义友元函数
void printPrivateVar(const MyClass& obj) {
    std::cout << "Private variable: " << obj.privateVar << std::endl;
}

int main() {
    MyClass obj(10);
    printPrivateVar(obj); // 调用友元函数
    return 0;
}

友元类示例

class MyClass {
private:
    int privateVar;

public:
    MyClass(int x) : privateVar(x) {}

    // 声明友元类
    friend class FriendClass;
};

class FriendClass {
public:
    void printPrivateVar(const MyClass& obj) {
        std::cout << "Private variable: " << obj.privateVar << std::endl;
    }
};

int main() {
    MyClass obj(10);
    FriendClass friendObj;
    friendObj.printPrivateVar(obj); // 调用友元类的方法
    return 0;
}

5. 访问控制的继承关系

在继承关系中，基类的访问控制会影响派生类对基类成员的访问权限。继承方式有三种：public 继承、protected 继承和 private 继承。

public 继承

• 基类的 public 成员在派生类中仍然是 public。
• 基类的 protected 成员在派生类中仍然是 protected。

protected 继承

• 基类的 public 成员在派生类中变为 protected。
• 基类的 protected 成员在派生类中仍然是 protected。

private 继承

• 基类的 public 和 protected 成员在派生类中都变为 private。

示例

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

class PublicDerived : public Base {
    // publicVar 是 public
    // protectedVar 是 protected
    // privateVar 不能访问
};

class ProtectedDerived : protected Base {
    // publicVar 是 protected
    // protectedVar 是 protected
    // privateVar 不能访问
};

class PrivateDerived : private Base {
    // publicVar 是 private
    // protectedVar 是 private
    // privateVar 不能访问
};

总结

• **public**：公有访问权限，允许类的成员在类的外部被访问。
• **protected**：受保护访问权限，允许类的成员在类的内部和派生类中被访问。
• **private**：私有访问权限，允许类的成员仅在类的内部被访问。
• 友元函数和友元类：允许特定的非成员函数或类访问类的私有和受保护成员。
• 继承关系中的访问控制：基类的访问控制会影响派生类对基类成员的访问权限，具体取决于继承方式（public、protected、private）。