diff options
author | Giuseppe D'Angelo <giuseppe.dangelo@kdab.com> | 2020-11-04 15:19:26 +0100 |
---|---|---|
committer | Volker Hilsheimer <volker.hilsheimer@qt.io> | 2020-11-15 14:41:05 +0100 |
commit | 1869615fc959c70a334e666ebf95ff595a3d6e67 (patch) | |
tree | b3940f0c18afcabd3c531f172b040a47d34c55d0 /src/corelib/text/qchar.cpp | |
parent | 1aec96bffdce7e835aa33f01f44269594a955548 (diff) |
QChar: make construction from integral explicit
QChar should not be convertible from any integral type except from
char16_t, short and possibly char (since it's a direct superset).
David provided the perfect example:
if (str == 123) { ~~~ }
compiles, with 123 implicitly converted to QChar (str == "123"
was meant instead). But similarly one can construct other
scenarios where QString(123) gets accidentally used (instead of
QString::number(123)), like QString s; s += 123;.
Add a macro to revert to the implicit constructors, for backwards
compatibility.
The breaks are mostly in tests that "abuse" of integers (arithmetic,
etc.). Maybe it's time for user-defined literals for QChar/QString,
but that is left for another commit.
[ChangeLog][Potentially Source-Incompatible Changes][QChar] QChar
constructors from integral types are now by default explicit.
It is recommended to use explicit conversions, QLatin1Char,
QChar::fromUcs4 instead of implicit conversions. The old behavior
can be restored by defining the QT_IMPLICIT_QCHAR_CONSTRUCTION
macro.
Change-Id: I6175f6ab9bcf1956f6f97ab0c9d9d5aaf777296d
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
Diffstat (limited to 'src/corelib/text/qchar.cpp')
-rw-r--r-- | src/corelib/text/qchar.cpp | 53 |
1 files changed, 53 insertions, 0 deletions
diff --git a/src/corelib/text/qchar.cpp b/src/corelib/text/qchar.cpp index 14c82c7ee4..dcc36d18ce 100644 --- a/src/corelib/text/qchar.cpp +++ b/src/corelib/text/qchar.cpp @@ -158,6 +158,12 @@ QT_BEGIN_NAMESPACE to construct a QChar from an 8-bit \c char, and you will need to call toLatin1() to get the 8-bit value back. + Starting with Qt 6.0, most QChar constructors are \c explicit. This + is done to avoid dangerous mistakes when accidentally mixing + integral types and strings. You can opt-out (and make these + constructors implicit) by defining the macro \c + QT_IMPLICIT_QCHAR_CONSTRUCTION. + For more information see \l{http://www.unicode.org/ucd/}{"About the Unicode Character Database"}. @@ -2118,4 +2124,51 @@ static bool normalizationQuickCheckHelper(QString *str, QString::NormalizationFo return true; } +/*! + \macro QT_IMPLICIT_QCHAR_CONSTRUCTION + \since 6.0 + \relates QChar + + Defining this macro makes certain QChar constructors implicit + rather than explicit. This is done to enforce safe conversions: + + \badcode + + QString str = getString(); + if (str == 123) { + // Oops, meant str == "123". By default does not compile, + // *unless* this macro is defined, in which case, it's interpreted + // as `if (str == QChar(123))`, that is, `if (str == '{')`. + // Likely, not what we meant. + } + + \endcode + + This macro is provided to keep existing code working; it is + recommended to instead use explicit conversions and/or QLatin1Char. + For instance: + + \code + + QChar c1 = 'x'; // OK, unless QT_NO_CAST_FROM_ASCII is defined + QChar c2 = u'x'; // always OK, recommended + QChar c3 = QLatin1Char('x'); // always OK, recommended + + // from int to 1 UTF-16 code unit: must guarantee that the input is <= 0xFFFF + QChar c4 = 120; // compile error, unless QT_IMPLICIT_QCHAR_CONSTRUCTION is defined + QChar c5(120); // OK (direct initialization) + auto c6 = QChar(120); // ditto + + // from int/char32_t to 1/2 UTF-16 code units: + // 𝄞 'MUSICAL SYMBOL G CLEF' (U+1D11E) + auto c7 = QChar(0x1D11E); // compiles, but undefined behavior at runtime + auto c8 = QChar::fromUcs4(0x1D11E); // always OK + auto c9 = QChar::fromUcs4(U'\U0001D11E'); // always OK + // => use c8/c9 as QStringView objects + + \endcode + + \sa QLatin1Char, QChar::fromUcs4, QT_NO_CAST_FROM_ASCII +*/ + QT_END_NAMESPACE |