Qt Socket 通讯示例1

服务端代码

// QTcpServerHelp.h

#pragma once

#include <QThread>
#include <QTcpServer>
#include <QTcpSocket>
#include <iostream>

class QTcpServerHelp  : public QThread
{
	Q_OBJECT

public:
	QTcpServerHelp(QObject *parent);
	~QTcpServerHelp();

	void ServerListen();

protected:
	void run();

private slots:
	void ServerNewConnection();

	void ServerReadData();
	void ServerWriteData();

	void ServerDisconnect();
	
private:
	QTcpServer *m_pTcpServer;
	QTcpSocket *m_pTcpSocket;

	int m_nPort;

	static int m_nCount;
};

// QTcpServerHelp.cpp

#include "QTcpServerHelp.h"

using namespace std;

int QTcpServerHelp::m_nCount = 0;

QTcpServerHelp::QTcpServerHelp(QObject *parent)
{
	m_nPort = 8001;

	m_pTcpServer = new QTcpServer();	

}

QTcpServerHelp::~QTcpServerHelp()
{
	if (NULL != m_pTcpServer)
	{
		cout << "QTcpServerHelp destruct!" << endl;
		delete m_pTcpServer;
		m_pTcpServer = NULL;
	}
}

void QTcpServerHelp::run()
{
}

void QTcpServerHelp::ServerListen()
{
	connect(m_pTcpServer, SIGNAL(newConnection()), this, SLOT(ServerNewConnection()));
	//connect(m_pTcpServer, &QTcpServer::newConnection, this, &QTcpServerHelp::ServerNewConnection);
	if (!m_pTcpServer->listen(QHostAddress::Any, m_nPort))
	{
		cout << "Monitoring failed!" << endl;
		return;
	}
	else
	{
		cout << "Monitoring succeeded!" << endl;
	}

	m_pTcpServer->waitForNewConnection(1000000);

}

void QTcpServerHelp::ServerNewConnection()
{
	//获取客户端连接
	m_pTcpSocket = m_pTcpServer->nextPendingConnection();
	if (!m_pTcpSocket)
	{
		cout << "Failed to accept client connection!" << endl;
		return;
	}
	else
	{
		cout << "Accept client connection successfully" << endl;

		QString ip = m_pTcpSocket->peerAddress().toString();
		qint16 port = m_pTcpSocket->peerPort();

		cout << "IP: " << ip.toStdString() << " ... Port: " << (uint16_t)port << endl;

		connect(m_pTcpSocket, SIGNAL(readyRead()), this, SLOT(ServerReadData()));
		connect(m_pTcpSocket, SIGNAL(disconnected()), this, SLOT(ServerDisconnect()));

		m_pTcpSocket->waitForDisconnected(100000);
		//for (int n = 0; n < 30; n++)
		//{
		//	sleep(1);
		//	qDebug() << "sleep" << n;
		//}
	}
}

void QTcpServerHelp::ServerReadData()
{
	char buffer[1024] = { 0 };
	m_pTcpSocket->read(buffer, 1024);
	//QByteArray array = m_pTcpSocket->readAll();

	if (strlen(buffer) > 0)
	{
		QString recvMsg = buffer;
		cout << "server recv ..." << recvMsg.toStdString() << endl;

		ServerWriteData();
	}
	else
	{
		cout << "Failed to receive data" << endl;
		return;
	}	
}

void QTcpServerHelp::ServerWriteData()
{
	char sendMsgChar[1024] = { 0 };
	QString strWriteMsg = QString("World ... %1").arg(m_nCount++);
	if (strWriteMsg.isEmpty())
	{
		cout << "Data is empty, please enter" << endl;
		return;
	}
	strcpy_s(sendMsgChar, strWriteMsg.toStdString().c_str());
	if (m_pTcpSocket->isValid())
	{
		int nWriteRet = m_pTcpSocket->write(sendMsgChar, strlen(sendMsgChar));
		//int nWriteRet = m_pTcpSocket->write(strWriteMsg.toUtf8().data());

		if (-1 == nWriteRet)
		{
			cout << "Failed to send data!";
		}
		else
		{
			cout << "server send ..." << sendMsgChar << endl;
		}
	}
	else
	{
		cout << "socket is invalid!" << endl;
	}

}

