C++实现进程端口网络数据接收系统设计示例程序

2023-12-13 04:47:25

一、问题描述

最近做了一道简单的系统设计题,大概描述如下:
1.一个进程可以绑定多个端口,用于监听接收网络中的数据,但是一个端口只能被一个进程占用
2.1 <= pid <= 65535, 1 <= port <= 100000, 1 <= topNum <= 5, 0 <= packetLen < 1000
类接口函数声明如下,要求实现其中每个函数,满足程序要求。

class NetWorkRecvSystem
{
public:
	NetWorkRecvSystem();
	
	// 将某个端口和进程绑定
	bool BindPort(int pid, int port);
	
	// 解除端口port的绑定,如果port未被当前系统中的进程占用,则返回false
	bool UnBindPort(int port);
	
	// 在端口port上接收到字节数为packetLen长度的网络数据
	// 如果当前端口已被解绑或未被进程占用,则直接返回0
	// 否则该端口对应的进程的接收数据总长度累加上当前的dataLen,返回最后的总长度
	int RecvNetData(int port, int dataLen);
	
	// 统计总接收数据长度排名前topNum的进程列表
	// 按照如下规则进行排序输出:
	// 1.先按照进程的总数据接收长度从大到小降序排序
	// 2.如果两个进程的数据接收总长度相等,则按照进程pid从小到大升序
	// 最后返回前topNum个进程的列表
	// 注意:数据长度为0的进程不输出,如果所有进程都没有接收到数据,则返回空列表{}
	std::vector<int> statTopNum(int topNum);
};

举例1:
输入:
NetWorkRecvSystem sys; // 创建一个系统变量
sys.BindPort(12345, 80);
sys.BindPort(67890, 3306);
sys.BindPort(12345, 8080);
sys.statTopNum(2); // 由于当前进程只做端口绑定,还未接收到数据,所以返回空列表 []
sys.RecvNetData(80, 100); // 端口80上接收到100字节的网络数据,此时进程12345的总数据接收长度为100
sys.RecvNetData(3306, 300); // 端口3306上接收到300字节的网络数据,此时进程67890的总数据接收长度为300
sys.statTopNum(1); // 由于此时进程67890的总长度为300,大于进程12345的总数据接收长度100,所以返回[67890]
sys.RecvNetData(80,200); // 123456 -> 300, 67890 -> 300
sys.BindPort(34567, 3306); // false
sys.BindPort(34567, 21);
sys.RecvNetData(21,400); // 34567 -> 400,此时123456 -> 300, 67890 -> 300
sys.statTopNum(5); // [34567, 123456, 67890]
sys.UnBindPort(21);
sys.statTopNum(1); // [34567]

系统设计

做系统设计这类题目,首选要读懂题意,其次再选择合适的数据结构用于保存数据,我首先想到用一个std::map<int, ProcessItem>的接口来保存每个进程的网络端口和数据包接收信息,其中ProcessItem结构如下:

struct ProcessItem
{
	int processId = -1;		// 进程的pid,唯一标识
	std::set<int> ports;	// 进程所占用的端口集合,一个进程可占用多个不同的端口
	int packetLen = 0;		// 进程所有端口接收到的总报文字节数
};

后面实际写代码过层中发现std::map是个红黑树结构,不太好排序,而且会有些数据冗余;只用std::vector<ProcessItem> procItemVec;数组就能满足要求,而且结合C++ STL algorithmstd::vector排序很方便。

还有一个要注意的点,对std::vector循环遍历时,如果要erase删除某个元素,要注意迭代器失效的问题,这个可以参考我之前的一篇博客:C++ vector迭代器失效

C++代码实现:

NetWorkSystem.h头文件

#include <vector>
#include <set>

using std::vector;
using std::set;


struct ProcessItem
{
	int processId = -1;		// 进程的pid,唯一标识
	std::set<int> ports;	// 进程所占用的端口集合,一个进程可占用多个不同的端口
	int packetLen = 0;		// 进程所有端口接收到的总报文字节数
};

