解析这些数据时如何使用？

Question

我有一个十六进制数据，如下所示：

24 00 00 07 01 31 0f 66 65 77 66 63 77 65 72 74
32 35 33 76 73 77 04 31 30 30 30 05 66 65 32 32
66 06 76 77 65 72 67 34

注意： '24' 是从 '01' 到 '34' 的所有长度。

‘01’是后续数据的一个字节长度，如‘31’。

'0f'是后数据的15字节长度，例如：66 65 77 66 63 77 65 72 74 32 35 33 76 73 77。

'04'是后数据的4字节长度，如：31 30 30 30。

'05'是后数据的5字节长度，如：66 65 32 32 66。

'06'是后数据的6字节长度，如：76 77 65 72 67 34。

现在，我遇到了麻烦。

如何使用 while 和嵌套 while 来解决？

我尝试编写这段代码：

    // rowStart begin for data of 01.
    rowStart = 4;
    // 5 is all length of 
    while (i < 5) {
        nextLen = data[rowStart];

        rowStart ++;
        while (k < nextLen) {

            rowStart ++;
            k ++;
        }

        i ++;
    }

但这并不能解决我的问题。

我尝试过使用 while 和嵌套 while 来解决它，但最终我无法解决它。

Answer 1

这是一个片段，应该将此十六进制字节解析为向量向量，每个向量包含使用长度字节的部分数据：

#include <iostream>
#include <sstream>
#include <vector>
#include <string>

using namespace std;

// Function to convert a single hex character to its corresponding integer value
int hexCharToInt(char c) {
  if (c >= '0' && c <= '9') {
    return c - '0';
  } else if (c >= 'a' && c <= 'f') {
    return c - 'a' + 10;
  } else if (c >= 'A' && c <= 'F') {
    return c - 'A' + 10;
  } else {
    cerr << "Error: Invalid hex character: " << c << endl;
    return -1;
  }
}

// Function to parse a single hex byte from the input string
int parseHexByte(string& data) {
  if (data.length() < 2) {
    cerr << "Error: Insufficient data for hex byte" << endl;
    return -1;
  }

  int highNibble = hexCharToInt(data[0]);
  int lowNibble = hexCharToInt(data[1]);
  if (highNibble == -1 || lowNibble == -1) {
    return -1;
  }

  data.erase(0, 2);
  return (highNibble << 4) | lowNibble;
}

// Function to parse the hex data string
vector<vector<int>> parseHexData(string data) {
  vector<vector<int>> parsedData;
  stringstream ss(data);
  string token;

  // Get total length
  int totalLength = parseHexByte(data);
  if (totalLength == -1) {
    return parsedData;
  }

  while (getline(ss, token, ' ')) {
    if (token.empty()) {
      continue;
    }

    int subLength = parseHexByte(token);
    if (subLength == -1) {
      return parsedData;
    }

    vector<int> subData;
    for (int i = 0; i < subLength; i++) {
      int byte = parseHexByte(token);
      if (byte == -1) {
        return parsedData;
      }
      subData.push_back(byte);
    }

    parsedData.push_back(subData);
  }

  if (parsedData.size() != totalLength) {
    cerr << "Error: Data length mismatch" << endl;
  }

  return parsedData;
}

int main() {
  string hexData = "24 00 00 07 01 31 0f 66 65 77 66 63 77 65 72 74 32 35 33 76 73 77 04 31 30 30 05 66 65 32 32 66 06 76 77 65 72 67 34";

  vector<vector<int>> parsedData = parseHexData(hexData);

  if (parsedData.empty()) {
    cerr << "Error parsing data" << endl;
    return 1;
  }

  cout << "Parsed data:" << endl;
  for (const vector<int>& subData : parsedData) {
    for (int byte : subData) {
      cout << hex << byte << " ";
    }
    cout << endl;
  }

  return 0;
}