void QTcpServerHelp::ServerDisconnect()
{
	cout << "Disconnected from client" << endl;

	if (NULL == m_pTcpSocket)
	{
		return;
	}

	//主动和客户端断开连接
	m_pTcpSocket->disconnectFromHost();
	m_pTcpSocket->close();
	m_pTcpSocket = NULL;
}

// main.cpp

#include <QtCore/QCoreApplication>
#include "QTcpServerHelp.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
	
	QTcpServerHelp* tcpServer = new QTcpServerHelp(NULL);
	tcpServer->ServerListen();


	delete tcpServer;
	tcpServer = nullptr;

    return a.exec();
}

客户端代码

// QTcpClientHelp.h

#pragma once

#include <QObject>
#include <QString>
#include <QTcpSocket>
#include <iostream>

class QTcpClientHelp  : public QObject
{
	Q_OBJECT

public:
	QTcpClientHelp(QObject *parent);
	~QTcpClientHelp();

	bool ConnectServer();
	void DisconnectServer();

public slots:
	void ClientReadData();
	void ClientWriteData();

private:
	QTcpSocket* m_pClientSocket;

	QString m_IP;
	int m_nPort;

	static int m_nIndex;
};

// QTcpClientHelp.cpp

#include "QTcpClientHelp.h"
#include <QHostAddress>

using namespace std;

int QTcpClientHelp::m_nIndex = 0;

QTcpClientHelp::QTcpClientHelp(QObject *parent)
	: QObject(parent)
{
	m_IP = "127.0.0.1";
	m_nPort = 8001;

	m_pClientSocket = new QTcpSocket();
}

QTcpClientHelp::~QTcpClientHelp()
{
	if (NULL != m_pClientSocket)
	{
		cout << "QTcpClientHelp destruct!" << endl;

		delete m_pClientSocket;
		m_pClientSocket = NULL;
	}
}

bool QTcpClientHelp::ConnectServer()
{
	m_pClientSocket->connectToHost(QHostAddress(m_IP), m_nPort);
	
	if (!m_pClientSocket->waitForConnected(30000))
	{
		cout << "Failed to connect to server!" << endl;
		return false;
	}

	connect(m_pClientSocket, SIGNAL(readyRead()), this, SLOT(ClientReadData()));
	
	return true;
}

void QTcpClientHelp::DisconnectServer()
{
	m_pClientSocket->waitForDisconnected(1000);

	//主动和对方断开连接
	m_pClientSocket->disconnectFromHost();
	m_pClientSocket->close(); // connect的时建立连接, 这里释放连接
	//m_pClientSocket = null;
}

void QTcpClientHelp::ClientReadData()
{
	char recvMsg[1024] = { 0 };

	int nRecv = m_pClientSocket->read(recvMsg, 1024);
	//QByteArray array = m_pClientSocket->readAll();

	if (nRecv == -1)
	{
		cout << "Failed to receive data!" << endl;
		return;
	}

	QString strRecv = recvMsg;
	cout << "recv ..."<<strRecv.toStdString() << endl;	
}

void QTcpClientHelp::ClientWriteData()
{
	QString strMsg = QString("Hello ... %1").arg(m_nIndex++);
	char bufferMsg[1024] = { 0 };

	strcpy_s(bufferMsg, strMsg.toStdString().c_str());
	int nSendRet = m_pClientSocket->write(bufferMsg, strlen(bufferMsg));
	//int nSendRet = m_pClientSocket->write(strMsg.toUtf8().data());
	m_pClientSocket->waitForBytesWritten();  // 不添加，服务端只触发一次 newConnection
	if (-1 != nSendRet)
	{
		cout << "Send data: " << strMsg.toStdString() << endl;
		return;
	}	
}

// main.cpp

#include <QtCore/QCoreApplication>
#include "QTcpClientHelp.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

	QTcpClientHelp* tcpClient = new QTcpClientHelp(NULL);
	tcpClient->ConnectServer();

	for (int n = 0; n < 10; n++)
	{
		tcpClient->ClientWriteData();
		//std::this_thread::sleep_for(std::chrono::milliseconds(5000));
		_sleep(500);
	}

	tcpClient->DisconnectServer();

	delete tcpClient;

    return a.exec();
}