C++ 套接字标识符等于-1

不知怎么的，插座是-1。这不应该是因为我的客户端程序连接并发送信息，但被SIGPIPE信号停止。调试服务器时，我看到accept返回-1。我不知道为什么。如果你没有，请回答

client.cpp

using namespace std;
using namespace msg;
using namespace dataExchange;

int main() {
  Connection con("127.0.0.1", 123456);
  Annoucement ann;
  ann.set_typ(Annoucement::AKCJA);
  con.send(ann);
}

server.cpp

using namespace std;
using namespace msg;
using namespace dataExchange;

int main() {
  Server server(123456);
  while(1) {
    Connection con = server.accept();
    Annoucement ann = con.receive();
    cout << ann.typ() << endl;
  }
}

使用名称空间std；
使用名称空间msg；
使用名称空间数据交换；
int main（）{
服务器（123456）；
而(1){
Connection con=server.accept（）；
Annoucement ann=con.receive（）；
cout猜测一下，在其中的某个地方，您正在按值传递一个套接字类对象，而它的析构函数正在过早地关闭套接字。我不想费心费力地浏览代码以了解是否确实如此，但有一些观察结果：


不要用新的东西分配东西，除非你必须这样做
如果复制构造函数所做的只是默认复制构造函数应该做的，那么不要实现它们
通过将复制构造函数和赋值运算符声明为private，然后不实现它们来防止套接字对象的复制
不要将事情“重新安排”到类中——要么从一开始就开始编写类，要么只编写过程代码
我看到的一个突出问题是您的端口无效。
sockaddr\u in:：sin\u port
是一个
uint16\u t
，其最大值可能是65536。最好的情况是，在调用
htons
时截断您的端口，这将导致57920

关于接受失败的原因，
-1
表示发生了错误，您应该检查
errno
的值以了解原因

从
人员2接受
：

返回值
成功时，accept（）返回一个非负整数，该整数为
接受套接字的描述符。
出现错误时，返回-1，并返回errno
设置适当

我想这没什么关系，因为当我在析构函数中注释close时，问题仍然存在。errno等于22-参数无效。Socket参数等于5。不知道出了什么问题：/socklen\u t client\u len=sizeof（client）；这没关系。信息请点击Thx。我是一个noob。
using namespace msg;
using namespace google::protobuf;
using namespace google::protobuf::io;

namespace dataExchange {

  class SocketMaintenance {
  protected:
    sockaddr_in addr;
    int s;
  public:
    SocketMaintenance(const unsigned int port) {
      memset(&addr, 0, sizeof(addr));
      addr.sin_family = AF_INET;
      addr.sin_port = htons(port);
      s = socket(AF_INET, SOCK_STREAM, 0);
    }
    SocketMaintenance(const sockaddr_in Addr, const int Socket) {
      addr = Addr;
      s = Socket;
    }
    SocketMaintenance(const SocketMaintenance& source) {
      addr = source.addr;
      s = source.s;
    }
    ~SocketMaintenance() {
      close(s);
    }
    void write(const char* buffer, const int n) {
      ::write(s, buffer, n);
    }
  };

  class Connection : public SocketMaintenance {
    FileOutputStream* raw_output;
    FileInputStream* raw_input;
    char buffer[1024];
  public:
    Connection(const char* IP, const unsigned int port) : SocketMaintenance(port) {
      if(inet_pton(AF_INET, IP, &addr.sin_addr)<=0) {
    throw WrongAddress();
      }
      if(connect(s, (sockaddr*)&addr, sizeof(addr))<0) {
    throw ConnectFailed();
      }
      raw_output = new FileOutputStream(s);
      raw_input = new FileInputStream(s);
    }
    Connection(const SocketMaintenance& source) : SocketMaintenance(source) {}
    ~Connection() {
      delete raw_output;
    }
    void send(const Message& msg) throw(EmptyMessage)  {
      CodedOutputStream* coded_output = new CodedOutputStream(raw_output);
      int n = msg.ByteSize();
      if(n<=0) throw EmptyMessage();
      coded_output->WriteVarint32(n);
      delete coded_output;
      raw_output->Flush();
      msg.SerializeToArray(buffer, n);
      SocketMaintenance::write(buffer, n);
    }
    Annoucement receive() throw() {
      CodedInputStream* coded_input = new CodedInputStream(raw_input);
      google::protobuf::uint32 n;
      coded_input->ReadVarint32(&n);
      char *b;
      int m;
      coded_input->GetDirectBufferPointer((const void**)&b, &m);
      Annoucement ann;
      ann.ParseFromArray(b, n);
      return ann;
    }

  };

  class Server : public SocketMaintenance {
  public:
    Server(const unsigned int port) : SocketMaintenance(port) {
      addr.sin_addr.s_addr = htonl(INADDR_ANY);
      if(bind(s, (struct sockaddr *)&addr, sizeof(addr))<0) {
    throw BindFailed();
      }
      if(listen(s, 5)<0) {
    throw ListenFailed();
      }
    }
    Connection accept() throw() {
      sockaddr_in client;
      socklen_t client_len;
      int client_socket = ::accept(s, (sockaddr*)&client, &client_len);
      return Connection(SocketMaintenance(client, client_socket));
    }
  };

}