在 C++ 成员函数中使用“静态”关键字限制访问

Question

我知道拥有静态成员函数的一个好处是不必初始化一个类来使用它们。在我看来，它们的另一个优点可能是无法直接访问类的非静态内容。

例如，一种常见的做法是，如果您知道函数将具有不可更改的参数，则只需将这些参数标记为常量。例如：

bool My_Class::do_stuff(const int not_to_be_changed_1,
                        std::vector<int> const * const not_to_be_changed_2)
{
  //I can't change my int var, my vector pointer, or the ints inside it.
}

那么使用静态成员函数来限制访问是否有效。例如，假设你有一个函数

void My_Class::print_error(const unsigned int error_no) {
  switch (error_no) {
    case 1:
      std::cout << "Bad read on..." << std::endl;
      break;
    //...
    default:
      break;
  }
}

这里我们不会访问类的任何成员变量。因此，如果我将功能更改为：

static void My_Class::print_error(const unsigned int error_no) {
  switch (error_no) {
    case 1:
      std::cout << "Bad read on..." << std::endl;
      break;
    //...
    default:
      break;
  }
}

如果我无意中尝试访问我的私有变量等，我现在会收到一个错误（除非我将我的类的实例传递给自己，这将是有目的的^_^！）

这是一种有效的技术吗，类似于主动将不应更改的 args 设置为常量？

它在效率或使用方面可能有什么缺点？

我问的主要原因是我阅读的大多数“静态”教程都没有提到以这种方式使用它，所以我想知道是否有充分的理由不这样做，因为它似乎是一个有用的工具.

---

编辑 1：此用途的进一步逻辑理由：

如上所述，我有一个函数 print_error。我可以使用命名空间：

namespace MY_SPACE {
   static void print_error(...) {
      ...
   } 

   class My_Class {
      ....
      void a(void)
   }
}

但这很痛苦，因为我现在必须延长所有 var 声明，即

MY_SPACE::My_Class class_1;

all 从我的类中删除一个函数，它本质上是我的类的成员。

当然，函数有多个级别的访问控制：

//can't change pointer to list directly
void My_Class::print_error(std::vector<int> const * error_code_list) {...}

//can't change pointer to list or list members directly
void My_Class::print_error(std::vector<int> const * const error_code_list) {...}

//can't change pointer to list or list members directly, access
//non-const member vars/functions
void My_Class::print_error(std::vector<int> const * const error_code_list) const {...}

//can't change pointer to list or list members directly, access
//non-static member vars/functions
static void My_Class::print_error(std::vector<int> const * const error_code_list) {...}

//can't change pointer to list or list members directly, access
//member vars/functions that are not BOTH static and const
static void My_Class::print_error(std::vector<int> const * const error_code_list) const {...}

当然这有点不典型，但使用 const 函数和 const 变量的程度有所降低。我见过很多例子，人们可以使用 const 函数，但没有。然而，有些人认为这是个好主意。我认识许多不了解 const 函数或静态函数的含义的 C++ 初学者。同样，很多人都会理解两者。

那么，如果语言/规范允许像使用 const 函数等那样使用它，那么为什么有些人如此坚决地反对将其用作访问控制机制？

Answer 1

可以公平地说，全局作用域函数、静态成员函数和友元函数彼此之间并不完全正交。在某种程度上，这主要是因为它们旨在对程序员具有不同的语义含义，即使它们产生相似的输出。

特别是静态成员方法和友元函数唯一的区别就是命名空间不同，静态成员的命名空间为::className::methodName，友元函数只是::friendFunctionName。它们都以相同的方式运行。

嗯，实际上还有另一个区别，静态方法可以通过指针间接访问，这在多态类的情况下很有用。

所以问题是，函数是否属于类的“part”？如果是这样，请使用静态方法。如果没有，则将该方法放在全局范围内，如果它可能需要访问私有成员变量，则将其设为好友（如果不需要，则不要）

Answer 2

当静态成员函数与类相关但不对类的实例进行操作时，应使用它们。

示例包括一类实用程序方法，所有这些都是静态的，因为您永远不需要实用程序类本身的实际实例。

另一个例子是一个使用静态辅助函数的类，这些函数对于类外的其他函数已经足够有用了。

Answer 3

不要这样做。使用static 作为访问控制机制是一种野蛮可憎的行为。

不这样做的一个原因是它很奇怪。维护程序员将很难理解您的代码，因为它太奇怪了。可维护的代码是好的代码。每个人都会得到const 方法。没有人收到static-as-const。代码的最佳文档是代码本身。自我记录代码是您应该追求的目标。不是让您不必编写 cmets，而是让 they 不必read 它们。因为你知道他们无论如何都不会这样做。

不这样做的另一个原因是你永远不知道未来会发生什么。您上面的print_error 方法现在不需要访问类的状态。但我可以看到有一天可能需要它。假设您的类是 UDP 套接字的包装器。在会议进行到一半的时候，另一端砰的一声关上了门。你想知道为什么。您发送或接收的最后一条消息可能会提供线索。你不应该把它扔掉吗？你需要状态。

这样做的一个错误原因是它提供了成员访问控制。是的，它会这样做，但已经有这样的机制。假设您正在编写一个要确保不会更改对象状态的函数。例如，print_error 不应该改变任何对象的状态。所以制作方法const:

class MyClass
{
public:
  void print_error(const unsigned int error_no) const;
};

...

void MyClass::print_error(const unsigned int error_no) const
{
  // do stuff
}

print_error 是一个const 方法，实际上意味着this 指针是const。您不能更改任何非mutable 成员，也不能调用任何非const 方法。这不正是你想要的吗？

Answer 4

任何成员函数都应该可以访问对象的其他成员。你为什么要保护自己免受自己的伤害？

静态成员通常很少使用，例如工厂方法。您将创造一种情况，使下一个使用您的代码的人“WTF？？？”