升级！！！运用select实现一个简单的TCP通信！

多路转接模型

多路转接IO：对大量的描述符进行就绪事件监控–让进程能够仅仅对就绪的描述符执行操作 不仅仅提高效率，而且避免阻塞。 只要是存在对描述符进行监控的需求，都可以使用多路转接模型进行事件的监控

多路转接模型使用场景：只要对描述符有(可读，可写，异常)事件的监控需求都可以使用多路转接模型。也使用与对大量描述符进行监控，但是同一时间只有少量的描述符活跃的场景(因为三种模型都是并发处理的)。
当然udp可以使用多路转接模型，udp只有一个描述符，阻塞操作也可以，所以可以用也可以不用，使用了select模型或者epoll模型也没有差别。

select模型

select模型的操作流程简介

1. 定义某个事件的描述符集合（可读事件描述符集合，可写事件描述符集合，异常事件描述符集合），初始化清空集合。对哪个描述符关心什么事件，就把这个描述符添加到相应事件的描述符集合中
2. 将集合拷贝到内核中进行监控(只有内核才能知道你的文件描述符是否就绪），监控的原理是轮询遍历判断。(若超时等待，有描述符就绪事件则调用返回)
3. 监控调用的返回，表示监控出错/ 有描述符就绪 / 监控等待超时了 并且调用返回的时候，将事件监控的描述符集合中未就绪的描述符集合从集合中移除（只保留就绪的描述符）
   注意：因为调用返回的时候修改了集合，因此下次监控的时候，就需要重新向集合中添加描述符。
4. 轮询判断哪个描述符仍然在哪个集合中，就确定了这个描述符是否就绪了某个事件，然后进行对应事件的操作即可。
   注意：select并不会直接返回给用户就绪的描述符直接操作，而是返回了就绪的描述符集合，因此需要我们进行轮询判断

TCP的实现

封装一个TCP服务端

#pragma once
#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdio.h>
#include <string>
#include <string.h>
using namespace std;

//创建TCP类，提供监听listen,accept,recv,send等功能
class TcpSvr{
  public:
    //构造函数
    TcpSvr()
      :sock_fd_(-1)
    {

    }
    ~TcpSvr()
    {
    }
    //创建套接字
    int CreateSocket()
    {
      sock_fd_ = socket(AF_INET, SOCK_STREAM, 0);
      if(sock_fd_ < 0)
      {
        //创建套接字失败
        perror("socket\n");
        return -1;
      }
      printf("套接字创建成功！\n");
      return 0;
    }
    //绑定地址信息
    int Bind(const string& IP, const uint16_t port)
    {
      sockaddr_in addr;
      //协议
      addr.sin_family = AF_INET;
      //IP地址
      addr.sin_addr.s_addr = inet_addr("0.0.0.0");
      //端口
      addr.sin_port = htons(19999);
      int ret = bind(sock_fd_, (struct sockaddr*)&addr, sizeof(addr));
      if(ret < 0)
      {
        perror("bind");
        return -1;
      }
      printf("地址绑定成功！\n");
      return 0;
    }
    //listen侦听套接字
    int Listen(int backlog = 5)
    {
      int ret = listen(sock_fd_, backlog);
      if(ret < 0)
      {
        perror("listen");
        return -1;
      }
      printf("监听成功！\n");
      return 0;
    }
    //获取新连接
    int Accept(TcpSvr* ts, struct sockaddr_in* peer_addr, socklen_t* peer_addrlen)
    {
      int new_sock = accept(sock_fd_, (struct sockaddr*)peer_addr, peer_addrlen);
      if(new_sock < 0)
      {
        perror("accept");
        return -1;
      }
      else 
      {
        printf("获取新连接成功！\n");
        ts->SetSocketFd(new_sock);
        return 0;
      }
    }

    void SetSocketFd(int fd)
    {
      sock_fd_ = fd;
      printf("SetSockfd成功！");
    }
    //发送信息
    int Send(const string& data)
    {
      ssize_t send_size = send(sock_fd_, data.c_str(), data.size(), 0);
      if(send_size < 0)
      {
        perror("send");
        return -1;
      }
      return send_size;
    }
    //接收信息
    int Recv(string* data)
    {
      char buf[1024] = {0};
      ssize_t recv_size = recv(sock_fd_, buf, sizeof(buf) - 1, 0);
      if(recv_size < 0)
      {
        perror("recv");
        return -1;
      }
      else if(recv_size == 0)
      {
        printf("peer shutdown...\n");
        return 0;
      }
      data->assign(buf, strlen(buf));
      return recv_size;
    }
    int GetSockfd()
    {
      return sock_fd_;
    }
    private:
    //套接字
    int sock_fd_;
};

封装一个select类

#pragma once 
#include <stdio.h>
#include <iostream>
#include <sys/socket.h>
#include <sys/select.h>
#include <unistd.h>
#include <vector>
#include "tcp.hpp"
using namespace std;
class SelectSvr
{
  public:
    //构造函数
    SelectSvr()
      :nfds_(-1)
    {
      FD_ZERO(&readfds_);
    }
    //析构函数
    ~SelectSvr(){}

    //添加事件集合
    void AddFd(int fd)
    {
      FD_SET(fd, &readfds_);
      //printf("添加fd: %d成功！\n",fd);
      //判断最大文件描述符是否改变
      if(fd > nfds_)
      {
        nfds_ = fd;
      }
      // printf("添加fd后，nfds 为 : %d\n",nfds_);
    }

    //删除事件集合
    void DeleteFd(int fd)
    {
      //删除文件描述符事件
      FD_CLR(fd, &readfds_);
      //判断最大的文件描述符是否改变
      for(int i = nfds_; i >= 0; i--)
      {
        if(FD_ISSET(i, &readfds_) == 1)
        {
          nfds_ = i;
          break;
        }
      }
    }

    //select监听事件
    int SelectWait(struct timeval* tv, std::vector<TcpSvr>* vec)
    {
      fd_set tmp = readfds_;
      int ret = select(nfds_ + 1, &tmp, NULL, NULL, tv);
      // printf("SelectWait ：nfds 的值为 ：%d\n", nfds_);
      if(ret < 0)
      {
        perror("select");
        return -1;
      }
      else if(ret == 0)
      {
        //说明阻塞超时了
        printf("time out...\n");
        return 0;
      }
      //正常监听返回结果
      for(int i = 0; i <= nfds_; i++)
      {
        if(FD_ISSET(i, &tmp) == 1)
        {
          TcpSvr ts;
          ts.SetSocketFd(i);
          vec->push_back(ts);
        }
      }
      return ret;
    }
    
  private:
    //听事件集合
    fd_set readfds_;
    //最大描述符
    int nfds_;
};

main程序

#include "select.hpp"
#include "tcp.hpp"
#define CHECK_RET(p) if(p < 0){return 0;}

int main(int argc, char* argv[])
{
  if(argc != 3)
  {
    printf("usage...\n");
    return 0;
  }
  TcpSvr ts;

  string ip = argv[1];
  uint16_t port = atoi(argv[2]);
  CHECK_RET(ts.CreateSocket());
  //创建套接字
  CHECK_RET(ts.Bind(ip, port));
  //绑定地址信息
  CHECK_RET(ts.Listen());
  //侦听套接字
  
  SelectSvr ss;
  ss.AddFd(ts.GetSockfd());
  //将侦听套接字加入到听时间集合当中去
  
  while(1)
  {
    struct timeval tv;
    tv.tv_sec = 2;
    tv.tv_usec = 0;
    std::vector<TcpSvr> vec;
    vec.clear();
    //开始侦听
    int ret = ss.SelectWait(&tv, &vec);
    cout << "vec.size(): " << vec.size() << endl;
    if(ret < 0)
    {
      perror("select");
      return -1;
    }
    else if(ret == 0)
    {
      continue;
    }
    //开始循环判断事件集合中的就绪描述符
    for(size_t i = 0; i < vec.size(); i++)
    {
      //如果是侦听套接字
      if(vec[i].GetSockfd() == ts.GetSockfd())
      {
        cout << "begin accept...\n"<< endl;
        //创建新的套接字
        TcpSvr new_ts;
        struct sockaddr_in peer_addr;
        socklen_t peer_addrlen = sizeof(peer_addr);
        ts.Accept(&new_ts, &peer_addr, &peer_addrlen);
        printf("new socket is %d, peer_ip is %s, peer_port is %d\n", new_ts.GetSockfd(), inet_ntoa(peer_addr.sin_addr), ntohs(peer_addr.sin_port));
        //添加新的文件描述符到读事件集合中
        ss.AddFd(new_ts.GetSockfd());
      }
      else 
      {
        //开始沟通
        TcpSvr new_tcp_svr = vec[i];
        string data;
        data.clear();
        int ret = new_tcp_svr.Recv(&data);
        if(ret < 0)
        {
          perror("Recv");
          //对端关闭了，那么关闭套接字
          close(new_tcp_svr.GetSockfd());
          //将文件描述符从事件集合中移除出来
          ss.DeleteFd(new_tcp_svr.GetSockfd());
          continue;
        }
        else if(ret == 0)
        {
          close(new_tcp_svr.GetSockfd());
          ss.DeleteFd(new_tcp_svr.GetSockfd());
          continue;
        }
        printf("Recv data %s\n", data.c_str());
        string send_data = "i am server~~";
        new_tcp_svr.Send(send_data);
      }
    }
  }
  close (ts.GetSockfd());
  return 0;
}