TCP服务端程序 C++

说明

Qt中一般会拥有TCP UDP通信的相关的库，使用Qt进行TCP服务端的开发无需使用该程序。写着部分程序考虑到大部分的C++开发软件是并不会自带相应的库的，所以这里就写一个windows下C++进行TCP通信的简单服务器程序。

相关库

这里的ws2_32.dll是windows自带的，头文件为winsocket2.h一般也是自带的，而WS2_32.lib是需要自行下载配置的，所以需要下载一个WS2_32.lib文件。此处给一个腾讯微云的下载链接WS2_32.lib。

特别说明

考虑到部分同学可能没接触过TCP通信，TCP服务器使用的IP地址必须是已有的IP地址，一般默认可以使用的IP地址为127.0.0.1,如果WiFi或者以太网有连接还会有其他的IP地址。查看这些IP地址可以使用相应的调试软件查看，也可以自行写一段程序进行查看。这里给一个以前师兄给的调试软件，腾讯微云的下载连接TCP Test Tool。

相关程序

程序中提供了断线重连的相关程序，我这部分程序就是为了和采集卡相连的，所以就设计只与一个客户端相连的情况，如果需要实现多客户端相连的情况，程序中提供了大致的样式，可自行修改。程序中使用的CDebug是另一个博客中字写的MFC调试程序，如果需要实现在其他条件下的运行，可自行修改，使用对应的输出程序替换即可或者直接删除。

//CTCPServer.h
#pragma once
#include 
#include 
#include 
#include    // std::mem_fn

#pragma comment(lib, "Ws2_32.lib")

#define DEFAULT_IP "192.168.62.166"    //保证是本地IP，该值可以通过调试软件获得，默认可以使用localhost，即127.0.0.1
#define DEFAULT_PORT 44444             //端口随便选
#define DEFAULT_TIME_OUT 3000 // 3 seconds;

using namespace std;

class CTCPServer
{
public:
	CTCPServer();
	~CTCPServer();
	bool Init(string ip, int port);
private:
	
	bool Accept();
	void StartThread(string ip, int port);
	void reStartThread();
	bool RecvThread();


public:
	bool IsStart();
	bool IsConnect();
	bool IsClose();

	thread Start(string ip = DEFAULT_IP, int port = DEFAULT_PORT);
	thread reStart();
	thread RecvData();
	bool Close();
	bool SendData(string data);

private:
	bool m_IsInit;
	bool m_IsStart;
	bool m_IsConnect;
	bool m_IsClose;

	SOCKET m_ListenSocket;
	SOCKET m_ClientSocket;
	//SOCKET myClientSocket[20];     //连20个客户端
	//bool myConnect[20];            //对应的连接标志也应当有20个


};
//CTCPSever.cpp
#include "pch.h"
#include "CTCPServer.h"
#include "CDebug.h"
#include 
CTCPServer::CTCPServer()
{
	m_IsInit = false;
	m_IsStart = false;
	m_IsConnect = false;
	m_IsClose = false;
}

CTCPServer::~CTCPServer()
{
	if (!m_IsClose) {
		Close();
	}
}

