C++ 什么时候/为什么在课堂上将函数设置为私有？

我什么时候应该使函数

私有化，为什么这样做是个好主意？
当您不需要其他对象或类来访问函数时，当您从类中调用函数时，应该使函数
私有化

坚持最低特权原则，只允许访问绝对必要的变量/函数。任何不符合这个标准的东西都应该是私有的，封装是OOP的基本原则之一。这就是对象如何工作的功能保持在该对象内部的地方。其思想是，如果不需要知道对象是如何工作的，那么代码就更容易使用对象。有点像买微波炉——你只需要知道如何使用它，而不是它是如何工作的

class Sample
{
   public:
      void DoWork(SomeClass param)
      {       
            if ( IsValidParam(param))       
            {
                //actual code that operates on the param 
                //and other member data IF the param is valid
            }
      }
  private:
      bool IsValidParam(SomeClass param)
      {
          //check the validity of param.
          //return true if valid, else false.
      }
};

OOP也应该采用同样的方法。保持对象私有所需的一切。仅将充分使用对象所需的内容设置为公共。
如果您正在设计一个类—考虑客户端代码应该使用它的方式—那么您将不可避免地派生出一个由
公共
和
受保护
成员组成的接口

private
成员是支持和启用这些公共/受保护成员的函数和数据<代码>专用
功能应将非

专用成员所需的代码因素化和/或模块化/结构化，使其实现更少冗余，更易于理解

---

概括地说，如果一个成员不是供客户端代码直接使用的，并且只支持非

私有的
成员，那么就将其设置为私有的。
我通常将助手函数设置为私有的。但什么是助手似乎很模糊。让我给你举个例子。假设您有以下类
Sample
；它公开了一些公共函数，例如，
DoWork（）
。此函数接受一个参数。但它并不假设参数总是有效的，因此它首先检查参数的有效性，因为它在函数的开头有很多代码。大概是这样的：

class Sample
{
   public:
      void DoWork(SomeClass param)
      {
               /*
                *lots of code related to validation of param
                */  

                //actual code that operates on the param 
                //and other member data IF the param is valid
      }
};

class Sample
{
   public:
      void DoWork(SomeClass param)
      {       
            if ( IsValidParam(param))       
            {
                //actual code that operates on the param 
                //and other member data IF the param is valid
            }
      }
};

由于您已经编写了大量与参数验证相关的代码，这使得函数变得繁琐且难以阅读。因此，您决定将此验证代码移动到函数，例如，
IsValidParam（）
，然后从
DoWork（）
调用此函数，并将参数
param
传递给它。大概是这样的：

class Sample
{
   public:
      void DoWork(SomeClass param)
      {
               /*
                *lots of code related to validation of param
                */  

                //actual code that operates on the param 
                //and other member data IF the param is valid
      }
};

class Sample
{
   public:
      void DoWork(SomeClass param)
      {       
            if ( IsValidParam(param))       
            {
                //actual code that operates on the param 
                //and other member data IF the param is valid
            }
      }
};

看起来更干净，对吗

好的，您已经在类中的某个地方编写了
IsValidParam（）
，但是您现在面临的问题是，是否将此函数
公开？如果此函数仅被其他函数（如
DoWork（）
）使用，则将
IsValidParam（）
设置为公共是没有意义的。因此，您决定将此函数设置为私有函数

class Sample
{
   public:
      void DoWork(SomeClass param)
      {       
            if ( IsValidParam(param))       
            {
                //actual code that operates on the param 
                //and other member data IF the param is valid
            }
      }
  private:
      bool IsValidParam(SomeClass param)
      {
          //check the validity of param.
          //return true if valid, else false.
      }
};

这类函数（IsValidParam）应该是
私有的
。我称这些函数为helper函数

希望这个解释对你有帮助
 在创建函数或类之前，我们应该了解该函数或类的范围，无论是全局范围还是局部范围

例如：“ConnectionString（）”。
每个数据库连接都需要“ConnectionString（）”，因此其声明为Public。
private：仅由此类使用，不由其他类或派生类使用。

受保护：由此类使用，也可能由派生类使用，但不由其他类使用。

public：由其他类、此类和派生类使用

很难在私人和受保护之间做出选择。因此，如果派生类有1%的可能需要函数，我总是让它受到保护。
您希望成为一个多么纯粹的人？：）

这个问题的正确答案与不变量的维护有关。正确的方法是相当复杂的

在基类中，您定义了公共方法，以提供对该类的整体访问。所有这些方法都必须是具体的。这里的关键是，假定公共不变量在调用这些函数之前和之后都保持不变。这些函数决不能互相调用，它们只调用受保护的和私有的方法。这些函数应该是公理化的：它们应该是捕获所需语义所需的相当小的集合

使用这些方法可以完成的大多数计算应该是全局的，或者至少是公共静态成员

您还提供纯虚拟方法，这些方法是钩子，根据派生类中的表示实现细节。基中的虚拟函数应该是私有的。这里（公众）通常的建议是完全错误的。虚拟函数是实现细节。一个例外：虚拟析构函数必须是公共的

私有助手函数也可以放在基函数中

在库中设置受保护的方法可能也很有用：这些方法将调用私有助手或虚拟对象。如上所述：受保护的方法不应该调用受保护的或公共的方法。在每次调用前后，受保护函数保持的不变量比公共函数弱

私有函数通常保持非常弱的不变量

这种严格的层次结构是为了确保正确维护对象不变量

现在，在派生类中提供了一个实现。理想情况下，此处的虚拟功能将是不可见的，这是一种比仅私有更强大的条件。在派生类中根本不应调用这些虚拟函数。仅允许通过基站的受保护功能进行访问

派生类的所有方法（包括析构函数）都应该是私有的。构造函数必须是公共的，但它们不是类的方法

为了充分理解这些规则，您必须仔细考虑不变量。公众不变量