C ++拥有持久对象的最佳方法？

Question

我正在学习C ++，并且正在尝试使用我对其他语言进行编程的知识来理解C ++，这似乎使我很困惑。我正在研究一个基本的套接字程序，并试图找出处理套接字类创建的最佳方法，以便我可以读/写并且只能连接一次。

用我的其他语言，我将创建一个静态对象类，该类将允许我对其进行引用，如果未创建，则将创建套接字并进行连接。如果创建了它，我将其返回以供参考。

但是一个类不能是静态类（至少那是我读过的东西），所以我依靠的是我知道的下一个选项，即Singleton。

所以我最终得到了类似

class Socket{
   static Socket* socket;
public:
   Socket& Get()
   {
      if (!socket) socket = new Socket;
      return *socket;
   }
};

我将在构造函数中有启动/连接的内容。但这是应该怎么做的吗？互联网上似乎有很多冲突的东西。例如，使用人员使用互斥锁，而某些人员使用模板。

哪种方式最适合套接字包装类？

Answer 1

静态类和单例只是拥有全局变量和函数的不同方式。全局变量通常是一个坏主意。如果您希望系统的许多不同部分共享一个套接字，那么您应该在本地某处（例如，在 中main()）创建一个套接字，然后将其传递给需要共享它的组件。

如果您坚持使用全局变量，那么我可能会坚持使用最简单的方法：声明并使用全局变量，而不是单例或静态类或类似的东西。

下面是创建全局变量和函数的每种方法的示例。

静态类

“静态类”是无需实例对象即可访问其成员的类。

C++ 类可以拥有所有静态成员，但无法声明类以禁止非静态成员。

class StaticClass {
public:
  static Socket aStaticDataMember;
  static void aStaticFunction() {}
}

Socket StaticClass::aStaticDataMember = Socket(...);

int main() {
    StaticClass::aStaticFunction();
    StaticClass::aStaticDataMember.doWhatever();
}

全局变量和函数

// in a header
extern Socket globalVariable;
void globalFunction();

// in a cpp file
Socket globalVariable;
void globalFunction() {}

int main() {
  globalVariable.doWhatever();
  globalFunction();
}

辛格尔顿

在 C++ 中实现单例有很多不同的方法，但这是一种方法：

class SingletonClass {
public:
  void doWhatever() {}
private:
  // ... private members to implement singleton.
  // If you define any constructors they should be private

  friend SingletonClass &getSingletonClass() {
    static SingletonClass singleton; // thread safe in C++11
    return singleton;
  }
}

int main() {
  getSingletonClass().doWhatever();
}

这是不使用全局变量的示例：

class ComponentAThatUsesASocket {
private:
  Socket &socket;
public:
  ComponentAThatUsesASocket(Socket &s) : socket(s) {}

  void foo() {
    socket.doWhatever();
  }
}

int main() {
  Socket socket;

  ComponentAThatUsesASocket componentA(socket);
  componentA.doWhatever();

  ComponentB componentB(socket);
  componentB.doWhatever();
}