C++ 中创建客户端、服务器_c++ tcp server

作者：繁依Fanyi0 | 2024-04-03 21:50:13

踩

c++ tcp server

一、Tcp Server(服务器端)

(1)创建一个服务器端

实现服务器端大概有五个步骤：

1.初始化环境
2.创建监听套接字
3.监听套接字与IP地址及端口绑定
4.监听套接字
5.等待客户端连接

1.初始化环境

WSADATA wsaData;

WSAStartup(MAKEWORD(2, 2), &wsaData)；

WSADATA是Windows Sockets DLL的结构体，用于存储Windows Sockets在应用程序中的初始化和配置信息。在使用Windows Sockets API进行网络编程时，需要在应用程序中先调用WSAStartup函数来初始化WSADATA结构体。

WSAStartup() 是 Windows Sockets API 的一个函数，用于初始化 Winsock DLL 的使用。它接受两个参数：WORD 类型的版本号（通常为 MAKEWORD(2, 2)），以及一个指向 WSADATA 结构体的指针，该结构体用于存储调用 WSAStartup() 函数后返回的 Winsock DLL 的信息。通常在程序开始时调用 WSAStartup() 函数以初始化 Winsock

2.创建监听套接字

Socket m_listenSocket = socket(AF_INET, SOCK_STREAM, 0));

参数3可以是：IPPROTO_TCP，表示使用Tcp协议

AF_INET：指定使用IPV4协议簇
SOCK_STREAM：字节流，数据有保障的传输
0：默认协议，Tcp/Ip协议
该函数执行成功返回一个新的套接字，否则返回：INVALID_SOCKET。

3.监听套接字与ip地址及端口绑定

sockaddr_in sockadd = {0};

sockadd.sin_family = AF_INET;//IPV4协议簇
sockadd.sin_port = htons(m_uPort);//监听端口
sockadd.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//监听本机任意IP
bind(m_listenSocket, (struct sockaddr*) & sockadd, sizeof(sockadd));

sockaddr_in是一个结构体，用于存储IP地址和端口号等socket相关信息。在创建socket时，通常会创建一个sockaddr_in类型的对象，并对其进行赋值，以指定服务器的IP地址和端口号等信息。在这里，sockadd是一个sockaddr_in类型的变量，使用了零初始化，相当于将该变量的所有成员变量初始化为0。

m_listenSocket：已经创建好的监听套接字
INADDR_ANY：如果机器存在多网卡，客户端连接任意一个IP地址均可建立通信
执行失败时返回： SOCKET_ERROR

4.监听套接字

listen(m_listenSocket, 1);

m_listenSocket：绑定IP地址及端口的监听地址
1：指定最大允许同时连接的客户端数

5.等待客户端的连接

Socket m_clientSocket = accept(m_listenSocket, (struct sockaddr*) & addr, &addrlen);

提取套接字m_listenSocket上挂起连接队列的第一个连接，然后返回新套接字m_clientSocket，如过要与客户端通信就需要通过m_clientSocket来发送或接收数据
如果暂时没有客户端连接过来，该函数将阻塞在此处，直到新连接到来才会返回。

（2）收发数据

1. 接收数据
const int iBufSize = 1024;
char recvBuf[iBufSize] = { 0, };
auto iRecvSize = recv(m_clientSocket, recvBuf, iBufSize, 0);//若不支持C++11及以上，auto改为int
m_clientSocket：收发数据时，均需要用到accept()返回的客户端套接字
recvBuf：接收数据缓冲区，收到的数据就保存在该数组中
iBufSize：recvBuf数组的字节长度，最多接收到的数据长度，该缓冲区也只能接收这么多，否则会溢出，造成程序异常
0：将数据从TCP从输入队列中剪切到recvBuf，且不做其他操作
返回值：如果没有发生错误，recv将返回接收到的字节数，recvBuf参数指向的缓冲区将包含接收到的数据。如果连接已经正常关闭，则返回值为零。否则，将返回一个SOCKET_ERROR值
如果套接字m_clientSocket上没有可用的传入数据，则recv调用阻塞并等待数据并不会返回，除非定义了其他阻塞规则，此处并没有指定

2. 发送数据
std::string strMsg = "hello";
send(m_clientSocket, strMsg.c_str(), strMsg.length(), 0);

m_clientSocket：收发数据时，均需要用到accept()返回的客户端套接字
strMsg.c_str()：发送数据首地址
strMsg.length()：数据长度
0：无特别指定调用
返回值：如果没有发生错误，send返回发送的字节总数，它可能小于len参数中请求发送的字节数。否则，将返回SOCKET_ERROR的值

（3）服务器代码

Tcpserver.h


 
//CTcpServer.h
#pragma once
 
#include <string>
#include <winsock2.h>
 
#pragma comment(lib,"ws2_32")//Standard socket API.
 
