跨平台服务器 客户端

最新推荐文章于 2023-07-27 16:27:10 发布
最新推荐文章于 2023-07-27 16:27:10 发布
阅读量245 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43460601/article/details/105327981
版权

效果图
在这里插入图片描述

数据包头文件

#ifndef _MessageHeader_hpp_
#define _MessageHeader_hpp_

enum CMD
{
	CMD_LOGIN,
	CMD_LOGIN_RESULT,
	CMD_LOGOUT,
	CMD_LOGOUT_RESULT,
	CMD_ERROR,
	CMD_NEWUSR_JOIN
};

struct DataHeader
{
	DataHeader()
	{
		cmd = CMD_ERROR;
		dataLength = sizeof(DataHeader);
	}
	short cmd;
	short dataLength;
};

struct Login :public DataHeader
{
	Login()
	{
		cmd = CMD_LOGIN;
		dataLength = sizeof(Login);
	}
	char usrName[32];
	char passWd[32];
	char data[932];
};

struct LoginResult :public DataHeader
{
	LoginResult()
	{
		cmd = CMD_LOGIN_RESULT;
		dataLength = sizeof(LoginResult);
	}
	int result;
	char data[992];
};

struct  Logout :public DataHeader
{
	Logout()
	{
		cmd = CMD_LOGOUT;
		dataLength = sizeof(Logout);
	}
	char usrName[32];
};

struct  LogoutResult :public DataHeader
{
	LogoutResult()
	{
		cmd = CMD_LOGOUT_RESULT;
		dataLength = sizeof(LogoutResult);
	}
	int result;
};

struct  NewUsrJoin :public DataHeader
{
	NewUsrJoin()
	{
		cmd = CMD_NEWUSR_JOIN;
		dataLength = sizeof(NewUsrJoin);
	}
	int sockid;
};

#endif

客户端

#ifndef _EasyTcpClient_hpp_
#define _EasyTcpClient_hpp_

#ifdef  _WIN32
	#define WIN_32_LEAN_AND_MEAN
	#define FD_SETSIZE 10240

	#include <WinSock2.h>
	#include <windows.h>
	#pragma comment(lib,"ws2_32.lib")

#else 
	#include <unistd.h>
	#include <arpa/inet.h>
	#include <string.h>

	#define SOCKET int
	#define INVALID_SOCKET  (SOCKET)(~0)
	#define SOCKET_ERROR            (-1)
#endif

#include <stdio.h>
#include "MessageHeader.hpp"

#ifndef RECV_BUFF_SIZE
#define RECV_BUF_SIZE 10240
#endif // !RECV_BUFF_SIZE

class EasyTcpClient
{
	SOCKET _sock;
	//接收缓冲区
	char _szRecv[RECV_BUF_SIZE] = {};
	//第二缓冲区 ， 消息缓冲区
	char _szMsgBuf[RECV_BUF_SIZE * 5] = {};
	//最后的位置
	int _lastPos = 0;
	bool _isConnect;
public:
	EasyTcpClient()
	{
		_sock = INVALID_SOCKET;
		_isConnect = false;
	}

	virtual ~EasyTcpClient()
	{
		Close();
	}

	//初始化socket
	void InitSocket()
	{
		//启动环境
#ifdef _WIN32
		WORD ver = MAKEWORD(2, 2);
		WSADATA dat;
		WSAStartup(ver, &dat);
#endif 		
		if (_sock != INVALID_SOCKET)
		{
			printf("<socket = %d>关闭旧连接...\n",_sock);
			Close();
		}

		_sock = socket(AF_INET, SOCK_STREAM,IPPROTO_TCP);
		if (_sock == INVALID_SOCKET)
		{
			printf("建立socket失败...\n");
		}
		/*else
		{
			printf("建立socket成功...\n");
		}*/
	}

