【QML】解决 Qt C++ 正则表达式中文匹配问题

在qt中解析复杂的中文文本一直出现乱码的问题，参考了很多也解决不了，当前的场景是在qml中点击解析，文件内容为：

整体分析
1. **作战目标核心要素**：精准定位敌方指挥所并实施打击，需完成侦察→打击→毁伤评估全流程，核心目标为价值0.95的指挥所。
2. **任务阶段划分及功能**：
   - 阶段1（侦察）：需覆盖敌方阵地范围（x:200-1000,y:5000-10000），必备载荷为多光谱侦察相机（视距10km）或光电吊舱（探测距离75km）
   - 阶段2（打击）：需覆盖指挥所位置（610,8620），必备载荷为制导炮弹（制导距离6km）或雷达侦察载荷（探测距离250km）
   - 阶段3（评估）：需再次确认毁伤状态，需保留光电侦察载荷（探测距离60km）
3. **必要平台/载荷筛选**：
   - 无侦-7（价值0.9）：多光谱相机（95.2%识别精度）+电抗设备（干扰距离50km）→满足侦察和电磁压制需求
   - KV005H（价值0.8）：光电吊舱（75km探测距离）+破片炮弹（6km制导距离）→兼顾侦察与打击
   - 无直-2（价值0.7）：雷达侦察载荷（250km探测距离）→满足远距离侦察需求
   - KVD001（价值0.4）：破片炮弹（6km制导距离）→低成本打击

优先级分析
- **资源投入成本优先**：减少平台数量（保留KVD001×8+无直-2×2），将无侦-7部署至阵地2（35200-51000,18000-26000）中心点（43100,22000），使用雷达侦察载荷替代光电吊舱，降低总成本至360w美元
- **任务完成率优先**：保留无侦-7×1+KV005H×2，部署无侦-7至阵地2（43100,22000）执行高速侦察，KV005H部署至阵地1（23800,24000）实施精确打击，确保指挥所识别精度达95.2%
- **任务完成时间优先**：将无侦-7部署至阵地1（23800,24000）执行快速侦察（6.1小时续航），KVD001部署至阵地1（23800,24000）实施打击（4小时续航），压缩总时长至10小时
- **损耗优先**：将无直-2部署至阵地1（23800,24000）执行远距离侦察（雷达载荷250km探测距离），KV005H部署至阵地2（43100,22000）实施打击，减少暴露在敌方无人机（750km/h）威胁下的概率
- **任务价值优先**：保留无侦-7×1+KV005H×2，无侦-7部署至阵地2（43100,22000）执行高价值目标（指挥所）侦察，KV005H部署至阵地1（23800,24000）实施精确打击，确保指挥所摧毁概率达95.2%


文字建议
1. **资源投入成本优先**：部署KVD001×8至阵地1（21500,23000）执行打击，无直-2×2至阵地1（23800,24000）执行远距离侦察，减少高价值平台数量
2. **任务完成率优先**：无侦-7×1至阵地2（43100,22000）执行高速侦察，KV005H×2至阵地1（23800,24000）实施精确打击，确保指挥所识别精度
3. **任务完成时间优先**：无侦-7×1至阵地1（23800,24000）快速侦察，KVD001×8至阵地1（23800,24000）立即打击，压缩总时长至10小时
4. **损耗优先**：无直-2×2至阵地1（23800,24000）执行远距离侦察，KV005H×2至阵地2（43100,22000）实施打击，减少暴露风险
5. **任务价值优先**：无侦-7×1至阵地2（43100,22000）重点侦察指挥所，KV005H×2至阵地1（23800,24000）实施精确打击，聚焦高价值目标