class NetWorkSystem
{
public:
	NetWorkSystem();
	~NetWorkSystem();

	// 将某个端口和进程绑定
	bool BindPort(int pid, int port);

	// 解除端口port的绑定,如果port未被当前系统中的进程占用,则返回false
	bool UnBindPort(int port);

	// 在端口port上接收到字节数为packetLen长度的网络数据
	// 如果当前端口已被解绑或未被进程占用,则直接返回0
	// 否则该端口对应的进程的接收数据总长度累加上当前的dataLen,返回最后的总长度
	int RecvNetPacketData(int port, int packetLen);

	// 统计总接收数据长度排名前topNum的进程列表
	// 按照如下规则进行排序输出:
	// 1.先按照进程的总数据接收长度从大到小降序排序
	// 2.如果两个进程的数据接收总长度相等,则按照进程pid从小到大升序
	// 最后返回前topNum个进程的列表
	// 注意:数据长度为0的进程不输出,如果所有进程都没有接收到数据,则返回空列表{}
	std::vector<int> statTopNum(int topNum);

private:
	std::vector<ProcessItem> procItemVec;	// 数据,用来保存进程和端口映射的数组
};

NetWorkSystem.cpp实现文件:

#include "NetWorkSystem.h"
#include <algorithm>

NetWorkSystem::NetWorkSystem()
{
}

NetWorkSystem::~NetWorkSystem()
{
}

bool NetWorkSystem::BindPort(int pid, int port)
{
	if (pid <= 0 || port <= 0) {
		return false;
	}
	// 如果端口port已被其他进程占用,则不处理,直接返回false
	for (auto procIter : procItemVec) {
		if (procIter.ports.count(port) != 0) {
			return false;
		}
	}
	auto iter = std::find_if(procItemVec.begin(), procItemVec.end(), [pid](const ProcessItem item) {
		return pid == item.processId;
	});
	// 如果之前有进程,则将其插入到对应进程的ports集合中(集合可以去重)
	if (iter != procItemVec.end()) {
		iter->ports.insert(port);
	} else {
		// 之前没有该进程,则新建一项,初始化进程信息,并放入到数组中
		ProcessItem procItem;
		procItem.processId = pid;
		std::set<int> portSet = { port };
		procItem.ports = portSet;
		procItem.packetLen = 0;
		procItemVec.push_back(procItem);
	}

	return true;
}

bool NetWorkSystem::UnBindPort(int port)
{
	if (port <= 0) {
		return false;
	}
	// 如果端口port被其他进程占用,则从对应进程的端口集合中解绑,直接返回true
	for (auto procIter : procItemVec) {
		auto portIter = procIter.ports.find(port);
		// 找到对应的端口port
		if (portIter != procIter.ports.end()) {
			// 将该端口中对应进程的端口集合中移除
			procIter.ports.erase(port);
			return true;
		}
	}
	// 如果没找到该端口,则返回false
	return false;
}

int NetWorkSystem::RecvNetPacketData(int port, int packetLen)
{
	if (port <= 0 || packetLen <= 0) {
		return 0;
	}
	for (auto procIter = procItemVec.begin(); procIter != procItemVec.end(); procIter++) {
		// 找到对应的端口
		if (procIter->ports.count(port) != 0) {
			procIter->packetLen += packetLen;
			return procIter->packetLen;
		}
	}
	return 0;
}