	//连接服务器
	int Connect(const char *ip,unsigned short port)
	{
		if (_sock == INVALID_SOCKET)
		{
			InitSocket();
		}

		struct sockaddr_in _sin = {};

		_sin.sin_family = AF_INET;
		_sin.sin_port = htons(port);
#ifdef _WIN32
		_sin.sin_addr.S_un.S_addr = inet_addr(ip);
#else 
		_sin.sin_addr.s_addr = inet_addr(ip);
#endif 
		int ret = connect(_sock, (sockaddr *)&_sin, sizeof(_sin));
		if (SOCKET_ERROR == ret)
		{
			printf("连接服务器失败...\n");
		}
		else
		{
			_isConnect = true;
			//printf("连接服务器成功...\n");
		}
		return ret;
	}

	//关闭socket
	void Close()
	{
		if (_sock != INVALID_SOCKET)
		{
#ifdef _WIN32
			closesocket(_sock);
			WSACleanup();
#else
			close(_sock);
#endif 
			_sock = INVALID_SOCKET;
		}
		_isConnect = false;
	}

	//查询网络消息
	bool OnRun()
	{
		if (isRun())
		{
			fd_set fdReads;
			FD_ZERO(&fdReads);
			FD_SET(_sock, &fdReads);

			timeval t = { 1,0 };
			int ret = select(_sock + 1, &fdReads, NULL, NULL, &t);


			if (ret < 0)
			{
				printf("<socket = %d>select任务结束\n", _sock);
				Close();
				return false;
			}

			if (FD_ISSET(_sock, &fdReads))
			{
				FD_CLR(_sock, &fdReads);

				if (-1 == RecvData(_sock))
				{
					printf("select任务失败\n");
					Close();
					return false;
				}
			}
			return true;
		}
		return false;
	}

	//是否工作中
	bool isRun()
	{
		return _sock != INVALID_SOCKET && _isConnect;
	}

	//收数据 粘包 拆包
	int RecvData(SOCKET cliesock)
	{
		
		int nlen = (int)recv(cliesock, _szRecv, RECV_BUF_SIZE, 0);
		if (nlen <= 0)
		{
			printf("服务器断开连接...\n");
			return -1;
		}
		//将收取到的数据拷贝到消息缓冲区
		memcpy(_szMsgBuf + _lastPos, _szRecv, nlen);
		//消息缓冲区的数据尾部位置后移
		_lastPos += nlen;
		//判断消息缓冲区的数据长度是否大于消息头长度
		while (_lastPos >= sizeof(DataHeader))
		{
			//这时就可以知道当前消息的长度
			DataHeader *header = (DataHeader*)_szMsgBuf;
			//判断长度大于消息长度
			if (_lastPos >= header->dataLength)
			{
				//剩余未处理消息缓冲区的长度
				int nSize = _lastPos - header->dataLength;
				OnNetMsg(header);
				//将消息缓冲区剩余未处理数据前移
				memcpy(_szMsgBuf, _szMsgBuf + header->dataLength, nSize);
				//消息缓冲区的数据尾部位置前移
				_lastPos = nSize;
			}
			else {
				//消息缓冲区剩余数据不够一条完整消息
				break;
			}
		}
		
		return 0;
	}

	//响应
	void OnNetMsg(DataHeader *header)
	{
		switch (header->cmd)
		{
		case CMD_LOGIN_RESULT:
		{
			LoginResult *n = (LoginResult *)header;
			//printf("收到服务端消息:CMD_LOGIN_RESULT,数据长度:%d\n",n->dataLength);
		}
		break;
		case CMD_LOGOUT_RESULT:
		{
			LogoutResult *n = (LogoutResult *)header;
			//printf("收到服务端消息:CMD_LOGOUT_RESULT,数据长度:%d\n", n->dataLength);

		}
		break;
		case CMD_NEWUSR_JOIN:
		{
			NewUsrJoin *n = (NewUsrJoin *)header;
			//printf("收到服务端消息:新用户加入,数据长度:%d\n", n->dataLength);
		}
		break;
		case CMD_ERROR:
		{
			//printf("收到服务端消息:CMD_ERROR");
		}
		break;
		default:
			printf("收到未定义消息\n");
		break;
		}
	}

	//发送消息
	int SendData(DataHeader *header,int nlen)
	{
		int ret = SOCKET_ERROR;
		if (isRun() && header)
		{
			ret = send(_sock, (const char*)header, nlen, 0);
			if (ret == SOCKET_ERROR)
			{
				Close();
			}
		}
		return ret;
	}
private:

};


