blocks|key|2312276|text|我认为最好的方法是将文件表示为正确命令类型的variant的集合。例如，假设您有三个命令选项：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2312277|struct+Constant+{
++++short+value;
};
struct+UnaryOperation+{
++++unsigned+char+opcode;
++++short+value;
};
struct+BinaryOperation+{
++++unsigned+char+opcode;
++++short+value1;
++++short+value2;
};|code-block|syntax|javascript|2312278|表示未知命令的。如果您有未知命令，则可以将其表示为以下三种类型的variant：|BOLD|2312279|using+Command+=+std::variant<Constant,+UnaryOperation,+BinaryOperation>;+|2312280|根据命令类型应用函数。假设每个命令都有不同的函数：|2312281|short+eval(Constant+c)+{
++++return+c.value;
}
short+eval(UnaryOperation+u)+{
++++switch(u.opcode)+{
++++++++//+stuff
++++}
}
short+eval(BinaryOperation+b)+{
++++switch(b.opcode)+{
++++++++//+stuff
++++}
}|2312282|我们可以使用std::visit来评估任意的Command|2312283|short+evaluate_command(Command+const&+command)+{
++++short+output;+
++++//+This+calls+the+right+overload+automatically+
++++std::visit(command,+[&](auto+cmd)+{+output+=+eval(cmd);+});+
++++return+output;+
}|2312284|解析命令。我们可以从定义的任何类型中自动创建一个std::variant。这意味着，如果您提供一种方法来确定该命令是基于该文件的，则很容易做到这一点。|2312285|enum+class+OpType+:+unsigned+char+{
++++ConstantOp,+UnaryOp,+BinaryOp
};
//+Command+can+be+automatically+constructed+from+a+Constant,+a+UnaryOperation,+or+a+BinaryOperation
Command+readFromStream(std::istream&+i)+{
++++OpType+type;
++++unsigned+char+op;
++++short+value,+value2;

++++//+Read+the+type+of+the+operation
++++i+>>+(unsigned+char&)type;

++++//Return+either+a+Constant,+a+UnaryOperation,+or+a+BinaryOperation
++++switch(type)+{
++++++++case+OpType::ConstantOp:+{
+++++++++++++i+>>+value;
+++++++++++++return+Constant{value};
++++++++}
++++++++case+OpType::UnaryOp:+{
++++++++++++i+>>+op+>>+value;
++++++++++++return+UnaryOperation{op,+value};
++++++++}
++++++++case+OpType::BinaryOp+{
++++++++++++i+>>+op+>>+value+>>+value2;
++++++++++++return+BinaryOperation{op,+value,+value2};+
++++++++}
++++}
}|2312286|entityMap^0|M|7|0|0|7|1|W|7|0|0|0|B|0|0|6|A|M|7|0|0|0|5|O|C|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@$9|18|A|19|B|M]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|N|3|O|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|P|3|Q|5|6|7|1D|8|@$9|1E|A|1F|B|M]]|D|@]|E|$]]|$1|R|3|S|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|T|3|U|5|6|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|V|3|W|5|H|7|1M|8|@]|D|@]|E|$I|J]]|$1|X|3|Y|5|6|7|1N|8|@$9|1O|A|1P|B|M]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|Z|3|10|5|H|7|1S|8|@]|D|@]|E|$I|J]]|$1|11|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|12|$]]

I think your best bet is to represent the file as a collection of <code>variant</code>s of the correct command type. For example, let's say you have three options of commands:

<pre><code>struct Constant {
 short value;
};
struct UnaryOperation {
 unsigned char opcode;
 short value;
};
struct BinaryOperation {
 unsigned char opcode;
 short value1;
 short value2;
};
</code></pre>

Representing an unknown command. If you have an unknown command, you can represent it as a <code>variant</code> of the three types:

<pre><code>using Command = std::variant&lt;Constant, UnaryOperation, BinaryOperation&gt;; 
</code></pre>

Applying a function based on the type of command. Let's say you have different functions for each command:

<pre><code>short eval(Constant c) {
 return c.value;
}
short eval(UnaryOperation u) {
 switch(u.opcode) {
 // stuff
 }
}
short eval(BinaryOperation b) {
 switch(b.opcode) {
 // stuff
 }
}
</code></pre>

We can use <code>std::visit</code> to evaluate an arbitrary <code>Command</code>:

<pre><code>short evaluate_command(Command const&amp; command) {
 short output; 
 // This calls the right overload automatically 
 std::visit(command, [&amp;](auto cmd) { output = eval(cmd); }); 
 return output; 
}
</code></pre>

Parsing a command.
We can create a <code>std::variant</code> automatically from any of the types it's defined over. That means that if you provide a way to figure out what the command is based on the file, it's pretty easy to do. 

<pre><code>enum class OpType : unsigned char {
 ConstantOp, UnaryOp, BinaryOp
};
// Command can be automatically constructed from a Constant, a UnaryOperation, or a BinaryOperation
Command readFromStream(std::istream&amp; i) {
 OpType type;
 unsigned char op;
 short value, value2;

 // Read the type of the operation
 i &gt;&gt; (unsigned char&amp;)type;

 //Return either a Constant, a UnaryOperation, or a BinaryOperation
 switch(type) {
 case OpType::ConstantOp: {
 i &gt;&gt; value;
 return Constant{value};
 }
 case OpType::UnaryOp: {
 i &gt;&gt; op &gt;&gt; value;
 return UnaryOperation{op, value};
 }
 case OpType::BinaryOp {
 i &gt;&gt; op &gt;&gt; value &gt;&gt; value2;
 return BinaryOperation{op, value, value2}; 
 }
 }
}
</code></pre>

My purpose is to build a config file. So I basically have to represent command packet structures in some way.

When the actual data(binary) comes I want to compare the packet with this config file and then process it (convert the data into CSV format).

So there are different command types. 

So each time when a packet comes, I have to take its opcode and check it with the config file and return the appropriate command format that represents the format of that packet.

The command format may look like below:

opcode - 1 bytes - integer

command - 4 byte - string

...

All the commands doesn't have the same number of fields or the same format.

I want to retrieve all these details. I can represent it in XML and parse it using some library like libxml2.

A sample XML format is given below:

<pre><code> &lt;cmd type="Multiplication"&gt;
 &lt;field name="opcode" type="string" bytes="4"/&gt;
 &lt;field name="Multiplicand" type="number" bytes="2"/&gt;
 &lt;field name="Multiplier" type="number" bytes="2"/&gt;
 &lt;/cmd&gt;
</code></pre>

But this approach is rather slow. 

My thinking is to somehow represent the command packet format in structures. But since C/C++ is not a reflective language, the structure members cannot be known and you will need one function per structure (command) to parse it.

Please suggest some way to store the formats such that one generic function can parse the binary data just by looking at this format. 

<ul>
<li>The languages can be C or C++. </li>
<li>Performance is top priority so XML and similar types are discouraged. </li>
<li>In memory data structures are preferred.</li>
</ul>

Any help is highly appreciated.

Data Structure to represent command packet format

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我的目的是构建一个配置文件。因此，我基本上必须以某种方式表示命令包结构。当实际数据(二进制)到来时，我想将数据包与此配置文件进行比较，然后进行处理(将数据转换为CSV格式)。所以有不同的命令类型。因此，每次当数据包到来时，我必须获取它的操作码，并用配置文件检查它，然后返回代表该数据包格式的适当命令格式。命令格式可能如下...

表示命令包格式的数据结构-腾讯云开发者社区-腾讯云

问表示命令包格式的数据结构
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问表示命令包格式的数据结构EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问表示命令包格式的数据结构
EN