public：（开放性最强）

• public成员可以在类的内部和外部被访问。
• public成员可以被类的对象、类的成员函数和类的友元函数访问。

  class MyClass {
  public:
      int publicVar;
      void publicFunc() {
         
          cout << "可以访问函数publicFunc()" << endl;
      }
  };
  int main()
  {
      MyClass p;
      p.publicFunc();
  
  }

  private：(局限性最强)

• private成员只能在类的内部被访问。
• private成员只能被类的成员函数和类的友元函数访问。

• class MyClass {
  private:
      int privateVar;
      void privateFunc() {
          privateVar = 100;// 不报错，类内可以访问privateVar
      }
  };
  class ThemClass : public MyClass {
  public:
      void test()
      {
          //privateVar = 100;报错，在派生类内部不可以访问
      }
  };
  class YOUClass {
  public:
      MyClass p2;
      void Func()
      {
          //p2.privateFunc();报错，类外不可以访问
      }
  };
  int main()
  {
      MyClass p;
      //p.privateFunc();//报错，类外不可以访问
  }

protected：

• protected成员可以在类的内部被访问。
• protected成员可以被类的成员函数、类的派生类和类的友元函数访问。

class Base {
    friend class friendclass;//友元函数
private:
    int privateVar;     // 私有成员变量

protected:
    int protectedVar;   // 受保护成员变量

public:
    void publicMethod() {
        privateVar = 10;         // 在类内部可以访问私有成员变量
        protectedVar = 20;       // 在类内部可以访问受保护成员变量
    }
};
class friendclass {

public:
    void test() {
        Base p;
        p.privateVar = 100;//友元函数可以访问privateVar
        p.protectedVar = 50;//友元函数可以访问protectedVar
    }
    
};

class Derived : public Base {
public:
    void derivedMethod() {
        //privateVar = 30;         // 错误！无法访问私有成员变量
        protectedVar = 40;       // 在派生类内部可以访问受保护成员变量
    }
};

int main() {
    Base b;
    //b.privateVar = 50;     // 错误！无法访问私有成员变量
    //b.protectedVar = 60;   // 错误！无法访问受保护成员变量

    Derived d;
    //d.protectedVar = 70;   // 错误！无法访问受保护成员变量

    return 0;
}

区别在于：

• public成员可以被类的外部访问，private成员只能在类的内部访问，protected成员可以被派生类访问。
• private成员和protected成员都不能被类的外部访问，但private成员只能被当前类的成员函数和友元函数访问，而protected成员还可以被派生类访问。