#endif

#include "EasyTcpClient.hpp"
#include <thread>

bool g_bRun = true;

void cmdThread()
{
	while (true)
	{
		char cmdBuf[128] = {};
		scanf("%s", cmdBuf);
		if (!strcmp(cmdBuf, "exit"))
		{
			g_bRun = false;
			printf("退出cmdThread线程...\n");
			break;
		}
	}
}

//客户端连接数量
const int cCount = 1000;
//发送线程数量
const int tCount = 4;
//客户端数组
EasyTcpClient* client[cCount];

void sendThread(int id)
{
	printf("thread<%d> start\n", id);
	int c = cCount / tCount;
	int begin = (id - 1) * c;
	int end = id * c;

	for (int i = begin; i < end; i++)
	{
		client[i] = new EasyTcpClient();
	}
	for (int i = begin; i < end; i++)
	{
		client[i]->InitSocket();
		client[i]->Connect("127.0.0.1", 4567);
	}

	printf("thread <%d>,connect <begin = %d> <end = %d>\n", id, begin,end);
	Login login[10];
	for (int i = 0; i < 10; i++) 
	{
		strcpy(login[i].usrName, "lyn");
		strcpy(login[i].passWd, "154029");
	}
	const int nlen = sizeof(login);
	while (g_bRun)
	{
		for (int i = begin; i < end; i++)
		{
			client[i]->SendData(login,nlen);
			client[i]->OnRun();
		}
	}

	for (int i = begin; i < end; i++)
	{
		client[i]->Close();
		delete client[i];
	}

	printf("thread<%d> exit\n", id);
}

int main()
{
	std::thread t1(cmdThread);
	t1.detach();

	//启动发送线程
	for (int i = 0; i < tCount; i++)
	{
		std::thread t2(sendThread,i + 1);
		t2.detach();
	}

	while (g_bRun)
		Sleep(100);

	printf("已退出");
	return 0;
}

服务器

#ifndef  _CELLTimestamp_hpp_
#define _CELLTimestamp_hpp_

#include <chrono>

using namespace std::chrono;

class CELLTimestamp
{
public:
	CELLTimestamp()
	{
		update();
	}
	~CELLTimestamp()
	{
	
	}
	void update()
	{
		_begin = high_resolution_clock::now();
	}
	double getElapsedSecond()
	{
		return getElapsedTimeInMicroSec() * 0.000001;
	}
	double getElapsedTimeInMilliSec()
	{
		return getElapsedTimeInMicroSec() * 0.001;
	}
	long long getElapsedTimeInMicroSec()
	{
		return duration_cast<microseconds>(high_resolution_clock::now() - _begin).count();
	}//微秒
protected:
	time_point<high_resolution_clock> _begin;
};

#endif 


#ifndef  _EasyTcpServer_hpp_
#define _EasyTcpServer_hpp_

#ifdef  _WIN32
#define WIN_32_LEAN_AND_MEAN
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#define FD_SETSIZE 10240

#include <WinSock2.h>
#include <windows.h>
#pragma comment(lib,"ws2_32.lib")

#else 
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>

#define SOCKET int
#define INVALID_SOCKET  (SOCKET)(~0)
#define SOCKET_ERROR            (-1)
#endif

#include <stdio.h>
#include <vector>
#include <thread>
#include <mutex>
#include <atomic>
#include "MessageHeader.hpp"
#include "CELLTimestamp.hpp"

#ifndef RECV_BUFF_SIZE
#define RECV_BUF_SIZE 10240
#endif // !RECV_BUFF_SIZE

#define _CellServer_THREAD_COUNT 4

