[C++知识库]C++游戏编程教程（六）——C++字符串消息处理器类

大家好，我是一位初一的编程爱好者。今天，我向大家介绍一个我自制的C++字符串消息处理器类。看到标题，大家可能有些疑惑，字符串消息处理器怎么能和游戏编程扯上关系呢？其实，很多游戏中都需要用到消息处理，特别是一些人机交互的游戏。此时，如果没有一个类进行管理，是非常不方便的。其实，具体到我们以前的游戏框架中，Actor就可以看作一个消息处理器，Component相当于这里的Processor。当然，这是一个单独的项目，没有使用SDL，但它的原理和思想值得借鉴。

项目介绍

在实际开发中，我们经常会用到消息处理，即用户发来一些消息，让我们进行处理，典型的例子是QQ机器人。如果简单地用几个if，会导致程序非常混乱，可读性差。这时候，就要新建一个类对这些消息进行管理。当然，我只是实现了一个最简单的版本，还有很多功能，大家可以自行完善。其实，这个类功能和实现都很简单，但我通过这个类，开发了一个人机聊天的项目，比较有意思。
项目名称：C++字符串消息处理器类
开发环境：Visual Studio 2022
C++标准：C++11及以上

代码分析及实现

选择匹配方式

对于字符串消息，有多种处理方法，但使用最广泛的还是正则表达式。这个项目就是基于正则表达式匹配的。

基本原理

其实，消息处理器的原理很简单，就是对混乱的if语句进行封装，把每个正则和对应的处理函数存储到vector容器中，然后处理消息的时候，遍历容器进行匹配就行了。别看原理简单，它能大大改善代码质量。这里有一个比较常用的功能，那就是在传递消息的时候，同时传递一个对象到函数里，这样就可以灵活操作了。比如说，一个消息处理器收到消息后想移动位置，但没有对应的Actor，所以无法移动，如果把对象也作为一个参数传递给lambda函数，在函数体内就可以执行了。不过由于时间原因，我没有添加，大家可以根据这个功能，把这个类改成模板类实现。

CMessageProcessor类代码

CMessageProcessor.h:

#pragma once
#include<functional>
#include<regex>
#include<vector>
class CMessageProcessor
{
public:
	using ProcessorFunction = std::function<void(const std::smatch&)>;
	struct Processor
	{
		std::regex regex;
		ProcessorFunction function;
		std::string regexStr;
		bool bDeleted;
		Processor(const std::string& reg, const ProcessorFunction& func);
	};
	CMessageProcessor();
	void AddMatchProcessor(const std::string& regex, const ProcessorFunction& func);
	void RemoveMatchProcessor(const size_t& index);
	void AddSearchProcessor(const std::string& regex, const ProcessorFunction& func);
	void RemoveSearchProcessor(const size_t& index);
	size_t ProcessingMessage(const std::string& message);
	const std::vector<Processor>& GetMatchProcessorsList()const noexcept;
	const std::vector<Processor>& GetSearchProcessorsList()const noexcept;
private:
	std::vector<Processor> mMatchProcessors;
	std::vector<Processor> mSearchProcessors;
	std::vector<Processor> mPendingMatchProcessors;
	std::vector<Processor> mPendingSearchProcessors;
	bool mIsProcessingMessage;//为了防止在遍历容器处理消息的过程中添加或删除Processor
};

CMessageProcessor.cpp:

#include "CMessageProcessor.h"

CMessageProcessor::CMessageProcessor() :mIsProcessingMessage(false)
{
}

void CMessageProcessor::AddMatchProcessor(const std::string& regex, const ProcessorFunction& func)
{
	if (mIsProcessingMessage)
		mPendingMatchProcessors.push_back(Processor(regex, func));
	else
		mMatchProcessors.push_back(Processor(regex, func));
}

void CMessageProcessor::RemoveMatchProcessor(const size_t& index)
{
	if (mIsProcessingMessage)
		mMatchProcessors.at(index).bDeleted = true;
	else
		mMatchProcessors.erase(mMatchProcessors.begin() + index);
}

void CMessageProcessor::AddSearchProcessor(const std::string& regex, const ProcessorFunction& func)
{
	if (mIsProcessingMessage)
		mPendingSearchProcessors.push_back(Processor(regex, func));
	else
		mSearchProcessors.push_back(Processor(regex, func));
}

void CMessageProcessor::RemoveSearchProcessor(const size_t& index)
{
	if (mIsProcessingMessage)
		mSearchProcessors.at(index).bDeleted = true;
	else
		mSearchProcessors.erase(mMatchProcessors.begin() + index);
}

