C++ c++；（sys/socket.h）客户端重试连接到服务器导致seg故障

已解决 多亏了用户4581301的评论，我开始检查所有的unique_ptr，发现destructor中的std:：unique_ptr不正确

原创帖子：

（为我糟糕的英语道歉）

我在C++中用CysServer系统构建了“sys／socket”，在那里“用户”启动服务器，客户端将“永远”运行。p> 我的意思是，无论服务器是否正在运行，客户端都会在一定的时间间隔内尝试连接到服务器。但是，当我这样做时，在第三次尝试连接到服务器时会出现分段错误。（是的，这可能是糟糕的服务器客户端设计）

因为此cenario中不需要服务器，所以下面只显示了客户端的一部分：
client.cpp（）

intmain（）{
int端口=8888；
std:：string adr=“127.0.0.1”；
bool run=true
std：：唯一的ptr con；
while（运行）{
con.重置（新插座适配器（adr，端口））；
而（con->connected（））{
//做事
}
}
}
类socketHandler{
公众：
SocketHandler（标准：：字符串地址，int端口）：
incommingMessageHandler（新MessageHandler（））
，portNummer（港口）
，地址
{
如果（（this->socketContainer=socket（AF\u INET，SOCK\u STREAM，0））<0）{
出口（1）；
}
memset（&this->servAddr，'0'，sizeof（this->servAddr））；
这->servAddr.sin\u family=AF\u INET；
this->servAddr.sin\u port=htons（this->portnumer）；
if（inet_pton（AF_inet，this->address.c_str（），&this->servAddr.sin_addr）socketContainer，（struct sockaddr*）和this->servAddr，sizeof（this->servAddr））<0）{
closeSocket（）；
返回；
}
//更多的东西
}
布尔连接（）{
//如果从服务器接收到“测试消息”，则返回true。
}
//也跳过了一些函数
私人：
void closeSocket（）{
关闭（此->socketContainer）；
此->socketContainer=0；
}
国际港口；
std：：字符串地址；
std：：原子容器；
servAddr中的结构sockaddr_；
std：：原子状态；
}

我觉得这是唯一一个有问题的“代码”，所以不是所有的东西都在那里，如果必要的话，我会给出更多

根据我在文档中找到的内容，我感觉哪里丢失了，以及我在sys/socket上所有联机示例中找到的内容，它们都会在失败的“connect（）”调用中退出（1），但没有真正的原因

这里有人知道为什么会这样吗？和/或有办法“解决”这个问题

一些链接： - - -

谢谢你的帮助

解决方案：

私密（seg故障析构函数）：

intmain（）{
int端口=8888；
std:：string adr=“127.0.0.1”；
bool run=true
std：：唯一的ptr con；
while（运行）{
con.重置（新插座适配器（adr，端口））；
而（con->connected（））{
//做事
}
}
}
类socketHandler{
公众：
SocketHandler（标准：：字符串地址，int端口）：
incommingMessageHandler（新MessageHandler（））
，portNummer（港口）
，地址
{
如果（（this->socketContainer=socket（AF\u INET，SOCK\u STREAM，0））<0）{
出口（1）；
}
memset（&this->servAddr，'0'，sizeof（this->servAddr））；
这->servAddr.sin\u family=AF\u INET；
this->servAddr.sin\u port=htons（this->portnumer）；
if（inet_pton（AF_inet，this->address.c_str（），&this->servAddr.sin_addr）socketContainer，（struct sockaddr*）和this->servAddr，sizeof（this->servAddr））<0）{
closeSocket（）；
返回；
}
重置（新std:：thread（&ClientSocketHandler:：receiveMessagesFromSocket，this））；
}
布尔连接（）{
//如果从服务器接收到“测试消息”，则返回true。
}
void receiveMessagesFromSocket（）{
//如果输入消息，请添加messagehandler…（线程运行时）
}
~sockethandler（）{
/**
*这导致了SEG故障（显然，在考虑时）
*/
while（true）{
if（this->msgRecvThrd->joinable（））{
此->msgRecvThrd->join（）；
打破
}
}
}
//也跳过了一些函数
私人：
void closeSocket（）{
关闭（此->socketContainer）；
此->socketContainer=0；
}
国际港口；
std：：字符串地址；
std：：原子容器；
servAddr中的结构sockaddr_；
std：：原子状态；
std:：unique_ptr incommmingMessageHandler；
std：：唯一的\u ptr msgRecvThrd；
}

