C++ visibility可见性

在C++中，可见性（Visibility）主要指的是类成员（成员变量和成员函数）的访问权限。
C++提供了三种访问控制修饰符来管理类成员的可见性：public、protected和private。这些修饰符决定了类成员在类外部和派生类中的可见性和访问权限。

1. public 可见性

公有成员（Public Members）：可以被任何代码访问，包括类外部和派生类。

class MyClass {
public:
    int publicVar;

    void publicMethod() {
        // 可以在类内部访问
    }
};

int main() {
    MyClass obj;
    obj.publicVar = 10; // 可以在类外部访问
    obj.publicMethod(); // 可以在类外部访问
    return 0;
}

2. protected 可见性

保护成员（Protected Members）：只能被类内部和派生类访问，不能被类外部的代码直接访问。

class Base {
protected:
    int protectedVar;

    void protectedMethod() {
        // 可以在类内部访问
    }
};

class Derived : public Base {
public:
    void accessProtected() {
        protectedVar = 10; // 可以在派生类中访问
        protectedMethod(); // 可以在派生类中访问
    }
};

int main() {
    Base obj;
    // obj.protectedVar = 10; // 错误：不能在类外部访问
    // obj.protectedMethod(); // 错误：不能在类外部访问
    return 0;
}

3. private 可见性

私有成员（Private Members）：只能被类内部访问，不能被类外部和派生类直接访问。

class MyClass {
private:
    int privateVar;

    void privateMethod() {
        // 可以在类内部访问
    }

public:
    void accessPrivate() {
        privateVar = 10; // 可以在类内部访问
        privateMethod(); // 可以在类内部访问
    }
};

int main() {
    MyClass obj;
    // obj.privateVar = 10; // 错误：不能在类外部访问
    // obj.privateMethod(); // 错误：不能在类外部访问
    obj.accessPrivate(); // 可以通过公有方法访问私有成员
    return 0;
}

4. 类和结构体的默认访问控制

• 类（class）：默认的访问控制是private。
• 结构体（struct）：默认的访问控制是public。

class MyClass {
    // 默认是 private
    int privateVar; // private
};

struct MyStruct {
    // 默认是 public
    int publicVar; // public
};

5. 友元（Friend）

友元（friend）关键字可以让非成员函数或其他类访问类的私有和保护成员。

class MyClass {
private:
    int privateVar;

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

void accessPrivate(MyClass& obj) {
    obj.privateVar = 10; // 可以访问私有成员
}

int main() {
    MyClass obj;
    accessPrivate(obj); // 可以通过友元函数访问私有成员
    return 0;
}

综合应用示例：

#include <iostream>

class Base {
public:
    int publicVar;

protected:
    int protectedVar;

private:
    int privateVar;

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

    void show() {
        std::cout << "Base publicVar: " << publicVar << std::endl;
        std::cout << "Base protectedVar: " << protectedVar << std::endl;
        std::cout << "Base privateVar: " << privateVar << std::endl;
    }
};

class Derived : public Base {
public:
    void accessBaseMembers() {
        publicVar = 10; // 可以访问公有成员
        protectedVar = 20; // 可以访问保护成员
        // privateVar = 30; // 错误：不能访问私有成员
    }
};

int main() {
    Base base;
    base.show();

    Derived derived;
    derived.accessBaseMembers();
    derived.show();

    // base.publicVar = 100; // 可以在类外部访问公有成员
    // base.protectedVar = 200; // 错误：不能在类外部访问保护成员
    // base.privateVar = 300; // 错误：不能在类外部访问私有成员

    return 0;
}

输出：

Base publicVar: 1
Base protectedVar: 2
Base privateVar: 3
Base publicVar: 10
Base protectedVar: 20
Base privateVar: 3

总结

• public：公有成员可以被任何代码访问，包括类外部和派生类。
• protected：保护成员只能被类内部和派生类访问，不能被类外部的代码直接访问。
• private：私有成员只能被类内部访问，不能被类外部和派生类直接访问。
• 友元（friend）：友元函数或友元类可以访问类的私有和保护成员。
• 默认访问控制：类的默认访问控制是private，结构体的默认访问控制是public。