2 files changed, 42 insertions, 17 deletions

diff --git a/src/corelib/text/qbytearrayview.h b/src/corelib/text/qbytearrayview.h
index 81db7029de..079f888f4b 100644
--- a/src/corelib/text/qbytearrayview.h
+++ b/src/corelib/text/qbytearrayview.h
@@ -94,6 +94,9 @@ struct IsContainerCompatibleWithQByteArrayView<T, std::enable_if_t<
                 // This needs to be treated specially due to the empty vs null distinction
                 std::negation<std::is_same<std::decay_t<T>, QByteArray>>,
 
+                // We handle array literals specially for source compat reasons
+                std::negation<std::is_array<T>>,
+
                 // Don't make an accidental copy constructor
                 std::negation<std::is_same<std::decay_t<T>, QByteArrayView>>>>> : std::true_type {};
 
@@ -147,10 +150,11 @@ private:
         return qsizetype(std::size(c));
     }
 
-    template <typename Char, size_t N>
-    static constexpr qsizetype lengthHelperContainer(const Char (&)[N]) noexcept
+    static constexpr qsizetype lengthHelperCharArray(const char *data, size_t size) noexcept
     {
-        return qsizetype(N - 1);
+        const auto it = std::char_traits<char>::find(data, size, '\0');
+        const auto end = it ? it : std::next(data, size);
+        return qsizetype(std::distance(data, end));
     }
 
     template <typename Byte>
@@ -175,9 +179,6 @@ public:
         : QByteArrayView(first, last - first) {}
 
 #ifdef Q_QDOC
-    template <typename Byte, size_t N>
-    constexpr QByteArrayView(const Byte (&array)[N]) noexcept;
-
     template <typename Byte>
     constexpr QByteArrayView(const Byte *data) noexcept;
 #else
@@ -198,6 +199,13 @@ public:
     template <typename Container, if_compatible_container<Container> = true>
     constexpr QByteArrayView(const Container &c) noexcept
         : QByteArrayView(std::data(c), lengthHelperContainer(c)) {}
+    template <size_t Size>
+    constexpr QByteArrayView(const char (&data)[Size]) noexcept
+        : QByteArrayView(data, lengthHelperCharArray(data, Size)) {}
+
+    template <typename Byte, size_t Size, if_compatible_byte<Byte> = true>
+    [[nodiscard]] constexpr static QByteArrayView fromArray(const Byte (&data)[Size]) noexcept
+    { return QByteArrayView(data, Size); }
 
     [[nodiscard]] inline QByteArray toByteArray() const; // defined in qbytearray.h
 
diff --git a/src/corelib/text/qbytearrayview.qdoc b/src/corelib/text/qbytearrayview.qdoc
index f386881fa2..839a956249 100644
--- a/src/corelib/text/qbytearrayview.qdoc
+++ b/src/corelib/text/qbytearrayview.qdoc
@@ -256,23 +256,25 @@
 */
 
 /*!
-    \fn template <typename Byte, size_t N> QByteArrayView::QByteArrayView(const Byte (&data)[N])
+    \fn template <size_t Size> QByteArrayView(const char (&data)[Size])
 
-    Constructs a byte array view on the array of bytes \a data.
-    The length is set to \c{N-1}, excluding the trailing \{Byte(0)}.
-    If you need the full array, use the constructor from pointer and
-    size instead:
-
-    \snippet code/src_corelib_text_qbytearrayview.cpp 2
+    Constructs a byte array view on the char array \a data.
+    The view covers the array until the first \c{'\0'} is encountered,
+    or \c Size, whichever comes first.
+    If you need the full array, use fromArray() instead.
 
     \a data must remain valid for the lifetime of this byte array view
     object.
 
-    This constructor only participates in overload resolution if \a
-    data is an actual array and \c Byte is a compatible byte
-    type.
+    \note This constructor is only available for char array literals.
+    The reasoning behind that is for compatibility with C-libraries
+    which predefine "large-enough" arrays, but only use some of the
+    preallocated space. To support this in an intuitive way in an
+    implicit constructor overload, we need to stop at the first
+    \c{char(0)}. This is logical for a char array, but not
+    for a \c{std::byte} array.
 
-    \sa {Compatible Byte Types}
+    \sa fromArray
 */
 
 /*!
@@ -300,6 +302,21 @@
 */
 
 /*!
+    \fn template <typename Byte, size_t Size> static QByteArrayView QByteArrayView::fromArray(Byte (&data)[Size])
+
+    Constructs a byte array view on the array literal \a data. The view covers the full
+    array. That includes the trailing null-terminator of \c{char} array literals.
+    If you don't want the null-terminator included in the view, you can chop() it off
+    when you are certain it is at the end. Alternatively you can use the constructor
+    overload taking a char array literal which will create a view up to, but not including,
+    the first null-terminator in the data.
+
+    This function will work with any array literal of a compatible byte type.
+
+    \sa {Compatible Byte Types}, QByteArrayView
+*/
+
+/*!
     \fn QByteArray QByteArrayView::toByteArray() const
 
     Returns a deep copy of this byte array view's data as a QByteArray.