diff options
| author | Giuseppe D'Angelo <giuseppe.dangelo@kdab.com> | 2019-05-13 14:33:57 +0200 |
|---|---|---|
| committer | Giuseppe D'Angelo <giuseppe.dangelo@kdab.com> | 2019-05-19 14:24:52 +0200 |
| commit | 8845caa057cfcf54f7d46621adb3393c13747ffb (patch) | |
| tree | 5aebf32e9d1abe6b4e93067c83d6e3204f944fd1 /src/corelib/tools/qbytearray.cpp | |
| parent | c7167509acdba006fe6da4ec1866acb214c18197 (diff) | |
QCharRef/QByteRef: warn when triggering the resizing operator= behavior
The whole reason of QCharRef/QByteRef existence is to have a magic
operator=. This operator= delays the actual detach up to
the moment something is written into the Ref, thus avoiding
spurious detaches to the underlying string/byte array.
operator= has also an extra feature, it allows this code to
succeed:
QString s("abc");
s[10] = 'z';
assert(s == "abc z");
This last behavior is *extremely* surprising.
The problem with all of this is that this extra convenience is
outweighted by the massive pessimization in the codegen for
operator[]; by the maintenance burden (QChar APIs need to be
mirrored in QCharRef, etc.), and, for the automatic resize, by the
fact that it's an super-niche use case.
Cherry on top, std::basic_string does not do that, and no Qt or std
container does that. In other words: any other container-like class
exhibits UB for out of bounds access.
We can't just go and change behavior, though. This is something
coming all the way back from Qt 2 (maybe even Qt 1), which means we
can't deprecate it at short notice.
This patch simply adds a warning in debug builds in case the special
resizing behavior is triggered. While at it, removes some code
duplication in QByteRef.
[ChangeLog][QtCore][QString] The behavior of operator[] to allow
implicit resizing of the string has been deprecated, and will be
removed in a future version of Qt.
[ChangeLog][QtCore][QByteArray] The behavior of operator[] to allow
implicit detaching and resizing of the byte array has been
deprecated, and will be removed in a future version of Qt.
Change-Id: I3b5c5191167f12a606bcf6e513e6f304b220d675
Reviewed-by: Marc Mutz <marc.mutz@kdab.com>
Diffstat (limited to 'src/corelib/tools/qbytearray.cpp')
| -rw-r--r-- | src/corelib/tools/qbytearray.cpp | 34 |
1 files changed, 34 insertions, 0 deletions
diff --git a/src/corelib/tools/qbytearray.cpp b/src/corelib/tools/qbytearray.cpp index 720a91af492..c89fb078f72 100644 --- a/src/corelib/tools/qbytearray.cpp +++ b/src/corelib/tools/qbytearray.cpp @@ -1537,6 +1537,12 @@ QByteArray &QByteArray::operator=(const char *str) will apply to the character in the QByteArray from which you got the reference. + \note Before Qt 5.14 it was possible to use this operator to access + a character at an out-of-bounds position in the byte array, and + then assign to such position, causing the byte array to be + automatically resized. This behavior is deprecated, and will be + changed in a future version of Qt. + \sa at() */ @@ -5054,4 +5060,32 @@ QByteArray QByteArray::toPercentEncoding(const QByteArray &exclude, const QByteA \sa QStringLiteral */ +namespace QtPrivate { +namespace DeprecatedRefClassBehavior { +void warn(EmittingClass c) +{ + const char *emittingClassName = nullptr; + const char *containerClassName = nullptr; + switch (c) { + case EmittingClass::QByteRef: + emittingClassName = "QByteRef"; + containerClassName = "QByteArray"; + break; + case EmittingClass::QCharRef: + emittingClassName = "QCharRef"; + containerClassName = "QString"; + break; + } + + qWarning("Using %s with an index pointing outside" + " the valid range of a %s." + " The corresponding behavior is deprecated, and will be changed" + " in a future version of Qt.", + emittingClassName, + containerClassName); +} +} // namespace DeprecatedRefClassBehavior +} // namespace QtPrivate + + QT_END_NAMESPACE |