可参考的典型的TCP client class

//.h

#pragma once
#include <WINSOCK2.H>




#define TCP 0
#define UDP 1
//using namespace std
using  std::string;


class abstractclient
{
public:
SOCKET msockfd;
int mserverport;
int mtimeout;
int mtransmode;
char *mserverip;
char *mhostname;//域名
char *mclientip;
char *msendbuf;
char *mrecvbuf;
int  mNeedSend;//要发送的数据
int  mRecvBufLen;//接受缓冲区大小


public:
abstractclient(int port, char *serip, char *hostname,int t_mode);
virtual ~abstractclient(void);
bool init_socket();
void Close();
void SetBlock(bool bblock);
bool Checktimeout(bool isread);
bool ConnectServer(void);
int SendData(void);
int RecvDate(void);
//virtual bool SendCommand(const char* szMessage)=0;


};

//.cpp

#include "StdAfx.h"
#include "abstractclient.h"




abstractclient::abstractclient(int port, char *serip,char *hostname, int t_mode)
{
mserverport = port;
mtransmode = t_mode;
mtimeout = 10;//10 sec
msockfd = -1;
mserverip = NULL;
mhostname = NULL;
mRecvBufLen = 0;
mNeedSend = 0;
msendbuf = NULL;
mrecvbuf = NULL;

if( serip!=NULL)
{

mserverip = (char *)malloc(32);
if(mserverip )
{
snprintf(mserverip,32,"%s",serip);
}

}


if( hostname!=NULL)
{

mhostname = (char *)malloc(128);

if(mhostname)

{
snprintf(mhostname,128,"%s",hostname);

}

}

}


abstractclient::~abstractclient(void)
{

if(mserverip!=NULL)
{
free((void *)mserverip);
}
if(mhostname!=NULL)
{
free((void *)mhostname);
}
Close();
printf("release abstractclient !\n");
}


void abstractclient::Close()
{
#ifdef Linux
if(msockfd >= 0)
{
shutdown(msockfd,SHUT_WR);
close(msockfd);
}
#elif _WIN32_WINNT
if(msockfd >= 0)
{
shutdown(msockfd,SD_SEND);
closesocket(msockfd);
}
#endif


msockfd = -1;
}


//设置网络套接字阻塞或者非阻塞
void abstractclient::SetBlock(bool bblock)
{
#ifdef Linux
int mode = bblock ? 0 : 1;
ioctl(msockfd, FIONBIO, &mode); //设置为非阻塞模式
#elif _WIN32_WINNT
unsigned long op = bblock ? 0 : 1;
if (ioctlsocket(msockfd, FIONBIO, &op) == SOCKET_ERROR)
{
printf("Unable to Set Blocking");
}
#endif
}


//判断网络是否超时
bool abstractclient::Checktimeout(bool isread)
{
int len;
fd_set writeset;
fd_set readset;
fd_set *fdset = NULL;
struct timeval tm;
len = sizeof(int);
tm.tv_sec = mtimeout;
tm.tv_usec = 0;
FD_ZERO(&readset);
FD_ZERO(&writeset);


if(isread)
{
FD_SET(msockfd, &readset);
fdset = &readset;
}
else
{
FD_SET(msockfd, &writeset);
fdset = &writeset;
}


/* 等待连接，如果超时（10s），那么返回连接错误 by wangjidong*/
if (select(msockfd + 1,&readset,&writeset, NULL, &tm) > 0)
{
if(FD_ISSET(msockfd,fdset))
{
return false;
}
else
{
return true;
}

}
else
{
return true;   
}






return false;
}




// 初始化socket
bool abstractclient::init_socket()
{


if(mtransmode == UDP)
{
msockfd = socket(AF_INET, SOCK_DGRAM, 0);
}
else
{
msockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
}

if (0 > msockfd)
{
return false;
}
 
unsigned int nBufferSize = 40960;
unsigned int nBufferSize2 = 40960;
int reuse = TRUE;
setsockopt(msockfd, SOL_SOCKET, SO_SNDBUF, (char *)&nBufferSize2, sizeof(nBufferSize2));
setsockopt(msockfd, SOL_SOCKET, SO_RCVBUF, (char *)&nBufferSize, sizeof(nBufferSize));
setsockopt(msockfd,SOL_SOCKET ,SO_REUSEADDR,(char *)&reuse,sizeof(int));


return true;   
}


// try connect server ,first init sock, then connect server
bool abstractclient::ConnectServer(void)
{
if(init_socket()==false)
{
return false;
}


sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;


serv_addr.sin_port = htons(mserverport);



if(mhostname != NULL)
{
HOSTENT *host_entry = gethostbyname(mhostname);
mserverip = inet_ntoa(*((struct in_addr *)host_entry->h_addr)) ;
}




SetBlock(false); //设置为非阻塞模式
if ((serv_addr.sin_addr.S_un.S_addr = inet_addr(mserverip)) == INADDR_NONE)
{
Close();
return false;
}   
// udp 使用connect 不需要进行三次握手,后面可以使用send  和 recv 函数
    /*
        方法一：
        socket----->sendto()或recvfrom()
        方法二：
        socket----->connect()----->send()或recv()
    */
if(connect(msockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr))== -1)
{
/* 表示内核连接已经建立启动，但是尚未完成 add by  */
#ifdef Linux
if (errno != EINPROGRESS && errno != EWOULDBLOCK)
{
Close();
return false;
}
#endif
bool isread = false;
if(Checktimeout(isread) == true)
{
Close();
return false;
}
}


/*设置socket 阻塞模式发送接收数据*/
//阻塞模式http 协议数据够用
SetBlock(true);
return true;


}


int abstractclient::SendData()
{
if(msendbuf == NULL || mNeedSend <= 0)
{
return -1;
}
bool is_read = false;


if(Checktimeout(is_read))
{
return -1;
}
int ret = send(msockfd,msendbuf,mNeedSend,0);
// ret <= 0 is false 


mNeedSend = 0;
msendbuf = NULL;


return ret;

}


int abstractclient::RecvDate()
{
if(mrecvbuf == NULL || mRecvBufLen <= 0)
{
return -1;
}


bool is_read = true;


if(Checktimeout(is_read))
{
return -1;
}


int ret = recv(msockfd,mrecvbuf,mRecvBufLen,0);
// ret <= 0 is false 
// 0 close 
// -1 network error


mRecvBufLen = 0;
mrecvbuf = NULL;


return ret;






}