//客户端类型
class ClientSocket
{
public:
	ClientSocket(SOCKET sockfd = INVALID_SOCKET)
	{
		_sockfd = sockfd;
		memset(_szMsgBuf, 0, sizeof(_szMsgBuf));
		_lastPos = 0;
	}
	SOCKET sockfd()
	{
		return _sockfd;
	}
	char *msgBuf()
	{
		return _szMsgBuf;
	}
	int getLast()
	{
		return _lastPos;
	}
	void setLastPos(int pos)
	{
		_lastPos = pos;
	}
	int SendData(DataHeader *header)
	{
		if (header)
		{
			return send(_sockfd, (const char*)header, header->dataLength, 0);
		}
		return SOCKET_ERROR;
	}
private:
	SOCKET _sockfd;
	//消息缓冲区
	char _szMsgBuf[RECV_BUF_SIZE * 5] = {};
	//最后的位置
	int _lastPos;
};

//网络事件接口
class INetEvent
{
public:
	virtual void OnLeave(ClientSocket* pClient) = 0;
	virtual void OnJoin(ClientSocket* pClient) = 0;
	virtual void OnNetMsg(ClientSocket* pClient, DataHeader *header) = 0;
private:
};

class  CellServer
{
public:
	CellServer(SOCKET sock = INVALID_SOCKET)
	{
		_sock = sock;
		_pEvent = nullptr;
	}

	~CellServer()
	{
		Close();
		_sock = INVALID_SOCKET;
	}

	void setEventObj(INetEvent* event)
	{
		_pEvent = event;
	}

	bool isRun()
	{
		return _sock != INVALID_SOCKET;
	}

	void Close()
	{
		if (_sock != INVALID_SOCKET)
		{
#ifdef _WIN32
			for (int n = (int)_clients.size() - 1; n >= 0; n--)
			{
				closesocket(_clients[n]->sockfd());
				delete _clients[n];
			}
			closesocket(_sock);
#else	
			for (int n = g_clients.size() - 1; n >= 0; n--)
			{
				close(g_clients[n]->sockfd());
				delete _clients[n];
			}
			close(_sock);
#endif // _WIN32
			_clients.clear();
		}
	}

	bool OnRun()
	{
		while (isRun())
		{
			if (_clientsBuf.size() > 0)
			{
				std::lock_guard<std::mutex> lock(_mutex);
				for (auto pClient : _clientsBuf)
				{
					_clients.push_back(pClient);
				}
				_clientsBuf.clear();
			}

			if (_clients.empty())
			{
				std::chrono::microseconds t(1);
				std::this_thread::sleep_for(t);
				continue;
			}

			fd_set fdRead;
			//fd_set fdWrite;
			//fd_set fdExp;

			FD_ZERO(&fdRead);
			//FD_ZERO(&fdWrite);
			//FD_ZERO(&fdExp);

			SOCKET maxSock = _clients[0]->sockfd();

			for (int n = (int)_clients.size() - 1; n >= 0; n--)
			{
				FD_SET(_clients[n]->sockfd(), &fdRead);
				if (maxSock < _clients[n]->sockfd())
				{
					maxSock = _clients[n]->sockfd();
				}
			}

			int ret = select(maxSock + 1, &fdRead, nullptr, nullptr, nullptr);
			if (ret < 0)
			{
				printf("select任务结束\n");
				Close();
				return false;
			}

			for (int n = (int)_clients.size() - 1; n >= 0; n--)
			{
				if (FD_ISSET(_clients[n]->sockfd(), &fdRead))
				{
					if (-1 == RecvData(_clients[n]))
					{
						auto it = _clients.begin() + n;
						if (it != _clients.end())
						{
							if(_pEvent)
								_pEvent->OnLeave(_clients[n]);
							delete _clients[n];
							_clients.erase(it);
						}
					}
				}
			}
		}
	}