bool CTCPServer::Init(string ip, int port)
{
	WORD sockVersion = MAKEWORD(2, 2);
	WSADATA wsaData;
	if (WSAStartup(sockVersion, &wsaData) != 0) {       //启动并初始化winsocket
		return false;
	}
	m_ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);  //创建socket
	if (m_ListenSocket == INVALID_SOCKET) {
		
		return false;
	}
	
	SOCKADDR_IN sin;        //准备通信地址
	sin.sin_family = AF_INET;
	sin.sin_port = htons(port);
	sin.sin_addr.S_un.S_addr = inet_addr(ip.c_str());

	//绑定地址与socket
	if ((::bind(m_ListenSocket, (LPSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR))
	{
		return false;
	}
	if (listen(m_ListenSocket, 20) == SOCKET_ERROR) {
		closesocket(m_ListenSocket);
		WSACleanup();
		return false;
	}
	m_IsInit = true;
	return true;
}

bool CTCPServer::Accept()
{
	struct sockaddr_in remoteAddr;
	int nAddrlen = sizeof(remoteAddr);
	m_ClientSocket = accept(m_ListenSocket, (SOCKADDR*)&remoteAddr, &nAddrlen);
	CDebug()<<inet_ntoa(remoteAddr.sin_addr)<<":"<<remoteAddr.sin_port;
	if (m_ClientSocket == INVALID_SOCKET)
	{
		return false;
	}
	m_IsConnect = true;
	CDebug() << "connect successful!" << Cendl;
	RecvData().detach();
	return true;
}

void CTCPServer::StartThread(string ip, int port) //线程
{
	while (!m_IsStart) {


		if (!m_IsInit) {

			if (!Init(ip, port)) {  //初始化

				continue;
			}

			m_IsStart = true;
		}
	}
		while (!m_IsConnect) {   //连接，只能连接一个客户端
			Accept();
		}
}

void CTCPServer::reStartThread() //线程
{
	while(!m_IsConnect) {   //连接，只能连接一个客户端
		Accept();
	}
}


bool CTCPServer::RecvThread() //接收
{
	while (!IsConnect()) {   //等待连接
	}
	while (m_IsStart)
	{
		char revData[1025];
		int ret = 0;
		ret = recv(m_ClientSocket, revData, 1024, 0);
		if (ret <= 0) {
			//ret=0表示正常断开,ret=-1表示异常中断，此时需要完成的是准备重连的工作
			string str = "连接中断";
			switch (ret)
			{
			case 0:str = "正常断开"; break;
			case -1:str = "异常中断"; break;
			}
			//连接异常中断
			CDebug() << "error:"<<str;
			//此处不需要关闭监听的socket，需要重开m_ClientSocket
			m_IsConnect = false;

			if (m_ClientSocket != INVALID_SOCKET) {
				int ret = closesocket(m_ClientSocket);
				if (ret != 0) {
					CDebug() << "关闭异常";
					return false;
				}

			}
			reStart().join();
			RecvData().detach();
			return false;   //重连后开启了另一个线程了，该线程不在用于通信，就该结束了
		}
		revData[ret] = '\0';

		CDebug() << revData << Cendl;
	}
	return true;
}

thread CTCPServer::reStart() //开启线程，等待连接
{
	thread t(mem_fn(&CTCPServer::reStartThread), this);

	return t;
}
thread CTCPServer::Start(string ip /*= DEFAULT_IP*/, int port /*= DEFAULT_PORT*/) //开启线程，等待连接
{
	thread t(mem_fn(&CTCPServer::StartThread), this, ip, port);
	return t;
}

bool CTCPServer::IsStart()
{
	return m_IsStart;
}

bool CTCPServer::IsConnect()
{
	return m_IsStart;
}

bool CTCPServer::IsClose()
{
	return m_IsClose;
}

bool CTCPServer::Close()  //关闭
{
	m_IsInit = false;
	m_IsStart = false;
	m_IsConnect = false;
	m_IsClose = true;
	if (m_ListenSocket != INVALID_SOCKET) {
		int ret = closesocket(m_ListenSocket);
		if (ret != 0) {
			return false;
		}
	}
	if (m_ClientSocket != INVALID_SOCKET) {
		int ret = closesocket(m_ClientSocket);
		if (ret != 0) {
			return false;
		}
		
	}
	int ret = WSACleanup();
	if (ret != 0) {
		return false;
	}
	return true;
}

bool CTCPServer::SendData(string data)  //发送
{
	int ret = send(m_ClientSocket, data.c_str(), strlen(data.c_str()), 0);
	if (ret != 0) {
		return false;
	}
	return true;
}


thread CTCPServer::RecvData()   //开启数据接收线程
{
	thread t(mem_fn(&CTCPServer::RecvThread), this);
	return t;

}

使用

定义开启和关闭操作，使用起来相当的简单，接收数据只需要处理一下数据接收的程序即可。

//定义
CTCPServer tcpServer;
//开启
tcpServer.Start().detach();
//关闭
tcpServer.Close();