// 统计接收网络数据包总长度前topNum的进程列表
std::vector<int> NetWorkSystem::statTopNum(int topNum)
{
	std::vector<int> pidList;
	// 1. 先缓存进程信息列表(对缓存数据进行处理,防止原始数据procItemVec被弄脏)
	auto procItemVecTemp = procItemVec;
	// 2. 移除那些网络数据包为0的进程项
	for (auto iter = procItemVecTemp.begin(); iter != procItemVecTemp.end();) {
		if (iter->packetLen == 0) {
			iter = procItemVecTemp.erase(iter);	// 注意:vector在循环时做erase操作很容易导致迭代器失效问题
		} else {
			iter++;
		}
	}
	// 3. 如果procItemVecTemp长度为0,即所有进程都没有接收到数据包,则返回空列表
	if (procItemVecTemp.size() == 0) {
		return std::vector<int>();
	}
	// 4. 对第3步处理后的进程信息数据按照规则进行排序
	// 规则1: 先根据进程的packetLen长度从大到小降序
	// 规则2: 如果两个进程项的packetLen相等,则按照进程processId从小到大升序
	std::sort(procItemVecTemp.begin(), procItemVecTemp.end(), [](const ProcessItem item1, const ProcessItem item2) {
		if (item1.packetLen == item2.packetLen) {
			return item1.processId < item2.processId;
		}
		return item1.packetLen > item2.packetLen;
	});
	// 5. 只输出procItemVecTemp中排名topNum的进程pid列表
	int processCnt = topNum;
	for (auto procIter = procItemVecTemp.begin(); procIter != procItemVecTemp.end() && processCnt > 0; procIter++) {
		pidList.push_back(procIter->processId);
		if (processCnt-- <= 0) {
			break;
		}
	}
	return pidList;
}

main.cpp

#include <iostream>
#include "NetWorkSystem.h"

void PrintVector(std::vector<int> nums)
{
	std::cout << "[";
	for (auto iter = nums.begin(); iter != nums.end(); iter++) {
		if (iter != nums.end() - 1) {
			std::cout << *iter << ","
		} else {
			std::cout << *iter;
		}
	}
	std::cout << "]" << std::endl;
}

void NetWorkSystem_test_001()
{
	std::vector<int> pidListResult = {};
	NetWorkSystem sys;	// 创建一个系统变量
	sys.BindPort(12345, 80);
	sys.BindPort(67890, 3306);
	sys.BindPort(12345, 8080);
	std::cout << "--------------- 111 start ----------------------------" << std::endl;
	pidListResult = sys.statTopNum(2);		// 由于当前进程只做端口绑定,还未接收到数据,所以返回空列表 []
	PrintVector(pidListResult);
	std::cout << "--------------- 111 end ----------------------------" << std::endl;
	sys.RecvNetPacketData(80, 100);	// 端口80上接收到100字节的网络数据,此时进程12345的总数据接收长度为100
	sys.RecvNetPacketData(3306, 300); // 端口3306上接收到300字节的网络数据,此时进程67890的总数据接收长度为300
	std::cout << "--------------- 222 start ----------------------------" << std::endl;
	pidListResult = sys.statTopNum(1);	// 由于此时进程67890的总长度为300,大于进程12345的总数据接收长度100,所以返回[67890]
	PrintVector(pidListResult);
	std::cout << "--------------- 222 end ----------------------------" << std::endl;

	sys.RecvNetPacketData(80, 200); // 123456 -> 300, 67890 -> 300
	sys.BindPort(34567, 3306); // false
	sys.BindPort(34567, 21);
	sys.RecvNetPacketData(21, 400); // 34567 -> 400,此时123456 -> 300, 67890 -> 300

	std::cout << "--------------- 333 start ----------------------------" << std::endl;
	pidListResult = sys.statTopNum(5);  // [34567, 123456, 67890]
	PrintVector(pidListResult);
	std::cout << "--------------- 333 end ----------------------------" << std::endl;

	sys.UnBindPort(21);
	std::cout << "--------------- 444 start ----------------------------" << std::endl;
	pidListResult = sys.statTopNum(1); // [34567]
	PrintVector(pidListResult);
	std::cout << "--------------- 444 end ----------------------------" << std::endl;
}

int main(int argc, char* argv[])
{
	NetWorkSystem_test_001();
}

代码运行结果如下图所示:
代码运行结果

文章来源:https://blog.csdn.net/ccf19881030/article/details/134890285
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。