	//接收数据
	int RecvData(ClientSocket* pClient)
	{

		int nlen = recv(pClient->sockfd(), (char *)&_szRecv, RECV_BUF_SIZE, 0);
		if (nlen <= 0)
		{
			//printf("客户端已退出\n");
			return -1;
		}
		memcpy(pClient->msgBuf() + pClient->getLast(), _szRecv, nlen);
		pClient->setLastPos(pClient->getLast() + nlen);
		//判断消息缓冲区的数据长度是否大于消息头长度
		while (pClient->getLast() >= sizeof(DataHeader))
		{
			//这时就可以知道当前消息的长度
			DataHeader *header = (DataHeader*)(pClient->msgBuf());
			//判断长度大于消息长度
			if (pClient->getLast() >= header->dataLength)
			{
				//剩余未处理消息缓冲区的长度
				int nSize = pClient->getLast() - header->dataLength;
				OnNetMsg(pClient, header);
				//将消息缓冲区剩余未处理数据前移
				memcpy(pClient->msgBuf(), pClient->msgBuf() + header->dataLength, nSize);
				//消息缓冲区的数据尾部位置前移
				pClient->setLastPos(nSize);
			}
			else {
				//消息缓冲区剩余数据不够一条完整消息
				break;
			}
		}
		return 0;
	}

	//发送给指定socket数据
	int SendData(SOCKET _cSock, DataHeader *header)
	{
		if (isRun() && header)
		{
			return send(_sock, (const char*)header, header->dataLength, 0);
		}
		return SOCKET_ERROR;
	}

	virtual void OnNetMsg(ClientSocket* pClient, DataHeader *header)
	{

		_pEvent->OnNetMsg(pClient,header);
		switch (header->cmd)
		{
		case CMD_LOGIN:
		{
			Login *login = (Login*)header;
			//printf("收到命令:CMD_LOGIN,数据长度:%d,usr:%s,passWord:%s\n", login->dataLength, login->usrName, login->passWd);
			LoginResult lret;
			lret.result = 1;
			pClient->SendData(&lret);
		}
		break;
		case CMD_LOGOUT:
		{
			Logout* logout = (Logout*)header;
			//printf("收到命令:CMD_LOGOUT,数据长度:%d,usr:%s\n", logout->dataLength, logout->usrName);
			//LogoutResult lret;
			//lret.result = 1;
			//send(_cSock, (char *)&lret, sizeof(LogoutResult), 0);
		}
		break;
		}
	}

	void addClient(ClientSocket* pClient)
	{
		std::lock_guard<std::mutex> lock(_mutex);
		_clientsBuf.push_back(pClient);
	}

	void Start()
	{	
		_thread = std::thread(std::mem_fn(&CellServer::OnRun), this);
	}

	size_t getClientCount()
	{
		return _clients.size() + _clientsBuf.size();
	}

private:
	SOCKET _sock;
	std::vector<ClientSocket*> _clients;//正式客户队列
	std::vector<ClientSocket*> _clientsBuf;//缓冲队列
	char _szRecv[RECV_BUF_SIZE];
	std::mutex _mutex;
	std::thread _thread;
	INetEvent* _pEvent;
};

class EasyTcpServer : public INetEvent
{
private:
	SOCKET _sock;
	std::vector<CellServer*> _cellServers;
	CELLTimestamp _tTime;
	std::atomic_int _recvCount;
	std::atomic_int _clientCount;
public:
	EasyTcpServer()
	{
		_sock = INVALID_SOCKET;
		_recvCount = 0;
		_clientCount = 0;
	}

	virtual ~EasyTcpServer()
	{
		Close();
	}

	//初始化socket
	void InitSocket()
	{
		//启动环境
#ifdef _WIN32
		WORD ver = MAKEWORD(2, 2);
		WSADATA dat;
		WSAStartup(ver, &dat);
#endif 		
		if (_sock != INVALID_SOCKET)
		{
			printf("<socket = %d>关闭旧连接...\n", _sock);
			Close();
		}

		_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
		if (_sock == INVALID_SOCKET)
		{
			printf("建立socket失败...\n");
		}
		else
		{
			printf("建立socket成功...\n");
		}
	}

	//绑定ip和端口号
	int Bind(const char *ip,unsigned short port)
	{
		sockaddr_in _sin = {};
		_sin.sin_family = AF_INET;
		_sin.sin_port = htons(port);

#ifdef _WIN32
		if (ip) {
			_sin.sin_addr.S_un.S_addr = inet_addr(ip);
		}
		else {
			_sin.sin_addr.S_un.S_addr = INADDR_ANY;
		}
		printf("绑定的ip为:%s\n",inet_ntoa((in_addr)_sin.sin_addr));
#else 
		if (ip) {
			_sin.sin_addr.s_addr = inet_addr(ip);
		}
		else {
			_sin.sin_addr.s_addr = INADDR_ANY;
		}
#endif 
		
		int ret = bind(_sock, (sockaddr *)&_sin, sizeof(_sin));
		if (SOCKET_ERROR == ret)
		{
			printf("绑定端口失败...\n");
		}
		else {
			printf("绑定端口成功...\n");
		}
		return ret;
	}