json
{
  "资源投入成本优先": {
    "KVD001": {
      "平台数量": [8],
      "平台位置": [21500,23000],
      "载荷": {
        "破片型炮弹": {"载荷数量": [4]}
      }
    },
    "无直-2": {
      "平台数量": [2],
      "平台位置": [23800,24000],
      "载荷": {
        "雷达侦察载荷": {"载荷数量": [1]}
      }
    }
  },
  "任务完成率优先": {
    "无侦-7": {
      "平台数量": [1],
      "平台位置": [43100,22000],
      "载荷": {
        "多光谱侦察相机": {"载荷数量": [1]}
      }
    },
    "KV005H": {
      "平台数量": [2],
      "平台位置": [23800,24000],
      "载荷": {
        "光电吊舱": {"载荷数量": [1]}
      }
    }
  },
  "任务完成时间优先": {
    "无侦-7": {
      "平台数量": [1],
      "平台位置": [23800,24000],
      "载荷": {
        "多光谱侦察相机": {"载荷数量": [1]}
      }
    },
    "KVD001": {
      "平台数量": [8],
      "平台位置": [23800,24000],
      "载荷": {
        "破片型炮弹": {"载荷数量": [4]}
      }
    }
  },
  "损耗优先": {
    "无直-2": {
      "平台数量": [2],
      "平台位置": [23800,24000],
      "载荷": {
        "雷达侦察载荷": {"载荷数量": [1]}
      }
    },
    "KV005H": {
      "平台数量": [2],
      "平台位置": [43100,22000],
      "载荷": {
        "光电吊舱": {"载荷数量": [1]}
      }
    }
  },
  "任务价值优先": {
    "无侦-7": {
      "平台数量": [1],
      "平台位置": [43100,22000],
      "载荷": {
        "多光谱侦察相机": {"载荷数量": [1]}
      }
    },
    "KV005H": {
      "平台数量": [2],
      "平台位置": [23800,24000],
      "载荷": {
        "光电吊舱": {"载荷数量": [1]}
      }
    }
  }
}

需要解析一个这样的txt文件，并分别提取其中的内容，将其分为四块内容

代码方法如下：

1. 确保正确的编码处理

首先，确保您的源代码文件和文本文件都使用 UTF-8 编码：

void FileParser::parseFile(const QString &filePath)
{
    QFile file(filePath);
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        emit errorOccurred(tr("无法打开文件: %1").arg(filePath));
        return;
    }

    QTextStream in(&file);
    in.setCodec("UTF-8");
    QString content = in.readAll();
    file.close();

    qDebug() << "File content size:" << content.size();

    // 清空之前的数据
    m_overallAnalysis.clear();
    m_priorityAnalysis.clear();
    m_adviceList.clear();
    m_jsonData = QJsonObject();
    m_fullContent = content;

    // 尝试提取各部分内容，如果失败则使用完整内容
    if (!extractSections(content)) {
        m_overallAnalysis = content; // 如果解析失败，将完整内容放在整体分析中
    }

    emit dataChanged();
}

2. 使用 Unicode 属性进行正则表达式匹配

bool FileParser::extractSections(const QString &content)
{
    bool success = true;

    // 使用 Unicode 属性匹配中文字符
    QRegularExpression overallRegex(u8"整体分析[\\s\\n]*[:：]?[\\s\\n]*(.*?)(?=优先级分析|文字建议|json|$)",
                                    QRegularExpression::DotMatchesEverythingOption |
                                        QRegularExpression::UseUnicodePropertiesOption);

    QRegularExpression priorityRegex(u8"优先级分析[\\s\\n]*[:：]?[\\s\\n]*(.*?)(?=文字建议|json|$)",
                                     QRegularExpression::DotMatchesEverythingOption |
                                         QRegularExpression::UseUnicodePropertiesOption);

    QRegularExpression adviceRegex(u8"文字建议[\\s\\n]*[:：]?[\\s\\n]*(.*?)(?=json|$)",
                                   QRegularExpression::DotMatchesEverythingOption |
                                       QRegularExpression::UseUnicodePropertiesOption);

    QRegularExpression jsonRegex(u8"json[\\s\\n]*[:：]?[\\s\\n]*(\\{.*\\})",
                                 QRegularExpression::DotMatchesEverythingOption |
                                     QRegularExpression::UseUnicodePropertiesOption);


    // 提取整体分析
    QRegularExpressionMatch overallMatch = overallRegex.match(content);
    if (overallMatch.hasMatch()) {
        m_overallAnalysis = overallMatch.captured(1).trimmed();
        qDebug() << "Overall analysis found, length:" << m_overallAnalysis.length();
    } else {
        qDebug() << "Overall analysis not matched";
        success = false;
    }

    // 提取优先级分析
    QRegularExpressionMatch priorityMatch = priorityRegex.match(content);
    if (priorityMatch.hasMatch()) {
        m_priorityAnalysis = priorityMatch.captured(1).trimmed();
        qDebug() << "Priority analysis found, length:" << m_priorityAnalysis.length();
    } else {
        qDebug() << "Priority analysis not matched";
        success = false;
    }

    // 提取建议列表
    QRegularExpressionMatch adviceMatch = adviceRegex.match(content);
    if (adviceMatch.hasMatch()) {
        QString adviceText = adviceMatch.captured(1).trimmed();
        qDebug() << "Advice text found, length:" << adviceText.length();

        // 分割每条建议 - 更灵活的正则表达式，适应中文格式
        QRegularExpression adviceItemRegex("(\\d+)[\\.．]?\\s*([^:：]+)[:：]?\\s*(.*)");
        QStringList lines = adviceText.split("\n", Qt::SkipEmptyParts);

        for (const QString &line : lines) {
            QRegularExpressionMatch itemMatch = adviceItemRegex.match(line);
            if (itemMatch.hasMatch()) {
                QString title = itemMatch.captured(2).trimmed();
                QString description = itemMatch.captured(3).trimmed();

                QVariantMap adviceItem;
                adviceItem["title"] = title;
                adviceItem["description"] = description;

                m_adviceList.append(adviceItem);
                qDebug() << "Added advice:" << title;
            } else if (!line.trimmed().isEmpty()) {
                // 如果正则不匹配但仍然有内容，添加到列表
                QVariantMap adviceItem;
                adviceItem["title"] = "建议";
                adviceItem["description"] = line.trimmed();
                m_adviceList.append(adviceItem);
                qDebug() << "Added fallback advice:" << line;
            }
        }
    } else {
        qDebug() << "Advice section not matched";
        success = false;
    }

    // 提取JSON数据
    QRegularExpressionMatch jsonMatch = jsonRegex.match(content);
    if (jsonMatch.hasMatch()) {
        QString jsonStr = jsonMatch.captured(1).trimmed();
        qDebug() << "JSON string found, length:" << jsonStr.length();
        parseJsonData(jsonStr);
    } else {
        qDebug() << "JSON section not matched";
        success = false;
    }

    return success;
}

 