size_t CMessageProcessor::ProcessingMessage(const std::string& message)
{
	std::smatch m;
	size_t count = 0;
	mIsProcessingMessage = true;
	for (const auto& iter : mMatchProcessors)
	{
		if (std::regex_match(message, m, iter.regex))
		{
			++count;
			iter.function(m);
		}
	}
	for (const auto& iter : mSearchProcessors)
	{
		if (std::regex_search(message, m, iter.regex))
		{
			++count;
			iter.function(m);
		}
	}
	mIsProcessingMessage = false;
	while (!mPendingMatchProcessors.empty())//将等待中的MatchProcessor添加到正式容器中
	{
		mMatchProcessors.push_back(mPendingMatchProcessors.back());
		mPendingMatchProcessors.pop_back();
	}
	while (!mPendingSearchProcessors.empty())//将等待中的SearchProcessor添加到正式容器中
	{
		mSearchProcessors.push_back(mPendingSearchProcessors.back());
		mPendingSearchProcessors.pop_back();
	}
	mMatchProcessors.erase(std::remove_if(mMatchProcessors.begin(), mMatchProcessors.end(), [](const Processor& p) {
		return p.bDeleted;
		}), mMatchProcessors.end());//删除等待被删除的MatchPrecessor
	mSearchProcessors.erase(std::remove_if(mSearchProcessors.begin(), mSearchProcessors.end(), [](const Processor& p) {
		return p.bDeleted;
		}), mSearchProcessors.end());//删除等待被删除的SearchPrecessor
	return count;
}

const std::vector<CMessageProcessor::Processor>& CMessageProcessor::GetMatchProcessorsList() const noexcept
{
	return mMatchProcessors;
}

const std::vector<CMessageProcessor::Processor>& CMessageProcessor::GetSearchProcessorsList() const noexcept
{
	return mSearchProcessors;
}

CMessageProcessor::Processor::Processor(const std::string& reg, const ProcessorFunction& func) :regex(reg), regexStr(reg), function(func), bDeleted(false)
{
}

代码的原理很简单，也很好理解，这里就不做过多介绍，只提一点：因为在遍历容器的过程中不能添加或删除元素，所以要设置mIsProcessingMessage变量，如果在遍历过程中添加或删除指令，需要保存到等待队列中。下面，我们将重点介绍用这个类做一个人机对话的机器人。

机器人代码

先上代码：

#include<iostream>
#include"CMessageProcessor.h"
#include<vector>
using namespace std;
class MyClass
{
public:
	vector<string*>v;
	CMessageProcessor systemProcessor, userProcessor;
	MyClass()
	{
		systemProcessor.AddMatchProcessor("添加指令\\s*(.*)---(.*)", [=](const smatch& m) {
			string& s=*new string(m.str(2));
			v.push_back(&s);
			userProcessor.AddMatchProcessor(m.str(1), [=](const smatch& im) {
				cout << s << endl;
				});
			});
		systemProcessor.AddMatchProcessor("删除指令\\s*([0-9]+)", [=](const smatch& m) {
			const size_t size = stoul(m.str(1));
			if (size < userProcessor.GetMatchProcessorsList().size())
				userProcessor.RemoveMatchProcessor(size);
			else
				cout << "没有该指令！" << endl;
			});
		systemProcessor.AddMatchProcessor("指令列表", [=](const smatch& m) {
			const auto& vs = systemProcessor.GetMatchProcessorsList();
			std::cout << "系统指令（共" << vs.size() << "个）：" << endl;
			for (size_t i = 0; i < vs.size(); i++)
			{
				cout << i << '\t' << vs[i].regexStr << endl;
			}
			const auto& vu = userProcessor.GetMatchProcessorsList();
			std::cout << "用户自定义指令（共" << vu.size() << "个）：" << endl;
			for (size_t i = 0; i < vu.size(); i++)
			{
				cout << i << '\t' << vu[i].regexStr << endl;
			}
			});
		string str;
		while (getline(cin, str))
		{
			const size_t num = systemProcessor.ProcessingMessage(str) + userProcessor.ProcessingMessage(str);
			cout << "共有" << num << "个消息处理函数被调用！" << endl;
		}
		for (auto p : v)
			delete p;
	}
};
int main()
{
	MyClass a;
	return 0;
}

通过大致看代码，大家肯定发现，这个机器人没有任何自定义的聊天功能，只能通过几个默认指令添加自定义指令。其实，这样做有很大的好处，因为这样实现了动态的添加指令，想加一个新指令，无需重新编译。下面，我们简单介绍一下代码。
首先，在MyClass类中，我们新建了两个消息处理器，分别是systemProcessor和userProcessor，分别存储系统指令和自定义指令（为了防止用户误删系统指令，所以把它们分开）。接着，系统指令添加了几个默认元素，自定义指令没有添加任何元素。接下来，我们就可以通过用户不断输入来实现对话了。这里重点讲一下添加指令的代码：相信很多人一开始都想直接在内层的lambda中输出m.str(2)，但你们忽略了一点：内层lambda在调用的过程中，外层lambda并不会被调用，所以说，如果这样做，会输出随机值（其它的内存里的内容），甚至导致程序崩溃等严重后果！这也是lambda中捕获外部变量中一个非常容易犯的错误。解决方法是：将m.str(2)再new一份副本，程序结束后再释放，这样就不会出现内存访问错误的问题了。

运行结果