	//监听端口号
	int Listen(int n)
	{
		int ret = listen(_sock, n);
		if (SOCKET_ERROR == ret)
		{
			printf("错误，监听失败..\n");
		}
		else
		{
			printf("监听成功..\n");
		}
		return ret;
	}

	//接收客户端连接
	void Accept()
	{
		sockaddr_in _clie = {};
		int clie_len = sizeof(_clie);

		SOCKET cSock = INVALID_SOCKET;

#ifdef _WIN32
		cSock = accept(_sock, (sockaddr*)&_clie, &clie_len);
#else
		cSock = accept(_sock, (sockaddr*)&_clie, (socklen_t *)&clie_len);
#endif // _WIN32

		
		if (INVALID_SOCKET == cSock)
		{
			printf("接收到无效的客户端socket");
		}
		else 
		{
			addClient2Cellserver(new ClientSocket(cSock));
		}
	}

	//查找客户数量最少的消息处理对象
	void addClient2Cellserver(ClientSocket *pClient)
	{
		auto pMinServer = _cellServers[0];
		for (auto pCellServer : _cellServers)
		{
			if (pMinServer->getClientCount() > pCellServer->getClientCount())
			{
				pMinServer = pCellServer;
			}
		}
		pMinServer->addClient(pClient);
		OnJoin(pClient);
	}

	void Start()
	{
		for (int i = 0; i < _CellServer_THREAD_COUNT; i++)
		{
			auto ser = new CellServer(_sock);
			_cellServers.push_back(ser);
			ser->setEventObj(this);
			ser->Start();
		}
	}

	//关闭socket
	void Close()
	{
		if (_sock != INVALID_SOCKET)
		{
#ifdef _WIN32
			closesocket(_sock);
			WSACleanup();
#else	
			for (int n = g_clients.size() - 1; n >= 0; n--)
			{
				close(g_clients[n]->sockfd());
				delete _clients[n];
			}
			close(_sock);
#endif // _WIN32
		}
	}

	//处理网络信息
	bool OnRun()
	{
		if (isRun())
		{
			time4Msg();
			fd_set fdRead;
			FD_ZERO(&fdRead);
			FD_SET(_sock, &fdRead);
	
			timeval t = { 0,10 };
			int ret = select(_sock + 1, &fdRead, NULL, NULL, &t);

			if (ret < 0)
			{
				printf("select任务结束\n");
				Close();
				return false;
			}

			if (FD_ISSET(_sock, &fdRead))
			{
				FD_CLR(_sock, &fdRead);
				Accept();
				return true;
			}

			return true;
		}
		return false;
	}

	//是否运行中
	bool isRun()
	{
		return _sock != INVALID_SOCKET;
	}

	//j计算网络消息
	void time4Msg()
	{
		auto t1 = _tTime.getElapsedSecond();
		if (t1 >= 1.0)
		{
			printf("time<%lf>,clients<%d>,recvCount<%d>\n", t1,_clientCount, (int)(_recvCount/t1));
			_recvCount = 0;
			_tTime.update();
		}
	}

	virtual void OnJoin(ClientSocket* pClient)
	{
		_clientCount++;
	}

	virtual void OnLeave(ClientSocket* pClient)
	{
		_clientCount--;
	}

	virtual void OnNetMsg(ClientSocket* pClient, DataHeader *header)
	{
		_recvCount++;
	}
};

#endif

#include "EasyTcpServer.hpp"
#include <thread>

bool g_bRun = true;

void cmdThread()
{
	while (true)
	{
		char cmdBuf[128] = {};
		scanf("%s", cmdBuf);
		if (!strcmp(cmdBuf, "exit"))
		{
			g_bRun = false;
			printf("退出cmdThread线程...\n");
			break;
		}
	}
}

