QRegularExpression 类

QRegularExpression re("a pattern");
					

QRegularExpression re;
re.setPattern("another pattern");
					

// matches two digits followed by a space and a word
QRegularExpression re("\\d\\d \\w+");
// matches a backslash
QRegularExpression re2("\\\\");
					

// matches two digits followed by a space and a word
QRegularExpression re(R"(\d\d \w+)");
					

QRegularExpression re("a third pattern");
QString pattern = re.pattern(); // pattern == "a third pattern"
					

// matches "Qt rocks", but also "QT rocks", "QT ROCKS", "qT rOcKs", etc.
QRegularExpression re("Qt rocks", QRegularExpression::CaseInsensitiveOption);
					

QRegularExpression re("^\\d+$");
re.setPatternOptions(QRegularExpression::MultilineOption);
// re matches any line in the subject string that contains only digits (but at least one)
					

QRegularExpression re = QRegularExpression("^two.*words$", QRegularExpression::MultilineOption
                                                           | QRegularExpression::DotMatchesEverythingOption);
QRegularExpression::PatternOptions options = re.patternOptions();
// options == QRegularExpression::MultilineOption | QRegularExpression::DotMatchesEverythingOption
					

// match two digits followed by a space and a word
QRegularExpression re("\\d\\d \\w+");
QRegularExpressionMatch match = re.match("abc123 def");
bool hasMatch = match.hasMatch(); // true
					

QRegularExpression re("\\d\\d \\w+");
QRegularExpressionMatch match = re.match("abc123 def");
if (match.hasMatch()) {
    QString matched = match.captured(0); // matched == "23 def"
    // ...
}
					

QRegularExpression re("\\d\\d \\w+");
QRegularExpressionMatch match = re.match("12 abc 45 def", 1);
if (match.hasMatch()) {
    QString matched = match.captured(0); // matched == "45 def"
    // ...
}
					
					

提取捕获的子字符串

The QRegularExpressionMatch object contains also information about the substrings captured by the capturing groups in the pattern string. The captured () function will return the string captured by the n-th capturing group:

QRegularExpression re("^(\\d\\d)/(\\d\\d)/(\\d\\d\\d\\d)$");
QRegularExpressionMatch match = re.match("08/12/1985");
if (match.hasMatch()) {
    QString day = match.captured(1); // day == "08"
    QString month = match.captured(2); // month == "12"
    QString year = match.captured(3); // year == "1985"
    // ...
}
				

Capturing groups in the pattern are numbered starting from 1, and the implicit capturing group 0 is used to capture the substring that matched the entire pattern.

It's also possible to retrieve the starting and the ending offsets (inside the subject string) of each captured substring, by using the capturedStart () 和 capturedEnd () 函数：

QRegularExpression re("abc(\\d+)def");
QRegularExpressionMatch match = re.match("XYZabc123defXYZ");
if (match.hasMatch()) {
    int startOffset = match.capturedStart(1); // startOffset == 6
    int endOffset = match.capturedEnd(1); // endOffset == 9
    // ...
}
				

All of these functions have an overload taking a QString as a parameter in order to extract 命名 captured substrings. For instance:

QRegularExpression re("^(?<date>\\d\\d)/(?<month>\\d\\d)/(?<year>\\d\\d\\d\\d)$");
QRegularExpressionMatch match = re.match("08/12/1985");
if (match.hasMatch()) {
    QString date = match.captured("date"); // date == "08"
    QString month = match.captured("month"); // month == "12"
    QString year = match.captured("year"); // year == 1985
}
					
				

全局匹配

全局匹配 is useful to find all the occurrences of a given regular expression inside a subject string. Suppose that we want to extract all the words from a given string, where a word is a substring matching the pattern \w+ .

QRegularExpression::globalMatch 返回 QRegularExpressionMatchIterator , which is a Java-like forward iterator that can be used to iterate over the results. For instance:

QRegularExpression re("(\\w+)");
QRegularExpressionMatchIterator i = re.globalMatch("the quick fox");
				

由于它是像 Java 迭代器， QRegularExpressionMatchIterator will point immediately before the first result. Every result is returned as a QRegularExpressionMatch 对象。 hasNext () function will return true if there's at least one more result, and next () will return the next result and advance the iterator. Continuing from the previous example:

QStringList words;
while (i.hasNext()) {
    QRegularExpressionMatch match = i.next();
    QString word = match.captured(1);
    words << word;
}
// words contains "the", "quick", "fox"
				

