diff --git a/src/corelib/text/qbytearrayview.h b/src/corelib/text/qbytearrayview.h
index 4934777fb21..568b69dbb3f 100644
--- a/src/corelib/text/qbytearrayview.h
+++ b/src/corelib/text/qbytearrayview.h
@@ -176,6 +176,10 @@ public:
     constexpr QByteArrayView(const char (&data)[Size]) noexcept
         : QByteArrayView(data, lengthHelperCharArray(data, Size)) {}
 
+    template <typename Byte, if_compatible_byte<Byte> = true>
+    constexpr QByteArrayView(const Byte (&data)[]) noexcept
+        : QByteArrayView(&*data) {} // decay to pointer
+
 #ifdef Q_QDOC
     template <typename Byte, size_t Size>
 #else
diff --git a/src/corelib/text/qbytearrayview.qdoc b/src/corelib/text/qbytearrayview.qdoc
index bc9df292769..7d9a455b9fd 100644
--- a/src/corelib/text/qbytearrayview.qdoc
+++ b/src/corelib/text/qbytearrayview.qdoc
@@ -246,6 +246,21 @@
     \sa {Compatible Byte Types}
 */
 
+/*!
+    \fn template <typename Byte, QByteArrayView::if_compatible_byte<Byte>> QByteArrayView::QByteArrayView(const Byte (&data)[])
+    \since 6.9
+
+    Constructs a byte array view on \a data, an array of unknown size. The
+    length is determined by scanning for the first \c{Byte(0)}.
+
+    \a data must remain valid for the lifetime of this byte array view object.
+
+    This constructor only participates in overload resolution if \c Byte is a
+    compatible byte type.
+
+    \sa {Compatible Byte Types}
+*/
+
 /*!
     \fn template <size_t Size> QByteArrayView::QByteArrayView(const char (&data)[Size])
 
@@ -264,6 +279,9 @@
     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.
+    It is, however, inconsistent with the corresponding pointer (\c{Byte*}) and
+    unknown-length-array (\c{Byte[]}) constructors, and so might change in a
+    future version of Qt.
 
     \sa fromArray
 */
diff --git a/tests/auto/corelib/text/qbytearrayview/CMakeLists.txt b/tests/auto/corelib/text/qbytearrayview/CMakeLists.txt
index 8922ae22677..3a57f87ea87 100644
--- a/tests/auto/corelib/text/qbytearrayview/CMakeLists.txt
+++ b/tests/auto/corelib/text/qbytearrayview/CMakeLists.txt
@@ -14,6 +14,8 @@ endif()
 qt_internal_add_test(tst_qbytearrayview
     SOURCES
         tst_qbytearrayview.cpp
+        ../qstringview/arrays_of_unknown_bounds.cpp
+        ../qstringview/arrays_of_unknown_bounds.h
 )
 
 if(QT_FEATURE_sanitize_undefined)
diff --git a/tests/auto/corelib/text/qbytearrayview/tst_qbytearrayview.cpp b/tests/auto/corelib/text/qbytearrayview/tst_qbytearrayview.cpp
index a65f3ffc307..0155a1aeb9e 100644
--- a/tests/auto/corelib/text/qbytearrayview/tst_qbytearrayview.cpp
+++ b/tests/auto/corelib/text/qbytearrayview/tst_qbytearrayview.cpp
@@ -1,6 +1,8 @@
 // Copyright (C) 2020 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
+#include "../qstringview/arrays_of_unknown_bounds.h"
+
 #include <QByteArrayView>
 
 #include <QTest>
@@ -20,24 +22,43 @@ static_assert(!CanConvert<const char16_t*>);
 static_assert(!CanConvert<char>);
 static_assert(CanConvert<char[1]>);
 static_assert(CanConvert<const char[1]>);
+#ifndef Q_OS_INTEGRITY // ¯\_(ツ)_/¯
+static_assert(CanConvert<char[]>);
+static_assert(CanConvert<const char[]>);
+#endif
 static_assert(CanConvert<char*>);
 static_assert(CanConvert<const char*>);
 
 static_assert(!CanConvert<uchar>);
+// sic! policy decision:
 static_assert(!CanConvert<uchar[1]>);
 static_assert(!CanConvert<const uchar[1]>);