void FileParser::parseJsonData(const QString &jsonStr)
{
    QJsonParseError error;
    QJsonDocument doc = QJsonDocument::fromJson(jsonStr.toUtf8(), &error);

    if (error.error == QJsonParseError::NoError && doc.isObject()) {
        m_jsonData = doc.object();
        qDebug() << "JSON parsed successfully, keys:" << m_jsonData.keys();
    } else {
        qDebug() << "Failed to parse JSON:" << error.errorString();
    }
}

 

关键点在于：

  // 使用 Unicode 属性匹配中文字符
    QRegularExpression overallRegex(u8"整体分析[\\s\\n]*[:：]?[\\s\\n]*(.*?)(?=优先级分析|文字建议|json|$)",
                                    QRegularExpression::DotMatchesEverythingOption | 
                                    QRegularExpression::UseUnicodePropertiesOption);
    
    QRegularExpression priorityRegex(u8"优先级分析[\\s\\n]*[:：]?[\\s\\n]*(.*?)(?=文字建议|json|$)",
                                     QRegularExpression::DotMatchesEverythingOption | 
                                     QRegularExpression::UseUnicodePropertiesOption);
    
    QRegularExpression adviceRegex(u8"文字建议[\\s\\n]*[:：]?[\\s\\n]*(.*?)(?=json|$)",
                                   QRegularExpression::DotMatchesEverythingOption | 
                                   QRegularExpression::UseUnicodePropertiesOption);
    
    QRegularExpression jsonRegex(u8"json[\\s\\n]*[:：]?[\\s\\n]*(\\{.*\\})",
                                 QRegularExpression::DotMatchesEverythingOption | 
                                 QRegularExpression::UseUnicodePropertiesOption);

 若去掉后面的json数据，则解析需要变成：

    // 使用 Unicode 属性匹配中文字符，去掉 json 部分的匹配
    QRegularExpression overallRegex(u8"整体分析[\\s\\n]*[:：]?[\\s\\n]*(.*?)(?=优先级分析|文字建议|$)",
                                    QRegularExpression::DotMatchesEverythingOption |
                                        QRegularExpression::UseUnicodePropertiesOption);

    QRegularExpression priorityRegex(u8"优先级分析[\\s\\n]*[:：]?[\\s\\n]*(.*?)(?=文字建议|$)",
                                     QRegularExpression::DotMatchesEverythingOption |
                                         QRegularExpression::UseUnicodePropertiesOption);

    QRegularExpression adviceRegex(u8"文字建议[\\s\\n]*[:：]?[\\s\\n]*(.*?)$",
                                   QRegularExpression::DotMatchesEverythingOption |
                                       QRegularExpression::UseUnicodePropertiesOption);