class CTcpServer
{
public:
	CTcpServer(std::string strIp, unsigned int uPort);
	virtual ~CTcpServer();
 
	//初始化网络服务端
	bool InitServer();
 
	//发送数据
	bool SendMsg(const std::string& strMsg);
 
	//接收数据并打印
	bool RecvMsg();
 
private:
	unsigned int m_uPort;//监听端口
	std::string m_strIp;//用于监听本机指定IP地址
 
	SOCKET m_listenSocket = NULL;//监听套接字
	SOCKET m_clientSocket = NULL;//客户端套接字
};

Tcpserver.cpp


//CTcpServer.cpp
#include <iostream>
#include "CTcpServer.h"
 
CTcpServer::CTcpServer(std::string strIp, unsigned int uPort) :
	m_strIp(strIp),
	m_uPort(uPort)
{
}
 
CTcpServer::~CTcpServer()
{
	if (m_clientSocket)
	{
		closesocket(m_clientSocket);
		m_clientSocket = NULL;
	}
 
	if (m_listenSocket)
	{
		closesocket(m_listenSocket);
		m_listenSocket = NULL;
	}
 
	WSACleanup();
}
 
bool CTcpServer::InitServer()
{
	WSADATA	wsaData;
 
	//1. 初始化环境
	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
	{
		std::cout << "Init Windows Socket Failed!\n";
		return false;
	}
 
	//2. 创建监听套接字
	if ((m_listenSocket = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
	{
		std::cout << "Create socket failed!\n";
		return false;
	}
 
	//协议
	sockaddr_in sockadd = { 0, };
 
	sockadd.sin_family = AF_INET;//IPV4协议簇
	sockadd.sin_port = htons(m_uPort);//监听端口
	sockadd.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//监听本机任意IP
 
	//3. 监听套接字与IP地址及端口绑定
	if (bind(m_listenSocket, (struct sockaddr*) & sockadd, sizeof(sockadd)) == SOCKET_ERROR)
	{
		closesocket(m_listenSocket);
		m_listenSocket = INVALID_SOCKET;
		std::cout << "Socket bind failed!\n";
		return false;
	}
 
	//4. 监听套接字
	if (listen(m_listenSocket, 1) == SOCKET_ERROR)
	{
		closesocket(m_listenSocket);
		m_listenSocket = INVALID_SOCKET;
		std::cout << "Socket listen failed!\n";
		return false;
	}
 
	sockaddr_in addr = { 0, };
	int addrlen = sizeof(addr);
 
	//5. 等待客户端连接
	m_clientSocket = accept(m_listenSocket, (struct sockaddr*) & addr, &addrlen);
 
	if (m_clientSocket == SOCKET_ERROR)
	{
		closesocket(m_clientSocket);
		m_clientSocket = INVALID_SOCKET;
		std::cout << "Socket accept failed!\n";
		return false;
	}
 
	return true;
}
 
bool CTcpServer::SendMsg(const std::string& strMsg)
{
	if (!m_clientSocket) return false;
 
	if (send(m_clientSocket, strMsg.c_str(), strMsg.length(), 0) != INVALID_SOCKET)
	{
		std::cout << "发送成功:" << strMsg << "\n";
		return true;
	}
	else
	{
		std::cout << "发送失败!\n";
		return false;
	}
}
 
bool CTcpServer::RecvMsg()
{
	if (!m_clientSocket) return false;
 
	const int iBufSize = 1024;
	char recvBuf[iBufSize] = { 0, };
	auto iRecvSize = recv(m_clientSocket, recvBuf, iBufSize, 0);//若不支持C++11及以上，auto改为int
 
	if (iRecvSize <= 0)
	{
		std::cout << "接收失败!\n";
		return false;
	}
	else
	{
		std::cout << "接收成功:" << recvBuf << "\n";
		return true;
	}
}

main.cpp


#include <iostream>
#include "CTcpServer.h"
 
int main()
{
    {
        CTcpServer tcpServer("127.0.0.1", 6005);
 
        if (!tcpServer.InitServer())
            getchar();
 
        for (int i = 0; i != 3; ++i)
        {
        	//接收数据成功后，向客户端返回"answer"
            if (tcpServer.RecvMsg())
            {
                std::string strAnswerMsg{ "answer" };
 
                tcpServer.SendMsg(strAnswerMsg);
            }
        }
    }//接收3次数据后出此大括号，tcpServer对象被析构，客户端连接被关闭
    
    return 0;
}

二、Tcp client(客户端)

创建一个TCP客户端
1. 初始化环境
2. 创建一个新的套接字
3. 建立连接

客户端的创建比较简单，只需要三步，创建好了之后就可以进行数据的收发了
短链接：客户端与服务端建立连接之后，进行短暂的收发数据之后即断开连接（closesocket()）称为短链接
长连接：两者建立连接之后需要长时间保持该连接的成为长连接，在不需要数据交互时可以每隔一定时间其中一方发送一个心跳报文（内容可以是约定的任意值，比如字符串“heartBeat”）到另一方，另一方收到心跳报文后立即恢复一个应答（同样是约定的任意值），发送方在一定次数没有收到应答或者接收方一定次数没有收到心跳报文时，均可判定对方断线，此时可以关闭套接字或其他业务逻辑

CTcpClient.h


//CTcpClient.h
#pragma once
 
#include <string>
#include <winsock2.h>
 
#pragma comment(lib,"ws2_32")//Standard socket API.
 
class CTcpClient
{
public:
	CTcpClient(std::string strServerIp, unsigned uServerPort);
	virtual ~CTcpClient();
 
	//建立连接
	bool InitConnect();
 
	//发送数据
	bool SendMsg(const std::string& strMsg);
 
	//接收数据并打印
	bool RecvMsg();
 
private:
	SOCKET m_socket = INVALID_SOCKET;
	std::string m_strServerIp;//服务端监听IP地址
	unsigned int m_uServerPort = -1;//服务端监听端口
	struct addrinfo* m_servAddrInfo = NULL;//服务端地址结构链表
};

CTcpClient.cpp


//CTcpClient.cpp
 
#include <sstream>
#include <iostream>
#include <Ws2tcpip.h>
#include <mstcpip.h>
#include "CTcpClient.h"
 
CTcpClient::CTcpClient(std::string strServerIp, unsigned uServerPort) :
	m_strServerIp(strServerIp),
	m_uServerPort(uServerPort)
{
}
 
CTcpClient::~CTcpClient()
{
	if (m_socket != INVALID_SOCKET)
		closesocket(m_socket);
 
	WSACleanup();
	freeaddrinfo(m_servAddrInfo);
}
 
bool CTcpClient::InitConnect()
{
	WSADATA	wsaData;
 
	//1. 初始化环境
	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
	{
		std::cout << "Init Windows Socket Failed!\n";
		return false;
	}
 
	addrinfo hints = { 0, };//协议无关(IPV4 or IPV6)
 
	hints.ai_flags = AI_NUMERICHOST;
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_protocol = IPPROTO_TCP;
 
	std::stringstream ssPort;
 
	ssPort << m_uServerPort;
 
	//获取服务端地址结构
	if (getaddrinfo(m_strServerIp.c_str(), ssPort.str().c_str(), &hints, &m_servAddrInfo) != 0)
	{
		std::cout << "Get server addrInfo failed!\n";
		return false;
	}
 
	if (m_socket != INVALID_SOCKET)
		closesocket(m_socket);
 
	m_socket = INVALID_SOCKET;
 
	//2. 创建一个新的套接字
	if ((m_socket = socket(m_servAddrInfo->ai_family, m_servAddrInfo->ai_socktype, m_servAddrInfo->ai_protocol)) == SOCKET_ERROR)
		return false;
 
	//3. 建立连接
	int iResult = connect(m_socket, m_servAddrInfo->ai_addr, (int)m_servAddrInfo->ai_addrlen);
 
	if (iResult == SOCKET_ERROR)
	{
		iResult = WSAGetLastError();
		
		if (iResult != WSAEWOULDBLOCK)
		{
			std::cout << "Connect server failed!\n";
			closesocket(m_socket);
			m_socket = INVALID_SOCKET;
			return false;
		}
	}
 
	std::cout << "Connect Server succeed!\n";
	return true;
}
 
bool CTcpClient::SendMsg(const std::string& strMsg)
{
	if (!m_socket) return false;
 
	if (send(m_socket, strMsg.c_str(), strMsg.length(), 0) != INVALID_SOCKET)
	{
		std::cout << "发送成功:" << strMsg << "\n";
		return true;
	}
	else
	{
		std::cout << "发送失败!\n";
		return false;
	}
}
 
bool CTcpClient::RecvMsg()
{
	if (!m_socket) return false;
 
	const int iBufSize = 1024;
	char recvBuf[iBufSize] = { 0, };
	auto iRecvSize = recv(m_socket, recvBuf, iBufSize, 0);//若不支持C++11及以上，auto改为int
 
	if (iRecvSize <= 0)
	{
		std::cout << "接收失败!\n";
		return false;
	}
	else
	{
		std::cout << "接收成功:" << recvBuf << "\n";
		return true;
	}
}

main.cpp


#include <iostream>
#include "CTcpClient.h"
 
int main()
{
    {
        CTcpClient tcpClient("127.0.0.1", 6005);
 
        if (!tcpClient.InitConnect())
            getchar();
 
        std::string strAskMsg{ "ask" };
 
        for (int i = 0; i != 3; ++i)
        {
            if (tcpClient.SendMsg(strAskMsg))
            {
                tcpClient.RecvMsg();
            }
        }
    }
    
    getchar();
    
    return 0;
}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/356671