+#ifndef Q_OS_INTEGRITY // ¯\_(ツ)_/¯
+static_assert(CanConvert<uchar[]>);
+static_assert(CanConvert<const uchar[]>);
+#endif
 static_assert(CanConvert<uchar*>);
 static_assert(CanConvert<const uchar*>);
 
 static_assert(!CanConvert<signed char>);
+// sic! policy decision:
 static_assert(!CanConvert<signed char[1]>);
 static_assert(!CanConvert<const signed char[1]>);
+#ifndef Q_OS_INTEGRITY // ¯\_(ツ)_/¯
+static_assert(CanConvert<signed char[]>);
+static_assert(CanConvert<const signed char[]>);
+#endif
 static_assert(CanConvert<signed char*>);
 static_assert(CanConvert<const signed char*>);
 
 static_assert(!CanConvert<std::byte>);
+// sic! policy decision:
 static_assert(!CanConvert<std::byte[1]>);
 static_assert(!CanConvert<const std::byte[1]>);
+#ifndef Q_OS_INTEGRITY // ¯\_(ツ)_/¯
+static_assert(CanConvert<std::byte[]>);
+static_assert(CanConvert<const std::byte[]>);
+#endif
 static_assert(CanConvert<std::byte*>);
 static_assert(CanConvert<const std::byte*>);
 
@@ -108,6 +129,13 @@ private slots:
     void basics() const;
     void literals() const;
     void fromArray() const;
+    void fromArrayWithUnknownSize() const
+    {
+        from_array_of_unknown_size<QByteArrayView>();
+        from_uarray_of_unknown_size<QByteArrayView>();
+        from_sarray_of_unknown_size<QByteArrayView>();
+        from_byte_array_of_unknown_size<QByteArrayView>();
+    }
     void literalsWithInternalNulls() const;
     void at() const;
 
diff --git a/tests/auto/corelib/text/qstringview/arrays_of_unknown_bounds.cpp b/tests/auto/corelib/text/qstringview/arrays_of_unknown_bounds.cpp
index a8697464fb1..172015958f5 100644
--- a/tests/auto/corelib/text/qstringview/arrays_of_unknown_bounds.cpp
+++ b/tests/auto/corelib/text/qstringview/arrays_of_unknown_bounds.cpp
@@ -11,6 +11,18 @@ const char8_t u8string_array[] = u8"abc\0def";
 const int u8string_array_size = 3;
 #endif
 
+const uchar ustring_array[] = "abc\0def";
+const int ustring_array_size = 3;
+
+const signed char sstring_array[] = "abc\0def";
+const int sstring_array_size = 3;
+
+const std::byte byte_array[] = {
+    std::byte{'a'}, std::byte{'b'}, std::byte{'c'}, std::byte{},
+    std::byte{'d'}, std::byte{'e'}, std::byte{'f'}
+};
+const int byte_array_size = 3;
+
 const char16_t u16string_array[] = u"abc\0def";
 const int u16string_array_size = 3;
 
diff --git a/tests/auto/corelib/text/qstringview/arrays_of_unknown_bounds.h b/tests/auto/corelib/text/qstringview/arrays_of_unknown_bounds.h
index 863b58a1faf..d47c2437c6b 100644
--- a/tests/auto/corelib/text/qstringview/arrays_of_unknown_bounds.h
+++ b/tests/auto/corelib/text/qstringview/arrays_of_unknown_bounds.h
@@ -13,6 +13,15 @@ extern const char8_t u8string_array[];
 extern const int u8string_array_size;
 #endif
 
+extern const uchar ustring_array[];
+extern const int ustring_array_size;
+
+extern const signed char sstring_array[];
+extern const int sstring_array_size;
+
+extern const std::byte byte_array[];
+extern const int byte_array_size;
+
 extern const char16_t u16string_array[];
 extern const int u16string_array_size;
 
@@ -35,6 +44,27 @@ void from_u8array_of_unknown_size()
 }
 #endif
 
+template <typename StringView>
+void from_uarray_of_unknown_size()
+{
+    StringView bv = ustring_array;
+    QCOMPARE(bv.size(), ustring_array_size);
+}
+
+template <typename StringView>
+void from_sarray_of_unknown_size()
+{
+    StringView bv = sstring_array;
+    QCOMPARE(bv.size(), sstring_array_size);
+}
+
+template <typename StringView>
+void from_byte_array_of_unknown_size()
+{
+    StringView bv = byte_array;
+    QCOMPARE(bv.size(), byte_array_size);
+}
+
 template <typename StringView>
 void from_u16array_of_unknown_size()
 {