修复seg故障的析构函数：

int main(){
  int port = 8888;
  std::string adr = "127.0.0.1";
  bool run = true
  std::unique_ptr<socketHandler> con;

  while(run){
     con.reset(new socketHandler(adr, port));
     while(con->connected()){
       // do stuff
     }
  }
}

class socketHandler{
public:
   socketHandller(std::string address, int port):
   incommingMessageHandler(new MessageHandler())
    , portNummer(port)
    , address(address)
   {
      if( (this->socketContainer = socket(AF_INET, SOCK_STREAM, 0)) < 0){
         exit(1);
      }

      memset(&this->servAddr, '0', sizeof(this->servAddr));
      this->servAddr.sin_family = AF_INET;
      this->servAddr.sin_port = htons(this->portNummer);

      if( inet_pton(AF_INET, this->address.c_str(), &this->servAddr.sin_addr) <= 0){
         exit(1);
      }

      /**
       * The third time this "connect" is "excuted" I get seg fault
       * if it failed on the two first. It does not even call the 
       * "closeSocket" function.
      */
      if(connect(this->socketContainer, (struct sockaddr*)&this->servAddr, sizeof(this->servAddr)) < 0){
         closeSocket();
         return; 
      }

      msgRecvThrd.reset(new std::thread(&ClientSocketHandler::receiveMessagesFromSocket, this));
   }

   bool connected(){
     // return true if "test-message" been received from server.
   }

   void receiveMessagesFromSocket(){
      // if incomming message add the messagehandler... (while thread running)
   }

   ~socketHandller(){
      /**
      * FIXED
      */
      while(this->msgRecvThrd != nullptr){
         if(this->msgRecvThrd->joinable()){
           this->msgRecvThrd->join();
           this->msgRecvThrd.reset();
         }
      }
   }


   // skiped some functions as well

private:
    void closeSocket(){
       close(this->socketContainer);
       this->socketContainer = 0;
    }

   int portNummer;
   std::string address;
   std::atomic<int> socketContainer;
   struct sockaddr_in servAddr;
   std::atomic<bool> connectStatus;
   std::unique_ptr<MessageHandler> incommingMessageHandler;
   std::unique_ptr<std::thread> msgRecvThrd;
}

