tcp通信（发送结构体）

       具体实现：在tcpsocket类中定义结构体，将需要计算的数和计算方式赋值给结构体，服务端收到数据，判断计算方式然后处理数据并将值返回。

tcpsocket.hpp

#include<cstdio>
#include<iostream>
#include<string>
#include<unistd.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/socket.h>
#include<cstring>

#define MAX_LISTEN 5
#define CHECK_RET(q) if((q)==false){return false;}

typedef struct
{
 int num1;
 int num2;
 char op;
}tmp_t;

class TcpSocket
{
  public:
    TcpSocket():_sockfd(-1){}

    bool Socket()
    {
      this->_sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
      if(this->_sockfd <0)
      {
        perror("socket perror");
        return false;
      }

      return true;
    }

    int GetFd()
    {
      return _sockfd;
    }

    void Addr(struct sockaddr_in* addr, const std::string& ip, uint16_t port)
    {
      addr->sin_family = AF_INET;
      addr->sin_port = htons(port);
      addr->sin_addr.s_addr = inet_addr(ip.c_str());
      return;
    }

    bool Bind(const std::string &ip, uint16_t port)
    {
      struct sockaddr_in addr;
      Addr(&addr,ip,port);
      socklen_t len = sizeof(struct sockaddr_in);
      int ret = bind(_sockfd, (sockaddr*)&addr, len);
      if(ret<0)
      {
        perror("bind error");
        return false;
      }
        return true;
    }

    bool Listen(int backlog = MAX_LISTEN)
    {
      //int listen(描述符，同一时间最大连接数)
      int ret =listen(_sockfd,backlog);
      if(ret<0)
      {
        perror("listen error");
        return false;
      }
      return true;
    }

    bool Connect(const std::string &ip, u_int16_t port)
    {
      //connect(描述符，服务端地址，服务端地址长度)
      struct sockaddr_in addr;
      Addr(&addr,ip,port);

      socklen_t  len = sizeof(struct sockaddr_in); 
      
      int ret = connect(_sockfd,(struct sockaddr*)&addr, len);
      if(ret<0)
       {
        perror("connect error");
        return false;
      }
      return true;
    }

    bool Accpet(TcpSocket* sock, std::string *ip=NULL, uint16_t *port = NULL)
    {
      //accept(监听描述符，客户端地址，地址长度)
     struct sockaddr_in addr;
     
     socklen_t len = sizeof(struct sockaddr_in);
    int newfd = accept(_sockfd,(struct sockaddr*)&addr, &len);

    if(newfd<0)
    {
      perror("accept error");
      return false;
    }

    sock->_sockfd = newfd;
   
    if(ip != NULL)
    {
      *ip = inet_ntoa(addr.sin_addr);
    }

    if(port != NULL)
    {
      *port = ntohs(addr.sin_port);
    }

    return true;
    }

    bool Send(const std::string &data)
    {
      //ssize_t send(描述符，数据，长度，标志)
      int total =0;
      while(total <(int)data.size())
      {
      int ret = send(_sockfd, &data[0]+total,data.size()-total,0); 

      if(ret <0)
      {
        printf("发送失败\n");
        perror("send error");
        return false;
      }
      total+=ret;
      }
      return true;

    }

    bool Recv(std::string *buf)
    {
     //ssize_t recv(描述符，缓冲区，长度，标志);
     
     char tmp[4096]={0};
     int ret = recv(_sockfd,tmp,4096,0);
     if(ret<0)
     {
       perror("recv error");
       return false;
     }

     if(ret ==0)
     {
       std::cout<<"peer shutdown"<<std::endl;
       return false;
     }

      buf->assign(tmp,ret);//申请空间拷贝指定长度数据
      return true;
    }

    bool Close()
    {
      if(_sockfd != -1)
      {
        close(_sockfd);
      }
      return true;
    }

 private:
   int _sockfd;
};

tcp_srv.cpp

#include"tcpsocket.hpp"
#include<string>
#include<cstring>

int main(int argc, char *argv[])
{
  //argc是程序运行参数个数
  //argv存放程序运行参数 ./tcp_srv 10.0.4.7 9000
  if(argc !=3)
  {
    printf("useage: ./tcp_srv 10.0.4.7 9000");
    return -1;
  }

  std::string ip = argv[1];
  uint16_t port = std::stoi(argv[2]);

  TcpSocket lst_sock;

  //1.创建套接字
  CHECK_RET(lst_sock.Socket());
  //2.绑定地址信息
  CHECK_RET(lst_sock.Bind(ip,port));
  //3.开始监听
  CHECK_RET(lst_sock.Listen());
  while(1)
  {
    //4.获取新建连接
    TcpSocket new_sock;
    bool ret = lst_sock.Accpet(&new_sock,&ip,&port);
    if(ret ==false)
    {
      usleep(1000);
      continue;
    }
    int sockfd = new_sock.GetFd();
   
    tmp_t tmp;
    recv(sockfd,&tmp,sizeof(tmp),0);
    int result =0;
    if(tmp.op=='+')
    {
      result=tmp.num1+tmp.num2;
    }
    send(sockfd,&result,sizeof(int),0);

    //6.关闭套接字
  }
    lst_sock.Close();
    return 0;
}

tcp_cli.cpp

#include"tcpsocket.hpp"
#include<string>

int main(int argc, char* argv[])
{
  if(argc !=3)
  {
    printf("useage: ./tcp_cli srvip srvport\n");
    return -1;
  }

  std::string srv_ip = argv[1];
  int16_t srv_port = std::stoi(argv[2]);

  TcpSocket cli_sock;

  //1.创建套接字
  CHECK_RET(cli_sock.Socket());
  //2.绑定地址信息
  //3.向服务端发起连接请求
  CHECK_RET(cli_sock.Connect(srv_ip,srv_port));
    tmp_t tmp;
    tmp.num1=11;
    tmp.num2=22;
    tmp.op='+';
    int sockfd = cli_sock.GetFd();
    send(sockfd,&tmp,sizeof(tmp_t),0);

    int result;
    recv(sockfd, &result,sizeof(int),0);
    printf("result=%d\n",result);
  //4.与服务端进行通信
  //5.关闭套接字
  cli_sock.Close();
  return 0;
}