int main()
{
	EasyTcpServer server;
	server.InitSocket();
	server.Bind(NULL,4567);
	server.Listen(128);
	server.Start();
	std::thread t1(cmdThread);
	t1.detach();

	while (g_bRun)
	{
		server.OnRun();
	}

	server.Close();
	printf("退出\n");
	getchar();
	return 0;
}
LzyAir
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
跨平台tcp socket 客户端服务端（C++源码）
11-22
跨平台C++ tcp socket 客户端服务端源码 适用于linux window mac系统
跨平台客户端
zhanglianzhu_91的博客
10-09 638
DotNetCore加electron实现跨平台桌面
最小，独立，可分发的跨平台Web服务器
09-26 229
最近，我一直在编写大量较小的wsgi应用程序，并希望找到一个可以分布式，预先配置为运行特定应用程序的Web服务器。我知道有些东西可以用于wsgi应用程序，例如twisted和cherrypy，但它们似乎缺少我的一项关键功能，即使用http range标头“伪流”大文件的功能。是否有根据BSD或类似许可证提供的Web服务器，可以作为独立可执行文件分发到任何主要平台上，该平台既可以代理as ...
服务器端 跨平台
chifengtuan3409的博客
06-24 110
https://stackoverflow.com/questions/41437503/postgresql-9-5-or-9-6-for-s390x https://www.theurbanpenguin.com/using-cloud-images-in-kvm/ ##cloud...
从零开始写一个简单好用的游戏服务器引擎[2] - 跨平台相关
服务器开发的日子
10-09 1787
因为项目需要,所以必须做成跨平台的.一方面是历史原因,一方面是有时确实会碰上只有Windows Server或者只有Linux服务器的情况.不过对于服务端来讲,跨平台还是不算太复杂,主要就是以下几个方面:1.宏定义和类型别名 尽量都向Windows的命名靠拢了. 所以用的时候也以Windows的为标准.#if defined(_WIN32) || defined(_WIN64) #define
bfcp:跨平台 BFCP 服务器和客户端
06-04
**BFCP：跨平台BFCP服务器和客户端详解** BFCP（Broadcast File Control Protocol）是一种文件广播控制协议，主要用于在局域网内高效地进行大文件的广播传输。本项目基于muduuo-x、libre和tinyxml2库，提供了一个跨...
wombat：跨平台gRPC客户端
02-03
跨平台gRPC客户端 产品特点 自动解析原型定义以呈现服务和输入消息 .proto文件发现 选择多种服务和方法 TLS的配置，包括禁用TLS（纯文本） 所有标量类型的输入生成 嵌套消息的输入生成 枚举（包括嵌套）的输入...
baton:电子跨平台IRC客户端
05-10
通过以上信息，我们可以推断baton是一个用JavaScript编写的，利用Electron框架构建的跨平台IRC客户端，它使用户能够方便地与ngircd或其他IRC服务器进行交互。通过npm管理和运行，baton提供了一种现代且灵活的方式来...
Danmaku:弹幕服务器的跨平台客户端
06-30
《构建跨平台弹幕服务器客户端：Danmaku与Qt5技术解析》 在现代网络娱乐领域，弹幕已经成为一种独特的互动方式，它让观众能够实时分享自己的观看感受，增加了视频内容的互动性和趣味性。本篇文章将深入探讨如何利用...
【Go网络编程:Go如何通过RPC实现跨平台服务】
zhw21w的博客
12-27 413
Go如何玩转RPC服务
服务器升级 跨平台支持Win、Linux、MacOS
呵呵哒!的博客
05-04 126
【代码】服务器升级 跨平台支持Win、Linux、MacOS。
MT4MT5跟单EA系统跨平台
wanzhh180的博客
08-21 2230
全面兼容XP/WIN7/Win10系统，自动识别平台品种的后缀名称，安装设置简单，功能强大，稳定极速跟单。提供远程安装调试，优质售后服务及免费更新到最新版。软件不提供源代码，终身无任何限制版。功能说明 1.可以选择正向跟单或者反向跟单 2.可以选择是否修改止损止盈 3 .加入按钮一键平仓功能，全平更快捷 4.两种下单量模式可以选择，比例手数、固定手数 5 .风险控制功能，盈利或者亏损达到指定金额自动平仓 6 .有限制跟单品种和限制不跟单品种两个列表，方便选择跟单的品种 7.是否跟随喊单帐号平仓可以选择 ..
理解跨平台技术
最新发布
Ipkiss Studio
07-27 559
开发一个APP运行在Android手机需要一套代码，运行在ios操作系统的手机又需要一套代码，为了使同一套代码能运行在不同的操作系统上解决多端独立开发的问题，跨平台技术便应运而生。Android 应用采用 Java 或 Kotlin 编写，iOS 应用采用 Objective-C 或 Swift 编写，Web 端采用 HTML /CSS/JavaScript 编写。当需要开发支持多端的应用，每一端都需要独立研发、测试，一直到上线，以及后续的维护工作，工作量成倍增涨，势必延长研发周期。
跨平台(windows+linux)的线程辅助程序,跨平台（Windows+Linux)的线程辅助程序
weixin_33479657的博客
05-04 203
【好久没写文章了，因为在忙一个项目，这个项目需要编写跨平台(windows+Linux)代码，所以对跨平台的东西做了些关注，本文及下来几篇文章都是针对跨平台的。】如果一个项目需要跨平台，可选择的编程语言就受到一定的限制，如果再考虑运行效率，可选择的语言似乎只能是C/C++了。与Java不同，C/C++是被操作系统“原生态”支持的，因而各操作系统实现的方式也略有不同，各自做了不同的扩展，而不象Jav...
跨平台高性能TCP服务器框架 &boost
wang19840301的博客
06-26 4085
基于boost的asio封装的高性能TCP服务器
App项目实战之路(五):服务端篇
跨语言，跨平台，跨应用
10-25 5504
转载自Keegan小钢 原文链接：http://keeganlee.me/post/practice/20161006App项目实战之路(一):概述篇 App项目实战之路(二):API篇 App项目实战之路(三):原型篇 App项目实战之路(四):UI篇 App项目实战之路(五):服务端篇 App项目实战之路(六):数据库篇近一个月因为忙于其他事情，一直没能抽出时间来更新项目进度。现在，
C/C++跨平台程序注意
李青锋的专栏
06-04 3170
判断操作系统 通过使用内置的宏，可以进行
Windows PC、Linux、Android、iOS 跨平台视频云客户端 QML 开发解决方案
热门推荐
OpenSkeye的博客
04-05 1万+
Windows PC、Linux、Android、iOS 跨平台视频云客户端 QML 开发解决方案 SkeyeARS （Skeye Video Augmented Reality System） 全景 AR 增强监视系统 是一款基于宽场景多路视频无缝拼接、视频实时增强、监视目标增强显示、目标自动跟踪、视频存储回放、远程数据传输和多通道全景视频同步显示等功能的综合视频 AR 增强监视系统，广泛应用于智慧交通、智慧城市、智慧机场等大场景智能监控领域。 SkeyeARS整体架构： 为什么选择用
MT4跨平台跟单
MT5的博客
11-25 3654
最近做跨平台跟单项目 发现此类解决方案大概有两种方案： 1.管理权限的跟单，即跨平台都有管理权限，利用官方API管理权限进行后台跟单，    此种方法限制比较多，平台登陆非常少，需要官方的API,优点是稳定，不利于推广。 2.模拟客户端登陆，这种只需要账号，密码，服务器地址，即实现大量平台的模拟登陆    这种方法大概是使用了破译客户端登陆协议，进行操作，非官方接口，稳定性必然不如官方A...
基于TCP的服务器客户端程序设计.doc
06-07
"基于TCP的服务器客户端程序设计.doc" 在本次实验设计中，学生需要实现一个基于TCP协议的服务器客户端程序，旨在深入理解客户端与服务器的工作原理，并熟练掌握套接字和TCP协议的相关知识。TCP（Transmission ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值