还可以使用 peekNext () to get the next result without advancing the iterator.

It is also possible to simply use the result of QRegularExpression::globalMatch in a range-based for loop, for instance like this:

// using a raw string literal, R"(raw_characters)", to be able to use "\w"
// without having to escape the backslash as "\\w"
QRegularExpression re(R"(\w+)");
QString subject("the quick fox");
for (const QRegularExpressionMatch &match : re.globalMatch(subject)) {
    // ...
}
				

It is possible to pass a starting offset and one or more match options to the globalMatch () function, exactly like normal matching with match ().

部分匹配

A partial match is obtained when the end of the subject string is reached, but more characters are needed to successfully complete the match. Note that a partial match is usually much more inefficient than a normal match because many optimizations of the matching algorithm cannot be employed.

A partial match must be explicitly requested by specifying a match type of PartialPreferCompleteMatch or PartialPreferFirstMatch 当调用 QRegularExpression::match or QRegularExpression::globalMatch . If a partial match is found, then calling the hasMatch () function on the QRegularExpressionMatch object returned by match () 会返回 false ，但 hasPartialMatch () 会返回 true .

When a partial match is found, no captured substrings are returned, and the (implicit) capturing group 0 corresponding to the whole match captures the partially matched substring of the subject string.

Note that asking for a partial match can still lead to a complete match, if one is found; in this case, hasMatch () 会返回 true and hasPartialMatch () false . It never happens that a QRegularExpressionMatch reports both a partial and a complete match.

Partial matching is mainly useful in two scenarios: validating user input in real time and incremental/multi-segment matching.

Validating user input

Suppose that we would like the user to input a date in a specific format, for instance "MMM dd, yyyy". We can check the input validity with a pattern like:

^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d\d?, \d\d\d\d$

