私有成员只能在定义它们的类中访问。

可在定义受保护成员的类中以及从该类继承的类中访问受保护成员。

编辑:两者都可以被其类的友元访问，如果是受保护成员，则可以被其派生类的友元访问。

编辑2:使用任何在你的问题上下文中有意义的东西。您应该尽可能地将成员设为private，以减少耦合并保护基类的实现，但如果不可能，则使用受保护的成员。查看c++常见问题以更好地理解这个问题。这个关于受保护变量的问题可能也有帮助。

与私有属性和方法不同，标记为受保护的属性和方法在子类中仍然可见。

除非您不想在可能的子类中使用或提供重写该方法的可能性，否则我会将它们设为private。

受保护的成员只能由类的后代和同一模块中的代码访问。私有成员只能被声明它们的类以及同一模块中的代码访问。

当然，朋友函数把这个扔出窗外，但是。

私有成员只能从类内部访问，受保护成员可以在类和派生类中访问。这是面向对象语言中继承的一个特性。

在c++中可以有私有、受保护和公共继承，这将决定哪些派生类可以在继承层次结构中访问。例如，c#只有公共继承。

可以从派生类访问受保护的成员。私立学校则不行。

class Base {

private: 
  int MyPrivateInt;
protected: 
  int MyProtectedInt;
public:
  int MyPublicInt;
};

class Derived : Base
{
public:
  int foo1()  { return MyPrivateInt;} // Won't compile!
  int foo2()  { return MyProtectedInt;} // OK  
  int foo3()  { return MyPublicInt;} // OK
};‌‌

class Unrelated 
{
private:
  Base B;
public:
  int foo1()  { return B.MyPrivateInt;} // Won't compile!
  int foo2()  { return B.MyProtectedInt;} // Won't compile
  int foo3()  { return B.MyPublicInt;} // OK
};

至于“最佳实践”，则视情况而定。如果有人想要从您现有的类中派生一个新类，并且需要访问内部成员，那么将它们设置为Protected，而不是Private。如果它们是私有的，那么您的类就很难轻易继承。

MFC偏爱protected的原因是因为它是一个框架。您可能想要子类化MFC类，在这种情况下，需要一个受保护的接口来访问类的一般用途不可见的方法。

a类的公共成员对所有人都是开放的。

类a的受保护成员不能在a的代码之外访问，但可以从派生自a的任何类的代码访问。

类a的私有成员不能在a的代码之外或从a派生的任何类的代码中访问。

因此，最终，在受保护还是私有之间做出选择是为了回答以下问题:您愿意对派生类的程序员给予多少信任?

默认情况下，假定派生类不可信，并将成员设为private。如果你有一个很好的理由让它的派生类可以自由访问母类的内部内容，那么你可以让它们受到保护。

这完全取决于您想要做什么，以及您希望派生类能够看到什么。

class A
{
private:
    int _privInt = 0;
    int privFunc(){return 0;}
    virtual int privVirtFunc(){return 0;}
protected:
    int _protInt = 0;
    int protFunc(){return 0;}
public:
    int _publInt = 0;
    int publFunc()
    {
         return privVirtFunc();
    }
};

class B : public A
{
private:
    virtual int privVirtFunc(){return 1;}
public:
    void func()
    {
        _privInt = 1; // wont work
        _protInt = 1; // will work
        _publInt = 1; // will work
        privFunc(); // wont work
        privVirtFunc(); // will work, simply calls the derived version.
        protFunc(); // will work
        publFunc(); // will return 1 since it's overridden in this class
    }
}

当然，看看受保护的成员变量问题。建议使用private作为默认值(就像c++类一样)来减少耦合。受保护的成员变量总是一个坏主意，受保护的成员函数可以用于例如模板方法模式。

由于不需要公共成员函数来获取和更新派生类中的受保护成员，这提高了代码的效率，并减少了需要编写的代码量。然而，派生类的程序员应该知道他在做什么。

私有成员只能在声明它的类中访问，而受保护成员可以在声明它的类中与它继承的类一起访问。

受保护的非静态基类成员可以被派生自该基类的任何类的成员和友元访问，方法是使用以下方法之一:

指向直接或间接派生类的指针 对直接或间接派生类的引用 直接或间接派生类的对象

