C++的tcp和udp例子类 2011

本文详细介绍了一个用于Linux环境下的Socket编程类实现,包括不同构造函数的使用、创建套接字、绑定监听、客户端和服务端的连接及数据收发等功能。通过错误码枚举定义确保了错误处理的一致性和明确性。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

const unsigned int MySOCKET_DEFAULT_PORT= 4096;
mylinuxsocket::mylinuxsocket()
{
 
 m_bstate_connect = false;
    address_family=AF_INET;
    socket_type=SOCK_STREAM;
    protocol_family=IPPROTO_TCP;
    port_number = MySOCKET_DEFAULT_PORT;
    mysocket = -1;
 
   socket_error = MySOCKET_NO_ERROR;
   bytes_send = 0;
   bytes_read  = 0;
}
//构造函数:指定端口,套接字类型,端口名,创建套接字
mylinuxsocket::mylinuxsocket(int port, int stype, char* strhostname)     
{
    bytes_send = 0;
   bytes_read  = 0;
 m_bstate_connect = false;
 socket_error=MySOCKET_NO_ERROR;
 
 address_family=AF_INET;
   port_number=port;
   if (stype == SOCK_STREAM)          //判断套接字的类型
   {
      socket_type=SOCK_STREAM;
      protocol_family=IPPROTO_TCP;
   }
   else if(st==SOCK_DGRAM)   
   {
       socket_type=SOCK_DGRAM;
       protocol_family=IPPROTO_UDP;
   }
   else
   {
    socket_error = MySOCKET_SOCKETTYPE_ERROR;
  return -1;
 }
   sockaddr_sin.sin_family=address_family;
     if (strhostname)
  {
          hostent *hostentnm = gethostbyname(strhostname);
         if (hostentnm==(struct hostent *)0){
         socket_error=MySOCKET_HOSTNAME_ERROR;
      return -1;
  }
   sockaddr_sin.sin_addr.s_addr=*((unsigned long*) hostentnm->h_addr);
   else
   sockaddr_sin.sin_addr.s_addr=INADDR_ANY;
     sockaddr_sin.sin_port=htons(port_number);
  mysocket=socket(address_family, socket_type, protocol_family);
 
}
//构造函数:指定协议家族, 地址家族,端口,套接字类型,端口名,创建套接字
mylinuxsocket::mylinuxsocket(sa_family_t af,int stype,int pro_family,
   int port,char *strhostname)
{
    bytes_send = 0;
   bytes_read  = 0;
     address_family = af;
        socket_type = stype;
      protocol_family = pro_family;
    port_number = port;
 sockaddr_sin.sin_family = address_family;
    socket_error = MySOCKET_NO_ERROR;
    m_bstate_connect = false;
 if (strhostname) {
 struct hostent *hostentnm = gethostbyname(strhostname);
 if(hostentnm==(struct hostent *) 0) {
  socket_error=MySOCKET_HOSTNAME_ERROR;
  return -1;
 }
 sockaddr_sin.sin_addr.s_addr=*((unsigned long*) hostnm->h_addr);
 }
 else
   sockaddr_sin.sin_addr.s_addr=INADDR_ANY;
 sockaddr_sin.sin_port=htons(port_number);
 Mysocket=socket(address_family, socket_type, protocol_family);
}
//创建初始化套接字函数,创建套接字
int mylinuxsocket::socket_create(void)
{
 mysocket = =socket(address_family, socket_type, protocol_family);
 if (mysocket<0)
 {
     socket_error=MySOCKET_INIT_ERROR;
     return -1;
 }
 return mysocket;

}
//服务端套接字绑定监听函数, 返回值   -1:失败           0:成功
unsigned long mylinuxsocket::bindserver_listen(int maxconn_num)
{
 
  if(bind(mysocket,(struct sockaddr*)&sockaddr_sin, sizeof(struct sockaddr*)) == -1)
  {
   socket_error=MySOCKET_BIND_ERROR;
   return -1;
  }
  if(listen(Mysocket,maxconn_num) == -1)
  {
   socket_error=MySOCKET_LISTEN_ERROR;
   return -1;
  
  }
  return 0;
}
//客户端套接字连接函数
unsigned int mylinuxsocket::sock_connect()
{
   if(connect(mysocket,(struct sockaddr*)&sin,sizeof(sin)) == -1)
   {
    socket_error=MySOCKET_CONNECT_ERROR;
    m_bstate_connect = false;
    return -1;
  
   }
   else
   {
    m_bstate_connect = true;
    return 1;
  
   }
}
//服务端接受函数
unsigned int mylinuxsocket::sock_accept()
{
 socklen_t addr_size = (socklen_t)sizeof(remote_addrsin);
 conn_socket = accept(mysocket,(struct sockaddr*)&remote_addrsin , &addr_size);
 if(conn_socket < 0)
 {
          socket_error = MySOCKET_ACCEPT_ERROR;
    return -1;
 }
 return conn_socket;
}
//服务端轮询监听接收操作
int mylinuxsocket::Read_Select(int maxsock,int seconds,int useconds)
{
 struct timeval timeout;
 fd_set readfds;
 FD_ZERO(&readfds);
 FD_SET(maxsock, &readfds);
 timeout.tv_sec = seconds;
 timeout.tv_usec = useconds;
 return select(maxsock+1, &readfds, 0 ,0, &timeout);
}
//TCP客户端接收函数
int mylinuxsocket::client_recv(void *buf, int bytes, int flags)
{
  bytes_read = 0;
  int num_reads = 0;
  int num_requestrecv = bytes;     //需要接收的字节数
  char *preceivebuffer = (char*)buf;
  //循环接收需要接收的字节数
  while(bytes_read < bytes){
   if((num_reads = recv(mysocket, preceivebuffer, num_requestrecv - bytes_read, flags))>0)
   {
    bytes_read += num_read;
    preceivebuffer += num_read;        
   }
   if (num_read<0){
    socket_error=MySOCKET_RECEIVE_ERROR;
    return -1;
   }
     }
  return bytes_read;
}
//TCP服务端接收函数
int mylinuxsocket::server_recv(int socket, void *buf, int bytes,int seconds,int useconds,int flags)
{
 bytes_read=0;
 int num_read = 0;
 int num_requestrecv = (int)bytes;
 char*preceivebuffer = (char*)buf;
 while(bytes_read < bytes)
 {
  if(!ReadSelect(socket, seconds,useconds)){
   socket_error=MySOCKET_REQUEST_TIMEOUT;
   return -1;
  }
  if((num_read = recv(socket, p, num_requestrecv - bytes_read, flags))>0){
   bytes_read += num_read;
   preceivebuffer += num_read;
  }
  if(num_read < 0){
   socket_error = MySOCKET_RECEIVE_ERROR;
   return -1;
  }
 }
 return bytes_read;
}
//TCP发送函数
int mylinuxsocket::sock_send(int soket,const void *buf,int bytes,int flags)
{
    bytes_send = 0;
  int num_sends = 0;
  int num_requestsend = (int)bytes;
  char *psendbuffer = (char*)buf;
  while(bytes_send < num_requestsend)
  {
   if((num_sends = send(soket, psendbuffer,  num_requestsend - bytes_send, flags))>0)
   {
    bytes_send += num_sends;
    psendbuffer += num_sends;
   }
   if(num_sends<0){
    socket_error=MySOCKET_TRANSMIT_ERROR;
    return -1;
   }
     }
  return bytes_send;
}
//服务端UDP接收函数
int mylinuxsocket::udprecvfrom(void *buf, int bytes, int seconds, int useconds,int flags)
{
 socklen_t addr_size = (socklen_t)sizeof(sockaddr_in);
 bytes_read = 0;
 int num_read = 0;
 int num_req = (int)bytes;
 char *preceivebuffer = (char *)buf;
 while(bytes_read < bytes) {
  if(!ReadSelect(mysocket, seconds, useconds)) {
   socket_error = MySOCKET_REQUEST_TIMEOUT;
   return -1;
  }
  if((num_read = recvfrom(mysocket, preceivebuffer, num_req - bytes_read, flags
   , (struct sockaddr *)remote_addrsin, &addr_size)) > 0) {
   bytes_read += num_read;
   preceivebuffer += num_read;
  }
  if(num_read < 0) {
   socket_error = MySOCKET_RECEIVE_ERROR;
   return -1;
  }
 }
 return bytes_read;
}
//客户端UDP接收函数
int mylinuxsocket::udprecvfrom(void *buf, int bytes, int flags)
{
 socklen_t addr_size = (socklen_t)sizeof(sockaddr_in);
  int num_read = 0;
 int num_req = (int)bytes;
 char *preceivebuffer = (char *)buf;
      while(bytes_read < bytes)
   {
   if((num_read = recvfrom(mysocket, preceivebuffer, num_req - bytes_read
    , flags, (struct sockaddr *)sockaddr_sin, &addr_size)) > 0)
   {
    bytes_read += num_read;
    p += num_read;
   }
     if(num_read < 0)
  {
    socket_error = MySOCKET_RECEIVE_ERROR;
    return -1;
       }

       }
   return bytes_read;
}
//udp发送函数
int mylinuxsocket::udpSendTo(void *buf, int bytes, int flags)
{
  int addr_size = (int)sizeof(sockaddr_in);
 bytes_send = 0;
 int num_moved = 0;
 int num_req = (int)bytes;
 char *pSendbuffer = (char *)buf;
  while(bytes_moved < bytes)
  {
  if((num_moved = sendto(mysocket, pSendbuffer, num_req-bytes_moved, flags
   , (const struct sockaddr *)sockaddr_sin, addr_size)) > 0)
  {
   bytes_send += num_moved;
   pSendbuffer += num_moved;
  }
    if(num_moved < 0)
    {
           socket_error = MySOCKET_TRANSMIT_ERROR;
          return -1;
       }
       }
   return bytes_send;
}
 

enum MySocketError{
 MySOCKET_NO_ERROR=0,
 MySOCKET_INVALID_ERROR_CODE,
 MySOCKET_ACCEPT_ERROR,
 MySOCKET_BIND_ERROR,
 MySOCKET_BUFOVER_ERROR,
 MySOCKET_CONNECT_ERROR,
 MySOCKET_FILESYSTEM_ERROR,
 MySOCKET_GETOPTION_ERROR,
 MySOCKET_HOSTNAME_ERROR,
 MySOCKET_INIT_ERROR,
 MySOCKET_LISTEN_ERROR,
 MySOCKET_PEERNAME_ERROR,
 MySOCKET_PROTOCOL_ERROR,
 MySOCKET_RECEIVE_ERROR,
 MySOCKET_REQUEST_TIMEOUT,
 MySOCKET_SERVICE_ERROR,
 MySOCKET_SETOPTION_ERROR,
 MySOCKET_SOCKNAME_ERROR,
 MySOCKET_SOCKETTYPE_ERROR,
 MySOCKET_TRANSMIT_ERROR,
};
#include"mysocket.h"
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <string.h>
#include <fcntl.h>
#include <netdb.h>
class mylinuxsocket
{
 protected:
  sa_family_t address_family;
   int socket_type;
   int port_number;
   int protocol_family;

   sockaddr_in remote_addrsin;
   sockaddr_in sockaddr_sin;
   MySocketError socket_error;
 
   int mysocket;
  
public:
 mylinuxsocket();
 virtual ~mylinuxsocket();
  mylinuxsocket(int port, int stype, char* strhostname);
  mylinuxsocket(sa_family_t af,int stype,int pro_family,
   int port,char *strhostname);
 int socket_create(void);
 unsigned long bindserver_listen(int maxconn_num);
 unsigned int sock_connect();
 unsigned int sock_accept();
 int Read_Select(int maxsock,int seconds,int useconds);
 int client_recv(void *buf, int bytes, int flags);
 int server_recv(int socket,void *pbuf,int bytes, int seconds,int useconds,int flags);
 int sock_send(int soket,const void *buf,int bytes,int flags);
 int udprecvfrom(void *buf, int bytes, int seconds, int useconds,int flags);
 int udprecvfrom(void *buf, int bytes, int flags);
 int udpSendTo(void *buf, int bytes, int flags);
private:
 bool m_bstate_connect;
 int conn_socket;
 int bytes_read;
 int bytes_send;

}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值