intmain（）{
int端口=8888；
std:：string adr=“127.0.0.1”；
bool run=true
std：：唯一的ptr con；
while（运行）{
con.重置（新插座适配器（adr，端口））；
而（con->connected（））{
//做事
}
}
}
类socketHandler{
公众：
SocketHandler（标准：：字符串地址，int端口）：
incommingMessageHandler（新MessageHandler（））
，portNummer（港口）
，地址
{
如果（（this->socketContainer=socket（AF\u INET，SOCK\u STREAM，0））<0）{
出口（1）；
}
memset（&this->servAddr，'0'，sizeof（this->servAddr））；
这->servAddr.sin\u family=AF\u INET；
this->servAddr.sin\u port=htons（this->portnumer）；
if（inet_pton（AF_inet，this->address.c_str（），&this->servAddr.sin_addr）socketContainer，（struct sockaddr*）和this->servAddr，sizeof（this->servAddr））<0）{
closeSocket（）；
返回；
}
重置（新std:：thread（&ClientSocketHandler:：receiveMessagesFromSocket，this））；
}
布尔连接（）{
//如果从服务器接收到“测试消息”，则返回true。
}
void receiveMessagesFromSocket（）{
//如果输入消息，请添加messagehandler…（线程运行时）
}
~sockethandler（）{
/**
*固定的
*/
while（this->msgRecvThrd！=nullptr）{
if（this->msgRecvThrd->joinable（））{
此->msgRecvThrd->join（）；
此->msgRecvThrd.reset（）；
}
}
}
//
int main(){
  int port = 8888;
  std::string adr = "127.0.0.1";
  bool run = true
  std::unique_ptr<socketHandler> con;

  while(run){
     con.reset(new socketHandler(adr, port));
     while(con->connected()){
       // do stuff
     }
  }
}

class socketHandler{
public:
   socketHandller(std::string address, int port):
   incommingMessageHandler(new MessageHandler())
    , portNummer(port)
    , address(address)
   {
      if( (this->socketContainer = socket(AF_INET, SOCK_STREAM, 0)) < 0){
         exit(1);
      }

      memset(&this->servAddr, '0', sizeof(this->servAddr));
      this->servAddr.sin_family = AF_INET;
      this->servAddr.sin_port = htons(this->portNummer);

      if( inet_pton(AF_INET, this->address.c_str(), &this->servAddr.sin_addr) <= 0){
         exit(1);
      }

      /**
       * The third time this "connect" is "excuted" I get seg fault
       * if it failed on the two first. It does not even call the 
       * "closeSocket" function.
      */
      if(connect(this->socketContainer, (struct sockaddr*)&this->servAddr, sizeof(this->servAddr)) < 0){
         closeSocket();
         return; 
      }

      msgRecvThrd.reset(new std::thread(&ClientSocketHandler::receiveMessagesFromSocket, this));
   }

   bool connected(){
     // return true if "test-message" been received from server.
   }

   void receiveMessagesFromSocket(){
      // if incomming message add the messagehandler... (while thread running)
   }

   ~socketHandller(){
      /**
      * THIS CAUSED THE SEG FAULT (obviouse, when thinking about it)
      */
      while(true){
         if(this->msgRecvThrd->joinable()){
           this->msgRecvThrd->join();
           break;
         }
      }
   }


   // skiped some functions as well

private:
    void closeSocket(){
       close(this->socketContainer);
       this->socketContainer = 0;
    }

   int portNummer;
   std::string address;
   std::atomic<int> socketContainer;
   struct sockaddr_in servAddr;
   std::atomic<bool> connectStatus;
   std::unique_ptr<MessageHandler> incommingMessageHandler;
   std::unique_ptr<std::thread> msgRecvThrd;
}

int main(){
  int port = 8888;
  std::string adr = "127.0.0.1";
  bool run = true
  std::unique_ptr<socketHandler> con;

  while(run){
     con.reset(new socketHandler(adr, port));
     while(con->connected()){
       // do stuff
     }
  }
}

class socketHandler{
public:
   socketHandller(std::string address, int port):
   incommingMessageHandler(new MessageHandler())
    , portNummer(port)
    , address(address)
   {
      if( (this->socketContainer = socket(AF_INET, SOCK_STREAM, 0)) < 0){
         exit(1);
      }

      memset(&this->servAddr, '0', sizeof(this->servAddr));
      this->servAddr.sin_family = AF_INET;
      this->servAddr.sin_port = htons(this->portNummer);

      if( inet_pton(AF_INET, this->address.c_str(), &this->servAddr.sin_addr) <= 0){
         exit(1);
      }

      /**
       * The third time this "connect" is "excuted" I get seg fault
       * if it failed on the two first. It does not even call the 
       * "closeSocket" function.
      */
      if(connect(this->socketContainer, (struct sockaddr*)&this->servAddr, sizeof(this->servAddr)) < 0){
         closeSocket();
         return; 
      }

      msgRecvThrd.reset(new std::thread(&ClientSocketHandler::receiveMessagesFromSocket, this));
   }

   bool connected(){
     // return true if "test-message" been received from server.
   }

   void receiveMessagesFromSocket(){
      // if incomming message add the messagehandler... (while thread running)
   }

   ~socketHandller(){
      /**
      * FIXED
      */
      while(this->msgRecvThrd != nullptr){
         if(this->msgRecvThrd->joinable()){
           this->msgRecvThrd->join();
           this->msgRecvThrd.reset();
         }
      }
   }


   // skiped some functions as well

private:
    void closeSocket(){
       close(this->socketContainer);
       this->socketContainer = 0;
    }

   int portNummer;
   std::string address;
   std::atomic<int> socketContainer;
   struct sockaddr_in servAddr;
   std::atomic<bool> connectStatus;
   std::unique_ptr<MessageHandler> incommingMessageHandler;
   std::unique_ptr<std::thread> msgRecvThrd;
}