Private: It is an access specifier. By default the instance (member) variables or the methods of a class in c++/java are private. During inheritance, the code and the data are always inherited but is not accessible outside the class. We can declare our data members as private so that no one can make direct changes to our member variables and we can provide public getters and setters in order to change our private members. And this concept is always applied in the business rule. Protected: It is also an access specifier. In C++, the protected members are accessible within the class and to the inherited class but not outside the class. In Java, the protected members are accessible within the class, to the inherited class as well as to all the classes within the same package.

私有访问修饰符和受保护访问修饰符是相同的，只是基类的受保护成员可以在子(派生)类的基类范围之外被访问。 它也同样适用于继承。 但是使用私有修饰符，基类的成员只能在基类的作用域或代码中访问，它的友函数只能是''''

Private =只能由母类(基类)访问 (只有我父母才能进我父母的卧室)

Protected =母类(基类)和她的子类可以访问 (只有父母可以进父母的卧室，但允许儿子/女儿进父母的卧室)

Public =母类(基类)、子类和其他所有人都可以访问 (只有我父母才能进我父母的卧室，但那是家庭聚会——我的家是我的家)

成员数据首选Private。c++类中的成员默认是私有的。

Public是成员函数的首选，尽管这是一个意见问题。至少有一些方法必须是可访问的。公共是对所有人开放的。这是最灵活的选择，也是最不安全的选择。任何人都可以使用它们，任何人都可以滥用它们。

Private根本无法访问。没有人可以在课堂之外使用它们，也没有人可以滥用它们。甚至在派生类中也没有。

Protected是一种折衷，因为它可以在派生类中使用。当您从类派生时，您对基类有很好的理解，并且注意不要误用这些成员。

MFC是Windows API的c++包装器，它更倾向于public和protected。由Visual Studio向导生成的类包含受保护的、公共的和私有的成员。但是MFC类本身有一些逻辑。

像SetWindowText这样的成员是公共的，因为您经常需要访问这些成员。

成员如OnLButtonDown，处理窗口接收到的通知。它们不应该被访问，因此受到保护。您仍然可以在派生类中访问它们以重写这些函数。

一些成员必须执行线程和消息循环，它们不应该被访问或覆盖，因此它们被声明为私有

在c++结构中，成员默认是公共的。结构通常只用于数据，而不是方法，因此公共声明被认为是安全的。

Private:可由类成员函数和好友函数或好友类访问。 对于c++类，这是默认的访问说明符。

Protected:可由类成员函数、友元函数或友元类及派生类访问。

您可以根据需要将类成员变量或函数(甚至是typedefs或内部类)保留为私有或受保护。 大多数情况下，保持类成员为私有，并添加get/set函数进行封装。这有助于代码的维护。 一般来说，当你想要保持公共函数模块化或消除重复代码而不是将整个代码写入单个函数时，就会使用私有函数。这有助于代码的维护。

更多细节请参考这个链接。

The protected keyword specifies access to class members in the member-list up to the next access specifier (public or private) or the end of the class definition. Class members declared as protected can be used only by the following: Member functions of the class that originally declared these members. Friends of the class that originally declared these members. Classes derived with public or protected access from the class that originally declared these members. Direct privately derived classes that also have private access to protected members. When preceding the name of a base class, the protected keyword specifies that the public and protected members of the base class are protected members of its derived classes. Protected members are not as private as private members, which are accessible only to members of the class in which they are declared, but they are not as public as public members, which are accessible in any function. Protected members that are also declared as static are accessible to any friend or member function of a derived class. Protected members that are not declared as static are accessible to friends and member functions in a derived class only through a pointer to, reference to, or object of the derived class.

保护(c++)

c++类中的私有成员和受保护成员有什么区别?

其他的回答说:

公共-所有人都可以访问。 Protected -派生类(和友类)可以访问。 私人限制。

有什么区别，我应该用哪个?

c++的核心准则给出了数据应该始终是私有的建议。我认为这是一个很好的建议，因为当你的派生类可以访问受保护的数据时，它会导致“数据面条”。保护函数更有意义，但这取决于用例。

对于函数，你有一个选择。对于数据，应该将其设置为私有，并在需要时提供受保护的访问函数。这样可以更好地控制类数据。