1、基础的一个C++版本的服务器代码
依照C语言服务器的基础流程进行更改，整个的TCP链接流程的实现：接上篇
Socket编程-IO模型-CSDN博客
先上代码结构图，因为是示例
1、首先，这个示例的基本流程就是使用Socket，创建sockfd，进行获取sockfd'等操作，供之后的流程使用
2、InetAddress ： 这个文件中只做和地址相关的信息，比如初始化 IP，Port还有，获取IP信息等的操作方法（sockaddr_in ）。
3、Acceptor ：这个类文件里面只做和accept相关的操作，包括以下几个流程（基础功能，可以最终实现accept的操作）
设定地址和断开可复用后，流程开始，注意哦，这几个都是这个类的类成员函数，基于基础的函数进行设置。
绑定和监听。这在c语言流程中，监听之后就是accept了
但是在这里，将accept单独的设定成这个类的成员函数，自己可以决定什么时候去调用accept功能
前面的内容就是根据基本的流程更改后，C++版本的实现，我们只需要创建对象，进行调用各函数就可以了，功能实现也是函数之间的相互联系和嵌套。
4、InitConnetion : 这个就是对整体的链接进行操作和控制，（而创建一个对象，就相当于是创建了一个链接，然后我们执行这个链接所包含的操作），每个链接都是不同的。
与之类似的，就是这些类凸显了细分的功能：每一个功能，我们都将它设定成了对应的类，当我们需要创建大量的链接时，基于这些类创建出我们需要的对象，不同对象执行不同的操作。这里最明显的就是InetConnection ，可以使用其创建不同的对象，那么不同的对象是不是意味着不同的链接。只不过本例。只能实现单链接，其他的后面写。下面上代码
5、其中ProcessIO ，是为了进行程序的IO操作，读写功能的实现。
//写这个的时候，更多的还是注意类功能的实现和整体实现目标结构的设定（比如这里，就是服务器，就按照服务器结构来就行），不要盯着某一个成员函数的功能去看。我们需要调用谁，实现什么功能，就在合适的时候将它调用出来就行。
因为C++类的特征明显，每个类都是要解决一部分相关问题和操作的（类似这个，类的不同对应着服务器流程中的不同阶段或者某一模块功能）
其他代码也一样。之前看过很多代码文件命名不清晰或者名字相近还没有说明，只有一堆代码，也没有注释，理解上有歧义的情况下，特容易导致方向上的错误，看起来就太累了。
//这个可能写的也不太好。。后面多改进，在核心主线的基础上，拓展功能
代码示例：
Socket：
#ifndef __SOCKET_H__ #define __SOCKET_H__ #include "NonCopyable.h" class Socket : NonCopyable { public: Socket(); explicit Socket(int fd); ~Socket(); int fd() const; void shutDownWrite(); private: int _fd; }; #endif#include "Socket.h" #include <sys/types.h> #include <sys/socket.h> #include <stdio.h> #include <unistd.h> Socket::Socket() { _fd = ::socket(AF_INET, SOCK_STREAM, 0); if(_fd < 0) { perror("socket"); return; } } Socket::Socket(int fd) : _fd(fd) { } Socket::~Socket() { close(_fd); } int Socket::fd() const { return _fd; } void Socket::shutDownWrite() { //关闭写端 int ret = shutdown(_fd, SHUT_WR); if(ret) { perror("shutdown"); return; } }
InetAddress
#ifndef __INETADDRESS_H__ #define __INETADDRESS_H__ #include <arpa/inet.h> #include <string> #include <iostream> using std::string; class InetAddress{ private: struct sockaddr_in _serverAddr; string _ip; int _port; public: InetAddress(const string &ip,unsigned short port); InetAddress(const struct sockaddr_in &addr); ~InetAddress(); string getServerIP() const; unsigned short getServerPort() const; const sockaddr_in *getInetAddrPtr() const; // 因为我们的类通常需要和其他类进行关联协作 // 在必要时候需要获取到类中的数据信息（如果是私有的，就需要设定一个公共权限的获取函数） }; #endifInetAddress.cc
#include "InetAddress.h" #include <string.h> //初始化服务器的IP，端口，和协议 InetAddress::InetAddress(const string &ip, unsigned short port){ ::bzero(&_serverAddr, sizeof(struct sockaddr_in)); _serverAddr.sin_addr.s_addr = inet_addr(ip.c_str()); _serverAddr.sin_port = htons(port); _serverAddr.sin_family = AF_INET; } InetAddress::InetAddress(const struct sockaddr_in &addr){ _serverAddr.sin_addr.s_addr = addr.sin_addr.s_addr; _serverAddr.sin_family = addr.sin_family; _serverAddr.sin_port = addr.sin_port; } InetAddress::~InetAddress(){ } //返回sockaddr_in sockaddr的地址族信息 const sockaddr_in * InetAddress::getInetAddrPtr() const { return &_serverAddr; } string InetAddress::getServerIP() const{ return string(inet_ntoa(_serverAddr.sin_addr)); } unsigned short InetAddress::getServerPort()const{ return _serverAddr.sin_port; }
Acceptor
#ifndef __ACCEPTOR_H__ #define __ACCEPTOR_H__ #include "Socket.h" #include "InetAddress.h" #include <string> using std::string; class Acceptor { public: Acceptor(const string &ip, unsigned short port); ~Acceptor(); void ready(); void setReuseAddr(); void setReusePort(); void bind(); void listen(); int accept(); int fd() const; private: Socket _listenSock; InetAddress _servAddr; }; #endifAcceptor.cc
#include "Acceptor.h" #include <stdio.h> Acceptor::Acceptor(const string &ip, unsigned short port) : _listenSock() , _servAddr(ip, port) { } Acceptor::~Acceptor() { } void Acceptor::ready() { setReuseAddr(); setReusePort(); bind(); listen(); //accept(); } void Acceptor::setReuseAddr() { int on = 1; int ret = setsockopt(_listenSock.fd(), SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); if(ret) { perror("setsockopt"); return; } } void Acceptor::setReusePort() { int on = 1; int ret = setsockopt(_listenSock.fd(), SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)); if(-1 == ret) { perror("setsockopt"); return; } } void Acceptor::bind() { int ret = ::bind(_listenSock.fd(), (struct sockaddr *)_servAddr.getInetAddrPtr(), sizeof(struct sockaddr)); if(-1 == ret) { perror("bind"); return; } } void Acceptor::listen() { int ret = ::listen(_listenSock.fd(), 128); if(-1 == ret) { perror("listen"); return; } } int Acceptor::accept() { int connfd = ::accept(_listenSock.fd(), nullptr, nullptr); if(-1 == connfd) { perror("listen"); return -1; } return connfd; } int Acceptor::fd() const { return _listenSock.fd(); }
InitConnection
/* /* 这个类就是用来实现初始化创建链接的整个过程（从socket 到accept 成功创建链接），或者说用来实现整个流程的枢纽，运行实现就行了 */ #ifndef __INITCONNETION_H__ #define __INITCONNETION_H__ #include "Socket.h" #include "InetAddress.h" #include "ProcessIO.h" #include <string> using std::string; class InitConnection{ private: Socket _sock; ProcessIO _processio; InetAddress _localaddr; InetAddress _peeraddr; private: InetAddress getLocalAddress(); InetAddress getpeerAddress(); public: InitConnection(int fd); ~InitConnection(); void send(const string &msg); string receive(); string printConnetionInfo(); }; #endif#include "InitConnection.h" #include <iostream> #include <sstream> using std::cout; using std::endl; using std::ostringstream; InitConnection::InitConnection(int fd) :_sock(fd) ,_localaddr(getLocalAddress()) ,_peeraddr(getpeerAddress()) ,_processio(_sock.fd()) //实际上运行到这里，_sock的 fd已经时经过accept处理的已连接文件描述符，直接用就行 { } InitConnection::~InitConnection(){ } InetAddress InitConnection::getLocalAddress(){ struct sockaddr_in addr; socklen_t socklen = sizeof(struct sockaddr); int ret = getsockname(_sock.fd(),(struct sockaddr *)&addr,&socklen); if(ret == -1){ perror("InitConnection getsockaddr "); } return InetAddress(addr); //因为我们使用服务器的地址进行初始化时， } InetAddress InitConnection::getpeerAddress(){ struct sockaddr_in addr; socklen_t socklen = sizeof(struct sockaddr); int ret = getpeername(_sock.fd(),(struct sockaddr *)&addr,&socklen); if(ret == -1){ perror("InitConnection getpeersockaddr "); } return InetAddress(addr); } string InitConnection::printConnetionInfo(){ ostringstream oss1; oss1 << "服务端地址 "<< _localaddr.getServerIP() << ": " << _localaddr.getServerPort() << "----> 客户端地址" << _peeraddr.getServerIP() << ": " << _peeraddr.getServerPort() << ": "; return oss1.str(); } void InitConnection::send(const string &msg) { _processio.writen(msg.c_str(), msg.size()); } string InitConnection::receive() { char buff[65535] = {0}; //这里设定的足够大，才能在我们真正进行读写IO操作时，可以保证正常读取，但是注意不要过大，毕竟系统存储空间是有限的，资源合理利用 _processio.readLine(buff, sizeof(buff)); return string(buff); }
ProcessIO
#ifndef __SOCKETIO_H__ #define __SOCKETIO_H__ class ProcessIO{ public: explicit ProcessIO(int fd); ~ProcessIO(); int readn(char *buf,int len); int readLine(char *buf, int len); int writen(const char *buf, int len); private: int _fd; //这个就是链接 accept后生成的文件描述符 }; #endif#include "ProcessIO.h" #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <error.h> #include <stdio.h> ProcessIO::ProcessIO(int fd){ _fd = fd; } ProcessIO::~ProcessIO(){ //因为这个只进行基于数据读写的操作，所以不在这里进行释放 _fd,会在这个访问链接整体断开后的情况下，进行释放。 //因为系统的文件描述符是有限的，最好是释放后再重新创建 //close(_fd); } int ProcessIO::readn(char *buf,int len){ //此处考虑从客户端接收的数据大小问题，buf大小可以设定大一些 int left = len; char * pstr = buf; //这个函数设定中能实现的基础时这个buf 足够大，可放得下读取的客户端信息信息 int ret = 0; while(left > 0){ ret = read(_fd, buf, len); if(-1 == ret){ perror("read error -1"); return len-ret; } else if(0 == ret){ break; } else{ pstr += ret; //一次不能读完的情况下，将buf指针指向当前读取到数据的最后一个，方便将数写入buf中 left -= ret; //读取的数据总量 } } return len - left; //这里，因为上面的循环读取，正常情况下一定会将数据读取完后退出，这里返回下buf中读取到的数据大小 } int ProcessIO::readLine(char *buf, int len){ //因为直接使用read，我们没办法控制读取一行数据，只能将数据读取后，进行处理 //如果使用read，那我们就需要多开辟一块缓存空间去存储数据，不然无法有效将原buf中 某一行数据读取出来 //但是可以使用recv（）,这个不会清空缓存区，我们只要再次调用读写就行，不过就是对字节数有限制 int left = len-1; char * pstr = buf; int total = 0,linesize = 0; //读取的总字节数和行字数 while(left > 0){ int ret = recv(_fd, buf, len, MSG_PEEK); //这个属性不会清空缓存区域，也就是读取后，本缓存区内容在下一次调用这同一个函数时，buf内容相同 if( 0 == ret){ break; } else if(-1 == ret){ //这里原来写了错误判断 errno， 但是头文件有问题删了。产生eintr系统调用错误时，本系统调用可以再次调用进行使用，可以重启此调用，但是有的不行 continue; } if(-1 == ret){ perror("readline error -1"); return len - left; //这里表示本次循环虽然出错了，之前可能正常读取到了信息，返回下数量 } else{ for(int idx = 0; idx < ret ; idx++){ if(pstr[idx] == '\n'){ linesize = idx+1; //读取一行时，最后一个字符一定时换行符， readn(pstr,linesize); //这里就是直接调用上面的函数，相当于执行一个read，读取一行数据，存储在buf中 pstr += linesize; *pstr = '\n'; return total+linesize; } } //如果没有执行上面循环中的if结构，那就说明，还没有读到换行符，没有读够一行 total += ret; //这里因为 readn中也有ret ，有时注意下变量命名 readn(pstr, ret); //直接将数据读入到缓冲区中 pstr += ret; //pstr位置更行 left -= ret; //剩余可读取数量更新 ，之后执行下一次读写循环 } } *pstr = '\0'; //只要buf够大，最后一个元素一定时 \0 return total =- left; } int ProcessIO::writen(const char *buf, int len){ int left = len; const char *pstr = buf; int ret = 0; while(left > 0){ ret = write(_fd, pstr, left); if(-1 == ret) { continue; } else if(-1 == ret) { perror("writen error -1"); return len - ret; } else if(0 == ret) { break; } else { pstr += ret; left -= ret; } } return len - left; }
NonCopyable
#ifndef __NONCOPYABLE_H__ #define __NONCOPYABLE_H__ class NonCopyable{ protected: NonCopyable(){}; ~NonCopyable(){}; NonCopyable (const NonCopyable &) = delete; //赋值运算符 NonCopyable &operator&=(const NonCopyable) = delete; }; #endiftestServer
#include "Acceptor.h" #include "InitConnection.h" #include <iostream> #include <unistd.h> //这个案例 目前只能链接一个客户端 using std::cout; using std::endl; void test1(){ Acceptor acceptor1("127.0.0.1",8888); acceptor1.ready(); //这里就是已经到accept 步骤了 InitConnection conn(acceptor1.accept()); //这里呢，实际上，就是connection 类中需要已经链接好的fd参数，进行Connection中的操作 //InitConnection conn2(acceptor1.accept()); cout<< conn.printConnetionInfo() << "链接成功"<<endl; //cout<< conn2.printConnetionInfo() << "链接成功"<<endl; //测试同时开启两个不行，还是需要写多路复用后才可以 while(1) { cout << ">>recv msg from client: " << conn.receive() << endl; conn.send("hello baby\n"); } } int main(){ test1(); return 0; }
测试结果
使用telnet进行测试，当我测试发送中文时，telnet 默认发送了数字
//有问题或者发现问题，可以直接留言
