<think>
我们注意到在Qt中，`QString::split`函数使用`Qt::SplitBehavior`枚举来控制分割行为。在较新的Qt版本中（如Qt5和Qt6），这个枚举包含`SkipEmptyParts`和`KeepEmptyParts`。
但是，用户反馈说“Qt::SkipEmptyParts没有成员SkipEmptyParts”，这可能是因为：
1. 用户使用的是较旧的Qt版本（如Qt4），其中没有`SkipEmptyParts`，而是使用`QString::SkipEmptyParts`（作为静态成员）或使用枚举值`QString::SkipEmptyParts`（在Qt4中是`QString::SkipEmptyParts`，注意这是一个静态成员，而不是`Qt`命名空间下的）。
2. 或者，用户在使用时可能写错了命名空间。
在Qt4中，我们使用`QString::SkipEmptyParts`，而在Qt5和Qt6中，我们通常使用`Qt::SkipEmptyParts`（推荐）或者也可以使用`QString::SkipEmptyParts`（为了向后兼容，它被保留为过时的）。
因此，我们可以根据用户的Qt版本来调整代码：
如果是Qt4：
使用 `QString::SkipEmptyParts`
如果是Qt5或Qt6：
推荐使用 `Qt::SkipEmptyParts`，但也可以使用 `QString::SkipEmptyParts`（但可能会被标记为过时）
为了兼容性，我们可以这样做：
方法1：使用预处理器指令
方法2：使用条件编译（如果知道Qt版本）
但是，由于我们无法预知用户的Qt版本，我们提供两种写法，并让用户根据实际情况选择。
另外，在用户的问题中，他要求将每一行作为一个QString存入QVector，并且原始字符串中有特殊的分隔符。
我们重新审视问题：原始字符串中有`[\n]`这样的分隔符，我们希望去除这些分隔符，并将每一行存入QVector。
我们之前提供的代码中使用了`Qt::SkipEmptyParts`，如果用户的环境不支持，我们可以改用`QString::SkipEmptyParts`（在Qt4中可用）或者使用`QString.split`的另一个重载，它接受一个分隔符和一个SplitBehavior（这个SplitBehavior在Qt4中是QString::SplitBehavior枚举，在Qt5和Qt6中，这个枚举被移到了Qt命名空间）。
为了兼容性，我们可以这样写：
在代码中：
使用 `#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)` 来判断Qt版本
但是，为了简单起见，我们也可以直接使用`QString::split`的旧式写法（使用`QString::SplitBehavior`），在Qt4中，这个枚举是`QString::SkipEmptyParts`，在Qt5中，这个枚举被移到了`Qt`命名空间，但为了兼容，Qt5仍然保留了`QString::SkipEmptyParts`（作为过时的）。
所以，我们可以这样写：
```cpp
// 使用QString::SkipEmptyParts（兼容Qt4和Qt5，但在Qt5中过时）
QStringList lines = data.split('\n', QString::SkipEmptyParts);
// 或者，使用条件编译
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
QStringList lines = data.split('\n', Qt::SkipEmptyParts);
#else
QStringList lines = data.split('\n', QString::SkipEmptyParts);
#endif
```
然而，用户可能没有定义`QT_VERSION`，我们可以采用更通用的写法：使用`QString::split`并传入分隔符和`QString::SkipEmptyParts`（因为即使在新版本，这个过时的枚举仍然可用，直到Qt6）。
但在Qt6中，`QString::SkipEmptyParts`被移除了，必须使用`Qt::SkipEmptyParts`。所以为了同时兼容Qt5和Qt6，我们可以这样：
```cpp
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
QStringList lines = data.split('\n', Qt::SkipEmptyParts);
#elif QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
// Qt5中两者都可以，但推荐使用Qt::SkipEmptyParts
QStringList lines = data.split('\n', Qt::SkipEmptyParts);
#else
// Qt4
QStringList lines = data.split('\n', QString::SkipEmptyParts);
#endif
```
但是，如果用户不想使用条件编译，我们可以使用另一种方法：使用`split`返回的列表，然后手动移除空字符串。
例如：
```cpp
QStringList lines = data.split('\n');
lines.removeAll(""); // 移除所有空字符串
// 但注意，这样也会移除中间的空行？实际上，原意是跳过空的部分，但这样会移除所有空字符串，包括中间的空行？而SkipEmptyParts会跳过连续分隔符产生的空部分。
// 但是，原字符串中我们使用了`Qt::SkipEmptyParts`，所以为了达到同样效果，我们可以：
QStringList lines = data.split('\n', QString::KeepEmptyParts); // 先保留空部分
lines.removeAll(QString("")); // 然后移除所有空字符串，这样就会把空行全部移除
// 但是注意：原始字符串中，如果两个换行符连续，那么中间会产生一个空行，使用SkipEmptyParts会跳过，而用这种方法也会移除。
```
因此，我们可以不用条件编译，而用：
```cpp
QStringList lines = data.split('\n', QString::KeepEmptyParts);
lines.removeAll(QString(""));
```
但是，这样会移除所有的空行，包括原始数据中可能存在的空行？而我们的需求是分割后得到非空行。但根据问题，原始字符串中没有真正的空行，所以可以这样做。
然而，用户的问题中原始字符串的分隔符是`[\n]`，分割后我们并不希望保留空行，所以移除空行是合理的。
因此，我们可以这样写（避免使用条件编译）：
```cpp
QStringList tempList = data.split('\n', QString::KeepEmptyParts);
tempList.removeAll(QString("")); // 移除所有空字符串
```
但注意：`QString("")`也可以写成`QString()`，但为了清晰，我们写`""`。
但是，`removeAll`会移除所有等于空字符串的元素。在分割时，如果一行是空的，那么它会被分割成一个空字符串。所以这样操作后，我们就跳过了空行。
所以，我们可以修改之前的代码，避免使用`Qt::SkipEmptyParts`，从而解决用户的问题。
现在，我们重写之前的处理代码，不使用`Qt::SkipEmptyParts`。
### 修改后的完整代码（避免使用Qt::SkipEmptyParts）
```cpp
#include <QString>
#include <QVector>
#include <QDebug>
#include <QRegularExpression>
int main() {
QString data =
"[VxX]q[VxX]x0.01[VxX]x<Tol2>bbbb[\n"
"][VxX]h[VxX]x0.01[VxX]x<Tol2>[VxX]t[VxX]xaaaaa[\n"
"][VxX]n[VxX]x0.01[VxX]x<Tol2>[VxY]7[VxX]x[VxY]7[VxX]x[VxY]1[VxX]x[VxX]~";
// 步骤1：处理特殊分隔符
// 1.1 替换所有 "[\n" 和 "\n]" 以及 "]\n[" 为换行符
QString processedData = data;
processedData.replace(QRegularExpression(R"(\]\s*\[\n)"), "\n"); // 处理 "]\n" 后跟 "[" 的情况，但这里我们直接处理成换行
processedData.replace("[\n", "\n");
processedData.replace("\n]", "\n");
// 1.2 处理行首的 ']' 和行尾的 '['
processedData.replace(QRegularExpression(R"(^\])"), "");
processedData.replace(QRegularExpression(R"(\[\s*$)"), "");
// 步骤2：分割字符串
QStringList tempList = processedData.split('\n', QString::KeepEmptyParts); // 先保留空的部分
// 移除所有空字符串
tempList.removeAll("");
// 转换为QVector
QVector<QString> result;
result = QVector<QString>::fromList(tempList); // 注意：在Qt5.14以后，QVector不再有fromList，可以直接用QVector<QString>(tempList.begin(), tempList.end())
// 或者使用循环
// 对于较新的Qt版本，如果QVector没有fromList，我们可以：
// QVector<QString> result;
// result.reserve(tempList.size());
// for (const QString &str : tempList) {
// result.append(str);
// }
// 验证
qDebug() << "处理后的行数:" << result.size();
for (int i = 0; i < result.size(); ++i) {
qDebug() << "行" << i+1 << ":" << result[i];
}
return 0;
}
```
### 兼容Qt5.14及以上版本（QVector::fromList被废弃）
在Qt5.14及以上，我们可以使用：
```cpp
QVector<QString> result(tempList.begin(), tempList.end());
```
因此，修改为：
```cpp
// 移除空字符串后
tempList.removeAll("");
// 转换为QVector（兼容Qt5.14及以上）
QVector<QString> result;
result = QVector<QString>(tempList.begin(), tempList.end());
```
### 更简洁的写法（使用范围构造）
```cpp
QVector<QString> result;
// 直接使用范围构造
QStringList noEmptyList = processedData.split('\n', QString::KeepEmptyParts);
noEmptyList.removeAll("");
result = QVector<QString>(noEmptyList.begin(), noEmptyList.end());
```
### 完整代码（兼容Qt4, Qt5, Qt6）
```cpp
#include <QString>
#include <QVector>
#include <QDebug>
#include <QRegularExpression>
int main() {
QString data =
"[VxX]q[VxX]x0.01[VxX]x<Tol2>bbbb[\n"
"][VxX]h[VxX]x0.01[VxX]x<Tol2>[VxX]t[VxX]xaaaaa[\n"
"][VxX]n[VxX]x0.01[VxX]x<Tol2>[VxY]7[VxX]x[VxY]7[VxX]x[VxY]1[VxX]x[VxX]~";
// 步骤1：特殊处理
QString processedData = data;
// 使用正则表达式匹配所有分隔符：包括 [\n, \n], 以及 ]\n[ 的情况
// 实际上，我们可以将所有的 [\n 和 \n] 替换为换行，同时将 ]\n[ 替换为换行（因为中间的]和[是连在一起的）
processedData.replace(QRegularExpression(R"(\]\s*\[\n)"), "\n"); // 处理 ]\n[ 的情况，注意原始字符串中有换行符，所以这里匹配]\n[
processedData.replace("[\n", "\n");
processedData.replace("\n]", "\n");
// 处理首尾
processedData.replace(QRegularExpression(R"(^\])"), ""); // 行首的]
processedData.replace(QRegularExpression(R"(\[\s*$)"), ""); // 行尾的[
// 步骤2：分割并移除空行
QStringList lines = processedData.split('\n', QString::KeepEmptyParts);
lines.removeAll("");
// 转换为QVector
QVector<QString> result;
// 使用迭代器构造QVector
result = QVector<QString>::fromList(lines); // 这个方法在Qt5.15被废弃，但在Qt4和Qt5早期版本可用
// 在Qt5.15及以上，建议使用：
// result = QVector<QString>(lines.begin(), lines.end());
// 输出验证
qDebug() << "Lines count: " << result.size();
for (int i = 0; i < result.size(); ++i) {
qDebug() << "Line " << i << ": " << result[i];
}
return 0;
}
```
### 针对Qt5.15及以上版本废弃QVector::fromList的适配
我们可以使用：
```cpp
#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
result = QVector<QString>::fromList(lines);
#else
result = QVector<QString>(lines.begin(), lines.end());
#endif
```
但为了简化，我们可以直接使用范围构造，它适用于所有版本（只要QVector支持迭代器构造，实际上从Qt2开始就支持，但为了确保，我们假设Qt4.8以上都支持迭代器构造？）
在Qt4中，QVector的构造函数不支持直接传入两个迭代器。所以为了兼容Qt4，我们需要使用循环。
最终，我们提供一个兼容Qt4的版本：
```cpp
QVector<QString> result;
for (int i = 0; i < lines.size(); ++i) {
if (!lines[i].isEmpty()) { // 这里其实已经移除了空行，但再判断一次也可以
result.append(lines[i]);
}
}
```
### 最终兼容版本
```cpp
#include <QString>
#include <QVector>
#include <QDebug>
#include <QRegularExpression>
int main() {
QString data =
"[VxX]q[VxX]x0.01[VxX]x<Tol2>bbbb[\n"
"][VxX]h[VxX]x0.01[VxX]x<Tol2>[VxX]t[VxX]xaaaaa[\n"
"][VxX]n[VxX]x0.01[VxX]x<Tol2>[VxY]7[VxX]x[VxY]7[VxX]x[VxY]1[VxX]x[VxX]~";
// 处理数据
QString processedData = data;
processedData.replace(QRegularExpression(R"(\]\s*\[\n)"), "\n");
processedData.replace("[\n", "\n");
processedData.replace("\n]", "\n");
processedData.replace(QRegularExpression(R"(^\])"), "");
processedData.replace(QRegularExpression(R"(\[\s*$)"), "");
// 分割
QStringList lines = processedData.split('\n', QString::KeepEmptyParts);
lines.removeAll("");
// 存入QVector
QVector<QString> result;
for (const QString &line : lines) {
result.append(line);
}
// 输出
qDebug() << "Lines: " << result.size();
for (int i = 0; i < result.size(); ++i) {
qDebug() << result[i];
}
return 0;
}
```
这个版本应该可以在Qt4和Qt5、Qt6上运行。
§§相关问题§§
1. 在Qt4中，除了使用`QString::SkipEmptyParts`，还有哪些方法可以在分割字符串时跳过空部分？
2. 如果原始字符串中的特殊分隔符不是`[\n]`而是其他形式（如`{换行}`），应如何调整正则表达式？
3. 在分割字符串后，除了使用`removeAll("")`移除空字符串，还有哪些高效的方法可以过滤掉空行？
4. 在处理超大型字符串时，如何优化内存使用以避免多次复制？
</think>### 解决 `Qt::SkipEmptyParts` 错误的方法
在 Qt 中处理字符串分割时，`Qt::SkipEmptyParts` 的使用方式取决于 Qt 版本：
#### 1. Qt 5.14+ 版本的正确用法
```cpp
#include <QString>
#include <QVector>
int main() {
QString data = "[VxX]q[VxX]x0.01[VxX]x<Tol2>bbbb[\n"
"][VxX]h[VxX]x0.01[VxX]x<Tol2>[VxX]t[VxX]xaaaaa[\n"
"][VxX]n[VxX]x0.01[VxX]x<Tol2>[VxY]7[VxX]x[VxY]7[VxX]x[VxY]1[VxX]x[VxX]~";
// 步骤1：替换特殊分隔符
data.replace("[\n]", "\n"); // 处理完整的[\n]
data.replace("[\n", ""); // 移除开头的[
data.replace("\n]", ""); // 移除结尾的]
// 步骤2：分割字符串（正确使用SkipEmptyParts）
QStringList lines = data.split('\n', Qt::SkipEmptyParts);
// 步骤3：存入QVector
QVector<QString> result;
for (const QString &line : lines) {
result.append(line);
}
return 0;
}
```
#### 2. 兼容旧版 Qt 的解决方案（Qt < 5.14）
```cpp
QVector<QString> processData(const QString &input) {
// 处理特殊分隔符
QString processed = input;
processed.replace(QRegularExpression(R"(\]\s*\[\n)"), "\n");
processed.replace(QRegularExpression(R"(\[\n|\n\])"), "");
// 分割后手动过滤空行
QStringList lines = processed.split('\n');
QVector<QString> result;
for (const QString &line : lines) {
if (!line.trimmed().isEmpty()) {
result.append(line);
}
}
return result;
}
```
#### 3. 使用正则表达式统一处理
```cpp
#include <QRegularExpression>
QVector<QString> advancedProcess(const QString &input) {
// 一次性处理所有特殊分隔符
QRegularExpression separator(R"((?:\[\n\]|\[\n|\n\]))");
QString normalized = input.replace(separator, "\n");
// 分割并过滤空行
QStringList lines = normalized.split('\n');
QVector<QString> result;
for (const QString &line : lines) {
if (!line.isEmpty()) {
result.append(line);
}
}
return result;
}
```
### 验证处理结果
```cpp
// 测试代码
void testProcessing() {
QString testData = "..."; // 原始数据
QVector<QString> result = advancedProcess(testData);
qDebug() << "处理结果:";
for (int i = 0; i < result.size(); ++i) {
qDebug() << "行" << i+1 << ":" << result[i];
}
/* 预期输出:
行1: [VxX]q[VxX]x0.01[VxX]x<Tol2>bbbb
行2: [VxX]h[VxX]x0.01[VxX]x<Tol2>[VxX]t[VxX]xaaaaa
行3: [VxX]n[VxX]x0.01[VxX]x<Tol2>[VxY]7[VxX]x[VxY]7[VxX]x[VxY]1[VxX]x[VxX]~
*/
}
```
### 关键点说明
1. **Qt版本差异**：
- Qt 5.14+：直接使用 `Qt::SkipEmptyParts`
- 旧版Qt：手动过滤空行 `if (!line.isEmpty())`
2. **分隔符处理**：
- `[\n]` → 替换为换行符
- `[` 开头和 `]` 结尾 → 直接移除
- 使用正则表达式处理复杂模式
3. **内存优化**：
```cpp
result.reserve(lines.size()); // 预分配内存
```
扫一扫
274
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
