如果您正在寻找一种将“static”关键字应用到类的方法，就像在c#中一样，那么如果不使用Managed c++，您将无法做到这一点。

但是从示例的外观来看，您只需要在BitParser对象上创建一个公共静态方法。像这样:

BitParser.h

class BitParser
{
 public:
  static bool getBitAt(int buffer, int bitIndex);

  // ...lots of great stuff

 private:
  // Disallow creating an instance of this object
  BitParser() {}
};

BitParser.cpp

bool BitParser::getBitAt(int buffer, int bitIndex)
{
  bool isBitSet = false;
  // .. determine if bit is set
  return isBitSet;
}

您可以使用此代码以与示例代码相同的方式调用该方法。

class A final {
  ~A() = delete;
  static bool your_func();
}

Final意味着一个类不能被继承。

析构函数的Delete意味着不能创建此类的实例。

此模式也称为“util”类。

正如许多人所说，静态类的概念在c++中并不存在。

在这种情况下，首选的解决方案是包含静态函数的规范名称空间。

在c++中你“可以”有一个静态类，正如前面提到的，静态类是一个没有实例化它的任何对象的类。在c++中，可以通过将构造函数/析构函数声明为private来获得。结果是一样的。

在Managed c++中，静态类语法是:-

public ref class BitParser abstract sealed
{
    public:
        static bool GetBitAt(...)
        {
            ...
        }
}

．.． 迟到总比不到好……

在c++中实现“不能被实例化的类”行为的一种(众多)替代方法，但也是最优雅的(在我看来)方法(与使用名称空间和私有构造函数来模拟静态行为相比)是声明一个带有私有访问修饰符的虚拟纯虚函数。

class Foo {
   public:
     static int someMethod(int someArg);

   private:
     virtual void __dummy() = 0;
};

如果使用c++ 11，可以在类声明中使用final说明符来限制其他类继承它，从而确保类不被继承(以纯粹模拟静态类的行为)。

// C++11 ONLY
class Foo final {
   public:
     static int someMethod(int someArg);

   private:
      virtual void __dummy() = 0;
};

尽管听起来很傻很不合逻辑，但c++ 11允许声明一个“不能被重写的纯虚函数”，你可以使用它来声明类final来完全实现静态行为，因为这会导致生成的类不可继承，虚函数也不能以任何方式被重写。

// C++11 ONLY
class Foo final {
   public:
     static int someMethod(int someArg);

   private:
     // Other private declarations

     virtual void __dummy() = 0 final;
}; // Foo now exhibits all the properties of a static class

名称空间对于实现“静态类”可能不太有用的一种情况是使用这些类实现继承上的组合。名称空间不能是类的友元，因此不能访问类的私有成员。

class Class {
 public:
  void foo() { Static::bar(*this); }    

 private:
  int member{0};
  friend class Static;
};    

class Static {
 public:
  template <typename T>
  static void bar(T& t) {
    t.member = 1;
  }
};