(This pattern doesn't catch invalid days, but let's keep it for the example's purposes).

We would like to validate the input with this regular expression while the user is typing it, so that we can report an error in the input as soon as it is committed (for instance, the user typed the wrong key). In order to do so we must distinguish three cases:

• the input cannot possibly match the regular expression;
• the input does match the regular expression;
• the input does not match the regular expression right now, but it will if more characters will be added to it.

Note that these three cases represent exactly the possible states of a QValidator (see the QValidator::State enum).

In particular, in the last case we want the regular expression engine to report a partial match: we are successfully matching the pattern against the subject string but the matching cannot continue because the end of the subject is encountered. Notice, however, that the matching algorithm should continue and try all possibilities, and in case a complete (non-partial) match is found, then this one should be reported, and the input string accepted as fully valid.

This behavior is implemented by the PartialPreferCompleteMatch match type. For instance:

QString pattern("^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \\d\\d?, \\d\\d\\d\\d$");
QRegularExpression re(pattern);
QString input("Jan 21,");
QRegularExpressionMatch match = re.match(input, 0, QRegularExpression::PartialPreferCompleteMatch);
bool hasMatch = match.hasMatch(); // false
bool hasPartialMatch = match.hasPartialMatch(); // true
				

If matching the same regular expression against the subject string leads to a complete match, it is reported as usual:

QString input("Dec 8, 1985");
QRegularExpressionMatch match = re.match(input, 0, QRegularExpression::PartialPreferCompleteMatch);
bool hasMatch = match.hasMatch(); // true
bool hasPartialMatch = match.hasPartialMatch(); // false
				

Another example with a different pattern, showing the behavior of preferring a complete match over a partial one:

QRegularExpression re("abc\\w+X|def");
QRegularExpressionMatch match = re.match("abcdef", 0, QRegularExpression::PartialPreferCompleteMatch);
bool hasMatch = match.hasMatch(); // true
bool hasPartialMatch = match.hasPartialMatch(); // false
QString captured = match.captured(0); // captured == "def"
				

在此情况下，子模式 abc\\w+X partially matches the subject string; however, the subpattern def matches the subject string completely, and therefore a complete match is reported.

If multiple partial matches are found when matching (but no complete match), then the QRegularExpressionMatch object will report the first one that is found. For instance:

QRegularExpression re("abc\\w+X|defY");
QRegularExpressionMatch match = re.match("abcdef", 0, QRegularExpression::PartialPreferCompleteMatch);
bool hasMatch = match.hasMatch(); // false
bool hasPartialMatch = match.hasPartialMatch(); // true
QString captured = match.captured(0); // captured == "abcdef"
				

增量/多段匹配

Incremental matching is another use case of partial matching. Suppose that we want to find the occurrences of a regular expression inside a large text (that is, substrings matching the regular expression). In order to do so we would like to "feed" the large text to the regular expression engines in smaller chunks. The obvious problem is what happens if the substring that matches the regular expression spans across two or more chunks.

In this case, the regular expression engine should report a partial match, so that we can match again adding new data and (eventually) get a complete match. This implies that the regular expression engine may assume that there are other characters beyond the end of the subject string. This is not to be taken literally – the engine will never try to access any character after the last one in the subject.

QRegularExpression implements this behavior when using the PartialPreferFirstMatch match type. This match type reports a partial match as soon as it is found, and other match alternatives are not tried (even if they could lead to a complete match). For instance:

QRegularExpression re("abc|ab");
QRegularExpressionMatch match = re.match("ab", 0, QRegularExpression::PartialPreferFirstMatch);
bool hasMatch = match.hasMatch(); // false
bool hasPartialMatch = match.hasPartialMatch(); // true
				

This happens because when matching the first branch of the alternation operator a partial match is found, and therefore matching stops, without trying the second branch. Another example:

QRegularExpression re("abc(def)?");
QRegularExpressionMatch match = re.match("abc", 0, QRegularExpression::PartialPreferFirstMatch);
bool hasMatch = match.hasMatch(); // false
bool hasPartialMatch = match.hasPartialMatch(); // true
				

This shows what could seem a counterintuitive behavior of quantifiers: since ? is greedy, then the engine tries first to continue the match after having matched "abc" ; but then the matching reaches the end of the subject string, and therefore a partial match is reported. This is even more surprising in the following example:

QRegularExpression re("(abc)*");
QRegularExpressionMatch match = re.match("abc", 0, QRegularExpression::PartialPreferFirstMatch);
bool hasMatch = match.hasMatch(); // false
bool hasPartialMatch = match.hasPartialMatch(); // true
				

It's easy to understand this behavior if we remember that the engine expects the subject string to be only a substring of the whole text we're looking for a match into (that is, how we said before, that the engine assumes that there are other characters beyond the end of the subject string).

由于 * quantifier is greedy, then reporting a complete match could be an error, because after the current subject "abc" there may be other occurrences of "abc" . For instance, the complete text could have been "abcabcX", and therefore the right match to report (in the complete text) would have been "abcabc" ; by matching only against the leading "abc" we instead get a partial match.

错误处理

It is possible for a QRegularExpression object to be invalid because of syntax errors in the pattern string. The isValid () function will return true if the regular expression is valid, or false otherwise:

QRegularExpression invalidRe("(unmatched|parenthesis");
bool isValid = invalidRe.isValid(); // false
				

You can get more information about the specific error by calling the errorString () 函数；再者， patternErrorOffset () function will return the offset inside the pattern string

QRegularExpression invalidRe("(unmatched|parenthesis");
if (!invalidRe.isValid()) {
    QString errorString = invalidRe.errorString(); // errorString == "missing )"
    int errorOffset = invalidRe.patternErrorOffset(); // errorOffset == 22
    // ...
}
				

If a match is attempted with an invalid QRegularExpression, then the returned QRegularExpressionMatch object will be invalid as well (that is, its isValid () function will return false). The same applies for attempting a global match.

不支持 Perl 兼容正则表达式特征

QRegularExpression does not support all the features available in Perl-compatible regular expressions. The most notable one is the fact that duplicated names for capturing groups are not supported, and using them can lead to undefined behavior.

这在未来 Qt 版本可能改变。

使用 QRegularExpression 调试代码

QRegularExpression internally uses a just in time compiler (JIT) to optimize the execution of the matching algorithm. The JIT makes extensive usage of self-modifying code, which can lead debugging tools such as Valgrind to crash. You must enable all checks for self-modifying code if you want to debug programs using QRegularExpression (for instance, Valgrind's --smc-check command line option). The downside of enabling such checks is that your program will run considerably slower.

To avoid that, the JIT is disabled by default if you compile Qt in debug mode. It is possible to override the default and enable or disable the JIT usage (both in debug or release mode) by setting the QT_ENABLE_REGEXP_JIT environment variable to a non-zero or zero value respectively.

另请参阅 QRegularExpressionMatch and QRegularExpressionMatchIterator .

成员类型文档编制

enum QRegularExpression:: MatchOption
flags QRegularExpression:: MatchOptions

The MatchOptions type is a typedef for QFlags <MatchOption>. It stores an OR combination of MatchOption values.

enum QRegularExpression:: MatchType

The MatchType enum defines the type of the match that should be attempted against the subject string.

enum QRegularExpression:: PatternOption
flags QRegularExpression:: PatternOptions

The PatternOption enum defines modifiers to the way the pattern string should be interpreted, and therefore the way the pattern matches against a subject string.

The PatternOptions type is a typedef for QFlags <PatternOption>. It stores an OR combination of PatternOption values.

[since 6.0] enum QRegularExpression:: WildcardConversionOption
flags QRegularExpression:: WildcardConversionOptions

The WildcardConversionOption enum defines modifiers to the way a wildcard glob pattern gets converted to a regular expression pattern.

This enum was introduced in Qt 6.0.

The WildcardConversionOptions type is a typedef for QFlags <WildcardConversionOption>. It stores an OR combination of WildcardConversionOption values.

另请参阅 QRegularExpression::wildcardToRegularExpression .

成员函数文档编制

QRegularExpression:: QRegularExpression ()

Constructs a QRegularExpression object with an empty pattern and no pattern options.

另请参阅 setPattern () 和 setPatternOptions ().

[explicit] QRegularExpression:: QRegularExpression (const QString & pattern , QRegularExpression::PatternOptions options = NoPatternOption)

Constructs a QRegularExpression object using the given pattern as pattern and the options as the pattern options.

另请参阅 setPattern () 和 setPatternOptions ().

[noexcept] QRegularExpression:: QRegularExpression (const QRegularExpression & re )

Constructs a QRegularExpression object as a copy of re .

另请参阅 operator= ().

[noexcept, since 6.1] QRegularExpression:: QRegularExpression ( QRegularExpression && re )

Constructs a QRegularExpression object by moving from re .

Note that a moved-from QRegularExpression can only be destroyed or assigned to. The effect of calling other functions than the destructor or one of the assignment operators is undefined.

该函数在 Qt 6.1 引入。

另请参阅 operator= ().

[noexcept] QRegularExpression:: ~QRegularExpression ()

销毁 QRegularExpression 对象。

[static] QString QRegularExpression:: anchoredPattern ( QStringView 表达式 )

返回 表达式 被包裹介于 \A and \z 锚点 (用于准确匹配)。

[static] QString QRegularExpression:: anchoredPattern (const QString & 表达式 )

这是重载函数。

int QRegularExpression:: captureCount () const

返回模式字符串内的捕获组数，或 -1 若正则表达式无效。

注意： 隐式捕获组 0 not 包括在返回数中。

另请参阅 isValid ().

QString QRegularExpression:: errorString () const

Returns a textual description of the error found when checking the validity of the regular expression, or "no error" if no error was found.

另请参阅 isValid () 和 patternErrorOffset ().

[static] QString QRegularExpression:: escape ( QStringView str )

Escapes all characters of str so that they no longer have any special meaning when used as a regular expression pattern string, and returns the escaped string. For instance:

QString escaped = QRegularExpression::escape("a(x) = f(x) + g(x)");
// escaped == "a\\(x\\)\\ \\=\\ f\\(x\\)\\ \\+\\ g\\(x\\)"
				

This is very convenient in order to build patterns from arbitrary strings:

QString pattern = "(" + QRegularExpression::escape(name) +
                  "|" + QRegularExpression::escape(nickname) + ")";
QRegularExpression re(pattern);
				

注意： This function implements Perl's quotemeta algorithm and escapes with a backslash all characters in str , except for the characters in the [A-Z] , [a-z] and [0-9] ranges, as well as the underscore ( _ ) character. The only difference with Perl is that a literal NUL inside str is escaped with the sequence "\\0" (backslash + '0' ), instead of "\\\0" (backslash + NUL ).

[static] QString QRegularExpression:: escape (const QString & str )

这是重载函数。

[static, since 6.0] QRegularExpression QRegularExpression:: fromWildcard ( QStringView pattern , Qt::CaseSensitivity cs = Qt::CaseInsensitive, QRegularExpression::WildcardConversionOptions options = DefaultWildcardConversion)

返回正则表达式为全局模式 pattern 。正则表达式将区分大小写若 cs is Qt::CaseSensitive , and converted according to options .

相当于

auto reOptions = cs == Qt::CaseSensitive ? QRegularExpression::NoPatternOption :
                                           QRegularExpression::CaseInsensitiveOption;
return QRegularExpression(wildcardToRegularExpression(str, options), reOptions);
				

该函数在 Qt 6.0 引入。

QRegularExpressionMatchIterator QRegularExpression:: globalMatch (const QString & subject , qsizetype offset = 0, QRegularExpression::MatchType matchType = NormalMatch, QRegularExpression::MatchOptions matchOptions = NoMatchOption) const

试图履行正则表达式全局匹配针对给定 subject 字符串，始于位置 offset 在主题中，使用匹配类型 matchType 且尊重给定 matchOptions .

返回的 QRegularExpressionMatchIterator 位于第 1 匹配结果 (若有的话) 之前。

另请参阅 QRegularExpressionMatchIterator and 全局匹配 .

[since 6.5] QRegularExpressionMatchIterator QRegularExpression:: globalMatchView ( QStringView subjectView , qsizetype offset = 0, QRegularExpression::MatchType matchType = NormalMatch, QRegularExpression::MatchOptions matchOptions = NoMatchOption) const

这是重载函数。

试图履行正则表达式全局匹配针对给定 subjectView 字符串视图，始于位置 offset 在主题中，使用匹配类型 matchType 且尊重给定 matchOptions .

返回的 QRegularExpressionMatchIterator 位于第 1 匹配结果 (若有的话) 之前。

注意： The data referenced by subjectView must remain valid as long as there are QRegularExpressionMatchIterator or QRegularExpressionMatch objects using it.

该函数在 Qt 6.5 引入。

另请参阅 QRegularExpressionMatchIterator and 全局匹配 .

bool QRegularExpression:: isValid () const

返回 true if the regular expression is a valid regular expression (that is, it contains no syntax errors, etc.), or false otherwise. Use errorString () to obtain a textual description of the error.

另请参阅 errorString () 和 patternErrorOffset ().

QRegularExpressionMatch QRegularExpression:: match (const QString & subject , qsizetype offset = 0, QRegularExpression::MatchType matchType = NormalMatch, QRegularExpression::MatchOptions matchOptions = NoMatchOption) const

试图匹配正则表达式针对给定 subject 字符串，始于位置 offset 在主题中，使用匹配类型 matchType 且尊重给定 matchOptions .

返回的 QRegularExpressionMatch 对象包含匹配结果。

另请参阅 QRegularExpressionMatch and 正常匹配 .

[since 6.5] QRegularExpressionMatch QRegularExpression:: matchView ( QStringView subjectView , qsizetype offset = 0, QRegularExpression::MatchType matchType = NormalMatch, QRegularExpression::MatchOptions matchOptions = NoMatchOption) const

这是重载函数。

试图匹配正则表达式针对给定 subjectView 字符串视图，始于位置 offset 在主题中，使用匹配类型 matchType 且尊重给定 matchOptions .

返回的 QRegularExpressionMatch 对象包含匹配结果。

注意： The data referenced by subjectView must remain valid as long as there are QRegularExpressionMatch objects using it.

该函数在 Qt 6.5 引入。

另请参阅 QRegularExpressionMatch and 正常匹配 .

QStringList QRegularExpression:: namedCaptureGroups () const

Returns a list of captureCount () + 1 elements, containing the names of the named capturing groups in the pattern string. The list is sorted such that the element of the list at position i is the name of the i -th capturing group, if it has a name, or an empty string if that capturing group is unnamed.

For instance, given the regular expression

    (?<day>\d\d)-(?<month>\d\d)-(?<year>\d\d\d\d) (\w+) (?<name>\w+)
				

namedCaptureGroups() will return the following list:

    ("", "day", "month", "year", "", "name")
				

which corresponds to the fact that the capturing group #0 (corresponding to the whole match) has no name, the capturing group #1 has name "day", the capturing group #2 has name "month", etc.

If the regular expression is not valid, returns an empty list.

另请参阅 isValid (), QRegularExpressionMatch::captured ()，和 QString::isEmpty ().

void QRegularExpression:: optimize () const

Compiles the pattern immediately, including JIT compiling it (if the JIT is enabled) for optimization.

另请参阅 isValid () 和 使用 QRegularExpression 调试代码 .

QString QRegularExpression:: pattern () const

返回正则表达式的模式字符串。

另请参阅 setPattern () 和 patternOptions ().

qsizetype QRegularExpression:: patternErrorOffset () const

Returns the offset, inside the pattern string, at which an error was found when checking the validity of the regular expression. If no error was found, then -1 is returned.

另请参阅 pattern (), isValid ()，和 errorString ().

QRegularExpression::PatternOptions QRegularExpression:: patternOptions () const

Returns the pattern options for the regular expression.

另请参阅 setPatternOptions () 和 pattern ().

void QRegularExpression:: setPattern (const QString & pattern )

Sets the pattern string of the regular expression to pattern . The pattern options are left unchanged.

另请参阅 pattern () 和 setPatternOptions ().

void QRegularExpression:: setPatternOptions ( QRegularExpression::PatternOptions options )

设置给定 options as the pattern options of the regular expression. The pattern string is left unchanged.

另请参阅 patternOptions () 和 setPattern ().

[noexcept] void QRegularExpression:: swap ( QRegularExpression & other )

Swaps the regular expression other with this regular expression. This operation is very fast and never fails.

[static] QString QRegularExpression:: wildcardToRegularExpression ( QStringView pattern , QRegularExpression::WildcardConversionOptions options = DefaultWildcardConversion)

Returns a regular expression representation of the given glob pattern .

There are two transformations possible, one that targets file path globbing, and another one which is more generic.

By default, the transformation is targeting file path globbing, which means in particular that path separators receive special treatment. This implies that it is not just a basic translation from "*" to ".*" and similar.

QString wildcard = QRegularExpression::wildcardToRegularExpression("*.jpeg");
// Will match files with names like:
//    foo.jpeg
//    f_o_o.jpeg
//    föö.jpeg
				

The more generic globbing transformation is available by passing NonPathWildcardConversion in the conversion options .

This implementation follows closely the definition of wildcard for glob patterns:

注意： For historical reasons, a backslash (\) character is not an escape char in this context. In order to match one of the special characters, place it in square brackets (for example, [?] ).

More information about the implementation can be found in:

• The Wikipedia Glob article
• man 7 glob

By default, the returned regular expression is fully anchored. In other words, there is no need of calling anchoredPattern () again on the result. To get a regular expression that is not anchored, pass UnanchoredWildcardConversion in the conversion options .

另请参阅 escape ().

[static] QString QRegularExpression:: wildcardToRegularExpression (const QString & pattern , QRegularExpression::WildcardConversionOptions options = DefaultWildcardConversion)

这是重载函数。

bool QRegularExpression:: operator!= (const QRegularExpression & re ) const

返回 true 若正则表达式不同于 re ，或 false 否则。

另请参阅 operator== ().

[noexcept] QRegularExpression &QRegularExpression:: operator= (const QRegularExpression & re )

Assigns the regular expression re to this object, and returns a reference to the copy. Both the pattern and the pattern options are copied.

[noexcept] QRegularExpression &QRegularExpression:: operator= ( QRegularExpression && re )

Move-assigns the regular expression re to this object, and returns a reference to the result. Both the pattern and the pattern options are copied.

Note that a moved-from QRegularExpression can only be destroyed or assigned to. The effect of calling other functions than the destructor or one of the assignment operators is undefined.

bool QRegularExpression:: operator== (const QRegularExpression & re ) const

返回 true 若正则表达式等于 re ，或 false 否则。两 QRegularExpression objects are equal if they have the same pattern string and the same pattern options.

另请参阅 operator!= ().

相关非成员

[noexcept] size_t qHash (const QRegularExpression & key , size_t seed = 0)

返回哈希值为 key ，使用 seed 做计算种子。

QDataStream & operator<< ( QDataStream & out , const QRegularExpression & re )

写入正则表达式 re 到流 out .

另请参阅 序列化 Qt 数据类型 .

QDebug operator<< ( QDebug debug , const QRegularExpression & re )

写入正则表达式 re 到 debug 对象 debug 为调试目的。

另请参阅 调试技术 .

QDebug operator<< ( QDebug debug , QRegularExpression::PatternOptions patternOptions )

写入模式选项 patternOptions 到 debug 对象 debug 为调试目的。

另请参阅 调试技术 .

QDataStream & operator>> ( QDataStream & in , QRegularExpression & re )

读取正则表达式从流 in into re .

另请参阅 序列化 Qt 数据类型 .