QStringTokenizer 类

template <typename Haystack, typename Needle> class QStringTokenizer

QStringTokenizer 类根据给定的分隔符将字符串分割成令牌。 更多...

头文件 #include <QStringTokenizer>
CMakefind_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmakeQT += core
Qt 6.0
继承自QtPrivate::Tok::HaystackPinning (私有),QtPrivate::Tok::NeedlePinning (私有),及

注意:本类中所有函数都是 可重入的

公共类型

公共函数

QStringTokenizer(Haystack haystack, Needle needle, Qt::CaseSensitivity cs = Qt::KeepEmptyParts)
QStringTokenizer(Haystack haystack, Needle needle, Qt::SplitBehavior sb = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QStringTokenizer<Haystack, Needle>::iteratorbegin() const
QStringTokenizer<Haystack, Needle>::iteratorcbegin() const
QStringTokenizer<Haystack, Needle>::sentinelcend() const
QStringTokenizer<Haystack, Needle>::sentinelend() const
LContainertoContainer(LContainer &&c ={}) const &
RContainertoContainer(RContainer &&c ={}) const &&
(since 6.0) decltype(QtPrivate::Tok::TokenizerResult<Haystack, Needle>{std::forward<Haystack>(h), std::forward<Needle>(n), flags...})qTokenize(Haystack &&haystack, Needle &&needle, Flags... flags)

详细描述

将字符串按指定的分隔符分割成子字符串,并返回包含这些字符串的(惰性构建的)列表。如果字符串中没有匹配分隔符,则产生一个只包含该字符串的单元素列表。如果分隔符为空,QStringTokenizer 将产生一个空字符串,后跟字符串的每个字符,然后又是一个空字符串。Qt::SplitBehavior 和 Qt::CaseSensitivity 枚举进一步控制输出。

QStringTokenizer 驱动 QStringView::tokenize(),但在最新编译器中也可以直接使用。

for (auto it : QStringTokenizer{string, separator})
    use(*it);

注意:您绝对不应该明确命名QStringTokenizer的模板参数。如果可以使用C++17类模板参数推导(CTAD),您可以写QStringTokenizer{string, separator}(不需要模板参数)。如果无法使用C++17 CTAD,则必须使用QStringView::split()或QLatin1StringView::split()成员函数,并将返回值仅存储在auto变量中

auto result = string.split(sep);

这是因为QStringTokenizer的模板参数对构造它们的特定字符串和分隔符类型有非常微妙的依赖性,并且通常不对应于实际传递的类型。

懒序列

QStringTokenizer充当所谓的懒序列,也就是说,仅当您请求它时,才会计算下一个元素。懒序列的优点是它们只需要O(1)的内存。它们的不利之处在于,至少对于QStringTokenizer,它们只允许前向迭代,而不允许随机访问迭代。

预期使用场景是您只需将其插入到range for循环中

for (auto it : QStringTokenizer{string, separator})
    use(*it);

或C++20范围内的算法

std::ranges::for_each(QStringTokenizer{string, separator},
                      [] (auto token) { use(token); });

结束哨兵

QStringTokenizer迭代器不能与经典STL算法一起使用,因为这些算法需要迭代器/迭代器对,而QStringTokenizer使用哨兵。也就是说,它使用不同的类型,QStringTokenizer::sentinel,来标记范围的末尾。这提高了性能,因为哨兵是一个空类型。从C++17(用于range for)和C++20(用于使用新range库的算法)开始支持哨兵。

临时变量

QStringTokenizer被非常精心地设计,以避免悬空引用。如果您从临时字符串(rvalue)中构建解析器,则该参数将内部存储,这样在分词之前不会删除引用的数据

auto tok = QStringTokenizer{widget.text(), u','};
// return value of `widget.text()` is destroyed, but content was moved into `tok`
for (auto e : tok)
   use(e);

如果您传递命名的对象(lvalue),则QStringTokenizer不会存储副本。您需要负责在解析器操作对象数据所在的时间段之外保留名称对象的数据

auto text = widget.text();
auto tok = QStringTokenizer{text, u','};
text.clear();      // destroy content of `text`
for (auto e : tok) // ERROR: `tok` references deleted data!
    use(e);

另请参阅QStringView::split()、QString::split()和QRegularExpression

成员类型文档

[别名] QStringTokenizer::const_iterator

此typedef为QStringTokenizer提供STL风格的const迭代器。

另请参阅iterator

[别名] QStringTokenizer::const_pointer

别名于value_type *

[别名] QStringTokenizer::const_reference

别名于value_type &

[别名] QStringTokenizer::difference_type

别名于qsizetype。

[别名] QStringTokenizer::iterator

此typedef为QStringTokenizer提供STL风格的const迭代器。

QStringTokenizer不支持可变迭代器,所以这是与const_iterator相同的。

另请参阅const_iterator

[别名] QStringTokenizer::pointer

别名于value_type *

QStringTokenizer不支持可变迭代器,所以这是与const_pointer相同的。

[别名] QStringTokenizer::引用

别名于value_type &

QStringTokenizer 不支持可变引用,因此这与 const_reference 相同。

[别名] QStringTokenizer::哨兵

此类型定义提供了 STL 风格的哨兵,用于 QStringTokenizer::iteratorQStringTokenizer::const_iterator

另请参阅const_iterator

[别名] QStringTokenizer::size_type

别名于qsizetype。

[别名] QStringTokenizer::value_type

别名根据标记器 Haystack 模板参数选择 const QStringViewconst QLatin1StringView

成员函数文档

[explicit constexpr noexcept(...)] QStringTokenizer::QStringTokenizer(Haystack haystack, Needle needle, Qt::CaseSensitivity cs, Qt::SplitBehavior sb = Qt::KeepEmptyParts)

[explicit constexpr noexcept(...)] QStringTokenizer::QStringTokenizer(Haystack haystack, Needle needle, Qt::SplitBehavior sb = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive)

构造一个字符串标记器,将字符串 haystack 按照在哪个位置找到 needle 将其分割成子字符串,并允许遍历这些字符串。如果 needlehaystack 中没有匹配项,则只生成包含 haystack 的单个元素。

cs 指定是否应区分大小写地匹配 needle

如果 sbQt::SkipEmptyParts,则结果中不会出现空条目。默认情况下,包括空条目。

注意: 当 "std::is_nothrow_copy_constructible<QStringTokenizer>::value" 为真时,(1) 不抛出任何异常。

注意: 当 "std::is_nothrow_copy_constructible<QStringTokenizer>::value" 为真时,(2) 不抛出任何异常。

另请参阅:QStringView::split()、QString::split()、Qt::CaseSensitivityQt::SplitBehavior

[noexcept] QStringTokenizer<Haystack, Needle>::iterator QStringTokenizer::begin() const

[noexcept] QStringTokenizer<Haystack, Needle>::iterator QStringTokenizer::cbegin() const

返回一个指向列表中第一个标记的常量 STL-style iterator

另请参阅:end() 和 cend()。

[constexpr noexcept] QStringTokenizer<Haystack, Needle>::sentinel QStringTokenizer::cend() const

end() 相同。

另请参阅cbegin() 和 end()。

[constexpr noexcept] QStringTokenizer<Haystack, Needle>::sentinel QStringTokenizer::end() const

返回一个指向列表中最后一个标记之后假想标记的常量 STL-style 标志。

另请参阅begin() 和 cend()。

template <typename LContainer> LContainer QStringTokenizer::toContainer(LContainer &&c = {}) const &

将懒惰序列转换为类型为 LContainer 的(通常是)随机访问容器。

如果 Container 有一个与这个标记器 value_type 匹配的 value_type,那么这个函数才是可用的。

如果你传入了名为的容器(一个 lvalue)给 c,则该容器会被填充,并返回对该容器的引用。如果你传入了临时容器(一个 rvalue,包括默认参数),则该容器会被填充,并通过值返回。

// assuming tok's value_type is QStringView, then...
auto tok = QStringTokenizer{~~~};
// ... rac1 is a QList:
auto rac1 = tok.toContainer();
// ... rac2 is std::pmr::vector<QStringView>:
auto rac2 = tok.toContainer<std::pmr::vector<QStringView>>();
auto rac3 = QVarLengthArray<QStringView, 12>{};
// appends the token sequence produced by tok to rac3
//  and returns a reference to rac3 (which we ignore here):
tok.toContainer(rac3);

这让你可以用最大的灵活性来存储序列。

template <typename RContainer> RContainer QStringTokenizer::toContainer(RContainer &&c = {}) const &&

这是一个重载函数。

将懒惰序列转换为类型为 RContainer 的(通常是)随机访问容器。

除了对 lvalue-this 重载的限制外,此 rvalue-this 重载仅在当前 QStringTokenizer 不存储内部 haystack 时才可用,因为这可能会创建一个包含悬挂引用的容器

auto tokens = QStringTokenizer{widget.text(), u','}.toContainer();
// ERROR: cannot call toContainer() on rvalue
// 'tokens' references the data of the copy of widget.text()
// stored inside the QStringTokenizer, which has since been deleted

要修复,请在一个临时位置存储 QStringTokenizer

auto tokenizer = QStringTokenizer{widget.text90, u','};
auto tokens = tokenizer.toContainer();
// OK: the copy of widget.text() stored in 'tokenizer' keeps the data
// referenced by 'tokens' alive.

您可以通过传递一个视图来强制此函数存在

func(QStringTokenizer{QStringView{widget.text()}, u','}.toContainer());
// OK: compiler keeps widget.text() around until after func() has executed

如果你为 c 传入了一个命名容器(一个 lvalue),则该容器将被填充,并返回对该容器的引用。如果你传递了一个临时容器(一个 rvalue,包括默认参数),则该容器将被填充,并通过值返回。

相关非成员函数

[constexpr noexcept(...), since 6.0] template <typename Haystack, typename Needle, typename... Flags> decltype(QtPrivate::Tok::TokenizerResult<Haystack, Needle>{std::forward<Haystack>(h), std::forward<Needle>(n), flags...}) qTokenize(Haystack &&haystack, Needle &&needle, Flags... flags)

这是一个用于创建 QStringTokenizer 的工厂函数,它将字符串 haystackneedle 发生处分割成子字符串,并允许遍历这些字符串。如果 needlehaystack 中没有匹配项,将产生一个包含 haystack 的单个元素。

将来自 Qt::CaseSensitivityQt::SplitBehavior 枚举值的 flags 传递给标记器以修改标记器的行为。

如果您编译器目前不支持C++17类模板参数推导(CTAD),则可以使用此功能。我们建议使用CTAD直接使用QStringTokenizer

此功能是在Qt 6.0中引入的。

注意:当"QtPrivate::Tok::is_nothrow_constructible_from<Haystack, Needle>::value"为true时,此函数不抛出任何异常。

© 2024 Qt公司。本文件中的文档贡献属于各自的版权所有者。提供的文档受GNU自由文档许可证1.3版的条款限制,该许可证由自由软件基金会发布。Qt及其相关标志是芬兰和/或世界其他国家的Qt公司的商标。所有其他商标均为其各自所有者的财产。