QT6 源（57）：阅读与注释 QLatin1String 这个类的源码，其存储了 c语言形式的字符串。非常类似于 QByteArray 类型。不知道为啥同时存在这两个类

于 2025-04-28 15:14:30 发布
阅读量126 收藏
点赞数 3
CC 4.0 BY-SA版权
分类专栏： # QT6.2.4源码阅读(一到四章） 文章标签： qt 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhangzhangkeji/article/details/147588303

（1）本类与重要的 QString 类定义于同一个头文件 qstring . h ：

/*
//QLatinlString 类为 US-ASCI/Latin-1 编码的字符串字面量提供了一个薄包装。
//定义QT NO_CAST FROM ASCI的应用程序(如QString文档中所解释的)
//无法访问QString的const char *API。
//为了提供一种有效指定拉丁文1字符串的方法，Qt提供了QLatinlstring。
//它只是const char *的一个非常薄的包装。
//总之可见，这个类不重要。更重要的是 QString

QString的许多成员函数都被重载以接受const char *而不是QString。
这包括复制构造函数、赋值运算符比较运算符以及各种其他函数，
如insert()、replace()和indexOf()。
这些函数通常经过优化，以避免为const char *数据构造一个QString对象。

定义 QT_NO_CAST_FROM ASCII(如 QString 文档中所解释)的应用程序无法访问
QString 的const char *API。
为了提供一种高效指定拉丁文1字符串的方法，Qt提供了 QLatin1String，
它只是const char*的一个非常薄的包装。


这段代码稍微长一些，但它提供的功能和第一个版本的代码完全相同，
而且比使用 QString::fromLatin1转换拉丁文1字符串更快。
由于QString(QLatin1String)构造函数，QLatin1String可以在任何需要使用QString的地方使用。

注:如果使用 QLatin1String参数调用的函数实际上没有重载以接受 QLatin1String,
那么隐式转换为 QString将触发内存分配，而这通常是你最初使用 QLatin1String想要避免的。
在这些情况下，使用 QStringLiteral可能是更好的选择。

*/

QT_BEGIN_NAMESPACE //说明伟大的 QString 类定义于 QT 全局空间

class QLatin1String
{
private:
#if !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII)
    static inline int compare_helper(const QLatin1String &s1, const char *s2)
    {
        return QString::compare(s1, QString::fromUtf8(s2));
    }
#endif
    Q_ALWAYS_INLINE constexpr void verify(qsizetype pos, qsizetype n = 0) const
    {
        Q_ASSERT(pos >= 0);
        Q_ASSERT(pos <= size());
        Q_ASSERT(n >= 0);
        Q_ASSERT(n <= size() - pos);
    }
    Q_CORE_EXPORT static int compare_helper(const QChar *data1, qsizetype length1,
              QLatin1String s2,
              Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;

    qsizetype    m_size; //数据长度
    const char * m_data; //数据起点

public:
    constexpr inline //介绍本类的构造函数
    QLatin1String() noexcept : m_size(0), m_data(nullptr) {}

    constexpr inline explicit
    QLatin1String(const char * s) noexcept :
        m_size(s ? qsizetype(strlen(s)) : 0), m_data(s) {}

    //Constructs a QLatin1String object that stores f with length (l - f).
    //The range [f ,l ) must remain valid for the lifetime of this
    //Latin-1 string object.
    //Passing nullptr as f is safe if l is nullptr, too,
    //and results in a null Latin-1 string.
    //The behavior is undefined if last precedes first,
    //first is nullptr and last is not, or if last - first > INT_MAX.
    constexpr explicit //包含的字符串的范围是 [f, l)
    QLatin1String(const char * f, const char * l)
        : QLatin1String(f, qsizetype(l - f)) {}

    constexpr inline explicit
    QLatin1String(const char *s, qsizetype sz) noexcept
        : m_size(sz), m_data(s) {}

    explicit
    QLatin1String(const QByteArray & s) noexcept // copy构造函数
        : m_size(qsizetype(qstrnlen(s.constData(), s.size()))),
          m_data(s.constData()) {}

    inline QString toString() const { return *this; }

    constexpr const char * latin1() const noexcept { return m_data; }
    constexpr qsizetype    size()   const noexcept { return m_size; }
    constexpr const char * data()   const noexcept { return m_data; }

    constexpr bool isNull()  const noexcept { return !data(); }
    constexpr bool isEmpty() const noexcept { return !size(); }

    template <typename...Args>
    [[nodiscard]] inline
    QString arg(Args &&...args) const
    {
        return QtPrivate::argToQStringDispatch(*this,
                            QtPrivate::qStringLikeToArg(args)...);
    }

    [[nodiscard]] constexpr
    QLatin1Char at(qsizetype i) const
    { return Q_ASSERT(i >= 0), Q_ASSERT(i < size()), QLatin1Char(m_data[i]); }

    [[nodiscard]] constexpr
    QLatin1Char operator[](qsizetype i) const { return at(i); }

    [[nodiscard]] constexpr
    QLatin1Char front() const { return at(0); }

    [[nodiscard]] constexpr
    QLatin1Char back()  const { return at(size() - 1); }

    [[nodiscard]]
    int compare(QStringView other,
                Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::compareStrings(*this, other, cs); }

    [[nodiscard]]
    int compare(QLatin1String other,
                Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::compareStrings(*this, other, cs); }

    [[nodiscard]] constexpr
    int compare(QChar c) const noexcept
    {   return  isEmpty()
                ? -1
                : front() == c
                   ? int(size() > 1)
                   : uchar(m_data[0]) - c.unicode();
    }

    [[nodiscard]]
    int compare(QChar c, Qt::CaseSensitivity cs) const noexcept
    { return QtPrivate::compareStrings(*this, QStringView(&c, 1), cs); }

    [[nodiscard]]
    bool startsWith(QStringView s,
                    Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::startsWith(*this, s, cs); }

    [[nodiscard]]
    bool startsWith(QLatin1String s,
                    Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::startsWith(*this, s, cs); }

    [[nodiscard]] constexpr
    bool startsWith(QChar c) const noexcept
    { return !isEmpty() && front() == c; }

    [[nodiscard]] inline
    bool startsWith(QChar c, Qt::CaseSensitivity cs) const noexcept
    { return QtPrivate::startsWith(*this, QStringView(&c, 1), cs); }

    [[nodiscard]]
    bool endsWith(QStringView s,
                  Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::endsWith(*this, s, cs); }

    [[nodiscard]]
    bool endsWith(QLatin1String s,
                  Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::endsWith(*this, s, cs); }

    [[nodiscard]] constexpr
    bool endsWith(QChar c) const noexcept
    { return !isEmpty() && back() == c; }

    [[nodiscard]] inline
    bool endsWith(QChar c, Qt::CaseSensitivity cs) const noexcept
    { return QtPrivate::endsWith(*this, QStringView(&c, 1), cs); }

    //Returns the index position of the first occurrence of the string-view str,
    //Latin-1 string l1, or character ch, respectively,
    //in this Latin-1 string, searching forward from index position from.
    //Returns -1 if str is not found.
    //If cs is Qt::CaseSensitive (default), the search is case sensitive;
    //otherwise the search is case insensitive.
    //If from is -1, the search starts at the last character;
    //if it is -2, at the next to last character and so on.
    [[nodiscard]]
    qsizetype indexOf(QStringView   s, qsizetype from = 0,  //参数决定是否区分大小写
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::findString(*this, from, s, cs); }

    [[nodiscard]]
    qsizetype indexOf(QLatin1String s, qsizetype from = 0,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::findString(*this, from, s, cs); }

    [[nodiscard]]
    qsizetype indexOf(QChar c, qsizetype from = 0,
                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::findString(*this, from, QStringView(&c, 1), cs); }

    [[nodiscard]]
    bool contains(QStringView s,
                  Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return indexOf(s, 0, cs) != -1; }

    [[nodiscard]]
    bool contains(QLatin1String s,
                  Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return indexOf(s, 0, cs) != -1; }

    [[nodiscard]] inline
    bool contains(QChar c,
                  Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return indexOf(QStringView(&c, 1), 0, cs) != -1; }

    [[nodiscard]]
    qsizetype lastIndexOf(QStringView s,
                          Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return lastIndexOf(s, size(), cs); }

    [[nodiscard]]
    qsizetype lastIndexOf(QStringView s, qsizetype from,
                          Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::lastIndexOf(*this, from, s, cs); }

    [[nodiscard]]
    qsizetype lastIndexOf(QLatin1String s,
                          Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return lastIndexOf(s, size(), cs); }

    [[nodiscard]]
    qsizetype lastIndexOf(QLatin1String s, qsizetype from,
                          Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::lastIndexOf(*this, from, s, cs); }

    //Returns the index position of the last occurrence of the string-view str,
    //Latin-1 string l1, or character ch, respectively, in this Latin-1 string,
    //searching backward from index position from. Returns -1 if str is not found.
    //If from is -1, the search starts at the last character;
    //if from is -2, at the next to last character and so on.
    //If cs is Qt::CaseSensitive (default), the search is case sensitive;
    //otherwise the search is case insensitive.
    [[nodiscard]]
    qsizetype lastIndexOf(QChar c, qsizetype from = -1,
                          Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept
    { return QtPrivate::lastIndexOf(*this, from, QStringView(&c, 1), cs); }

    using value_type      = const char;
    using reference       = value_type &;
    using const_reference = reference;
    using iterator        = value_type *;
    using const_iterator  = iterator;
    using difference_type = qsizetype; // violates Container concept requirements
    using size_type       = qsizetype; // violates Container concept requirements

    constexpr const_iterator  begin() const noexcept { return data(); }
    constexpr const_iterator cbegin() const noexcept { return data(); }
    constexpr const_iterator  end  () const noexcept { return data() + size(); }
    constexpr const_iterator cend  () const noexcept { return data() + size(); }

    using reverse_iterator       = std::reverse_iterator<iterator>;
    using const_reverse_iterator = reverse_iterator;

    const_reverse_iterator  rbegin() const noexcept
    { return const_reverse_iterator(end()); }

    const_reverse_iterator crbegin() const noexcept
    { return const_reverse_iterator(end()); }

    const_reverse_iterator  rend() const noexcept
    { return const_reverse_iterator(begin()); }

    const_reverse_iterator crend() const noexcept
    { return const_reverse_iterator(begin()); }

    [[nodiscard]] constexpr
    QLatin1String mid(qsizetype pos, qsizetype n = -1) const
    {
        using namespace QtPrivate;
        auto   result =  QContainerImplHelper::mid(size(), &pos, &n);
        return result == QContainerImplHelper::Null
                            ? QLatin1String()
                            : QLatin1String(m_data + pos, n); //源码显示了
    }

    [[nodiscard]] constexpr
    QLatin1String left(qsizetype n) const
    {
        if (size_t(n) >= size_t(size()))    n = size();

        return QLatin1String(m_data, n);
    }

    [[nodiscard]] constexpr
    QLatin1String right(qsizetype n) const
    {
        if (size_t(n) >= size_t(size()))    n = size();

        return QLatin1String(m_data + m_size - n, n);
    }

    [[nodiscard]] constexpr
    QLatin1String sliced(qsizetype pos) const
    {   verify(pos);
        return QLatin1String(m_data + pos, m_size - pos);
    }

    [[nodiscard]] constexpr //选择从下标 pos 开始的 n 个子杰
    QLatin1String sliced(qsizetype pos, qsizetype n) const
    {   verify(pos, n);
        return QLatin1String(m_data + pos, n);
    }

    [[nodiscard]] constexpr
    QLatin1String first(qsizetype n) const
    {   verify(n);
        return QLatin1String(m_data, n);
    }

    [[nodiscard]] constexpr
    QLatin1String last(qsizetype n) const
    {   verify(n);
        return QLatin1String(m_data + size() - n, n);
    }

    [[nodiscard]] constexpr
    QLatin1String chopped(qsizetype n) const //扔掉最后的 n 个字节
    {   verify(n);
        return QLatin1String(m_data, size() - n);
    }

    constexpr void chop    (qsizetype n) //为本字符串减掉最后的 n 个字节
    {   verify(n); m_size -= n; }

    constexpr void truncate(qsizetype n) //让本字符串只保留开始的 n 个字节
    {   verify(n); m_size  = n; }

    [[nodiscard]]
    QLatin1String trimmed() const noexcept { return QtPrivate::trimmed(*this); }

    template <typename Needle, typename...Flags>
    [[nodiscard]] inline constexpr
    auto tokenize(Needle &&needle, Flags...flags) const
        noexcept(noexcept(qTokenize(std::declval<const QLatin1String &>(),
                                    std::forward<Needle>(needle), flags...)))
            -> decltype(qTokenize(*this, std::forward<Needle>(needle), flags...))
    { return qTokenize(*this, std::forward<Needle>(needle), flags...); }

    //以下函数，不再是本 QLatin1String 的成员函数
    friend inline //全局的友元函数
    bool operator==(QLatin1String s1, QLatin1String s2) noexcept
    {   return s1.size() == s2.size() &&
               (!s1.size() || !memcmp(s1.latin1(), s2.latin1(), s1.size()));
    }

    friend inline
    bool operator!=(QLatin1String s1, QLatin1String s2) noexcept
    { return !(s1 == s2); }

    friend inline
    bool operator<(QLatin1String s1, QLatin1String s2) noexcept
    {
        const qsizetype len = qMin(s1.size(), s2.size());
        const       int r   = len ? memcmp(s1.latin1(), s2.latin1(), len) : 0;
        return r < 0 || (r == 0 && s1.size() < s2.size());
    }

    friend inline
    bool operator>(QLatin1String s1, QLatin1String s2) noexcept
    { return s2 < s1; }

    friend inline
    bool operator<=(QLatin1String s1, QLatin1String s2) noexcept
    { return !(s1 > s2); }

    friend inline
    bool operator>=(QLatin1String s1, QLatin1String s2) noexcept
    { return !(s1 < s2); }

    // QChar <> QLatin1String
    friend inline
    bool operator==(QChar lhs, QLatin1String rhs) noexcept
    { return rhs.size() == 1 && lhs == rhs.front(); }

    friend inline
    bool operator< (QChar lhs, QLatin1String rhs) noexcept
    { return compare_helper(&lhs, 1, rhs) < 0; }

    friend inline
    bool operator> (QChar lhs, QLatin1String rhs) noexcept
    { return compare_helper(&lhs, 1, rhs) > 0; }

    friend inline
    bool operator!=(QChar lhs, QLatin1String rhs) noexcept
    { return !(lhs == rhs); }

    friend inline
    bool operator<=(QChar lhs, QLatin1String rhs) noexcept
    { return !(lhs >  rhs); }

    friend inline
    bool operator>=(QChar lhs, QLatin1String rhs) noexcept
    { return !(lhs <  rhs); }

    friend inline
    bool operator==(QLatin1String lhs, QChar rhs) noexcept
    { return   rhs == lhs; }

    friend inline
    bool operator!=(QLatin1String lhs, QChar rhs) noexcept
    { return !(rhs == lhs); }

    friend inline
    bool operator< (QLatin1String lhs, QChar rhs) noexcept
    { return   rhs >  lhs; }

    friend inline
    bool operator> (QLatin1String lhs, QChar rhs) noexcept
    { return   rhs <  lhs; }

    friend inline
    bool operator<=(QLatin1String lhs, QChar rhs) noexcept
    { return !(rhs <  lhs); }

    friend inline
    bool operator>=(QLatin1String lhs, QChar rhs) noexcept
    { return !(rhs >  lhs); }

    // QStringView <> QLatin1String  全部都是全局的符号比较运算符函数
    friend inline bool operator==(QStringView lhs, QLatin1String rhs) noexcept
    { return lhs.size() == rhs.size() && QtPrivate::equalStrings(lhs, rhs); }

    friend inline bool operator!=(QStringView lhs, QLatin1String rhs) noexcept
    { return !(lhs == rhs); }

    friend inline bool operator< (QStringView lhs, QLatin1String rhs) noexcept
    { return QtPrivate::compareStrings(lhs, rhs) <  0; }

    friend inline bool operator<=(QStringView lhs, QLatin1String rhs) noexcept
    { return QtPrivate::compareStrings(lhs, rhs) <= 0; }

    friend inline bool operator> (QStringView lhs, QLatin1String rhs) noexcept
    { return QtPrivate::compareStrings(lhs, rhs) >  0; }

    friend inline bool operator>=(QStringView lhs, QLatin1String rhs) noexcept
    { return QtPrivate::compareStrings(lhs, rhs) >= 0; }

    friend inline bool operator==(QLatin1String lhs, QStringView rhs) noexcept
    { return lhs.size() == rhs.size() && QtPrivate::equalStrings(lhs, rhs); }

    friend inline bool operator!=(QLatin1String lhs, QStringView rhs) noexcept
    { return !(lhs == rhs); }

    friend inline bool operator< (QLatin1String lhs, QStringView rhs) noexcept
    { return QtPrivate::compareStrings(lhs, rhs) <  0; }

    friend inline bool operator<=(QLatin1String lhs, QStringView rhs) noexcept
    { return QtPrivate::compareStrings(lhs, rhs) <= 0; }

    friend inline bool operator> (QLatin1String lhs, QStringView rhs) noexcept
    { return QtPrivate::compareStrings(lhs, rhs) >  0; }

    friend inline bool operator>=(QLatin1String lhs, QStringView rhs) noexcept
    { return QtPrivate::compareStrings(lhs, rhs) >= 0; }


#if !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII)
    QT_ASCII_CAST_WARN inline bool operator==(const char *s) const;
    { return QString::fromUtf8(s) == *this; }

    QT_ASCII_CAST_WARN inline bool operator!=(const char *s) const;
    { return QString::fromUtf8(s) != *this; }

    QT_ASCII_CAST_WARN inline bool operator< (const char *s) const;
    { return QString::fromUtf8(s) > *this; }

    QT_ASCII_CAST_WARN inline bool operator> (const char *s) const;
    { return QString::fromUtf8(s) < *this; }

    QT_ASCII_CAST_WARN inline bool operator<=(const char *s) const;
    { return QString::fromUtf8(s) >= *this; }

    QT_ASCII_CAST_WARN inline bool operator>=(const char *s) const;
    { return QString::fromUtf8(s) <= *this; }

    QT_ASCII_CAST_WARN inline bool operator==(const QByteArray &s) const;
    { return QString::fromUtf8(s) == *this; }

    QT_ASCII_CAST_WARN inline bool operator!=(const QByteArray &s) const;
    { return QString::fromUtf8(s) != *this; }

    QT_ASCII_CAST_WARN inline bool operator< (const QByteArray &s) const;
    { return QString::fromUtf8(s) > *this; }

    QT_ASCII_CAST_WARN inline bool operator> (const QByteArray &s) const;
    { return QString::fromUtf8(s) < *this; }

    QT_ASCII_CAST_WARN inline bool operator<=(const QByteArray &s) const;
    { return QString::fromUtf8(s) >= *this; }

    QT_ASCII_CAST_WARN inline bool operator>=(const QByteArray &s) const;
    { return QString::fromUtf8(s) <= *this; }

    QT_ASCII_CAST_WARN friend bool operator==(const char *s1, QLatin1String s2)
    { return compare_helper(s2, s1) == 0; }

    QT_ASCII_CAST_WARN friend bool operator!=(const char *s1, QLatin1String s2)
    { return compare_helper(s2, s1) != 0; }

    QT_ASCII_CAST_WARN friend bool operator< (const char *s1, QLatin1String s2)
    { return compare_helper(s2, s1) >  0; }

    QT_ASCII_CAST_WARN friend bool operator> (const char *s1, QLatin1String s2)
    { return compare_helper(s2, s1) <  0; }

    QT_ASCII_CAST_WARN friend bool operator<=(const char *s1, QLatin1String s2)
    { return compare_helper(s2, s1) >= 0; }

    QT_ASCII_CAST_WARN friend bool operator>=(const char *s1, QLatin1String s2)
    { return compare_helper(s2, s1) <= 0; }
#endif // !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII)

}; //完结 class QLatin1String


Q_DECLARE_TYPEINFO(QLatin1String, Q_RELOCATABLE_TYPE);

（2）

谢谢

浅谈QLatin1String类的使用
ByteWhizX的博客
08-23 605
在上述示例中，QLatin1String类被用来创建一个Latin1编码的字符串，然后通过QString类的arg()函数进行拼接。需要注意的一点是，由于QLatin1String类返回的是一个指向Latin1字符集的字符串，所以在进行QString的操作时需要进行转换。总结：QLatin1String虽然不如QString使用广泛，但它作为QString类的替代品，具有轻量级和高效率的特性，是一种值得考虑的优化手段。本文将介绍QLatin1String类的使用方法，并通过简单的示例代码展示它的作用。
Qt基础之三十五：Qt中文乱码探索
草上爬的博客
04-07 7242
Qt中文乱码看这一篇就够了 先说个小技巧：Qt Creator支持显示源文件编码格式右上角点UTF-8，会弹出“文件编码”对话框我的开发环境是Win10 Qt5.12.6 VS2017，IDE是Qt Creator。
QLatin1String类的学习
Lutx的专栏
02-27 1万+
QLatin1String类对US-ASCII/Latin-1编码的字符串进行了封装。     许多QString的成员函数都用const char*代替QString作为参数实现重载。这包含拷贝构造函数，赋值操作，比较操作和其他不同的函数，比如insert(), replace(), indexOf(). 这些函数都做了优化以避免在函数调用时从const char*中构造一个QString
QLatin1String类的说明
热门推荐
非常道的博客
06-02 1万+
QLatin1String类对US-ASCII/Latin-1编码的字符串进行了简单封装。可理解为关于const char*的一个浅封装。
什么情况下用QLatin1String
友善啊，朋友的博客
12-07 1240
在这个例子中，使用了QString的构造函数、fromLatin1()函数和直接赋值操作，这些操作都会将C字符串复制到新的QString对象中，并分配内存来存储拷贝后的字符串数据。这样就会涉及到额外的复制和内存分配的开销。这里将C字符串直接转换为QLatin1String对象，不会进行数据的复制和内存的分配。这可以有效地提高性能。
Qt QString、QLatin1String、QStringLiteral 的区别
cpp_learner的博客
03-12 5426
QString String提供了一个Unicode字符串，QString存储的是一串QChar,而QChar提供了16位的Unicode字符，后台使用隐式共享减少内存的开销。 假设setObjectName参数列表是QString类型 Obj->setObjectName(“People”); 调用了QObject::setObjectName(const QString&)函数。这里有一个通过构造产生的从const char*到QString的隐式转换，一个新的QString对象产生，
c语言实现通讯录管理软件（源码）
03-31
- C语言提供了丰富的库函数，如标准输入输出（stdio.h）、字符串处理（string.h）和内存管理（malloc/free）等，为编写此类应用提供便利。 2. 数据结构： - 联系人信息可能以结构体的形式表示，如`struct Contact...
写QT串口通信的UI界面时，数据输入文本框为什么要有文本(字符串)发送和十六进制发送？
qq_44028775的博客
04-18 899
写QT串口通信的UI界面时，数据输入文本框为什么要有文本发送和十六进制发送？十六进制发送如何实现？
C++源码详解：程序设计与应用实例
由于提供的文件中并未包含具体的源代码，我们假设存在一个名为“C++程序设计与应用源码”的压缩文件，解压后可能包含如下文件结构： ``` C++程序设计与应用源码 │ ├── main.cpp ├── utils/ │ ├── string...
基于STM32+Qt上位机设计的智慧停车场管理系统(207)
08-14 2535
本项目设计了一套基于STM32+Qt上位机的智慧停车场管理系统。该系统融合了先进的嵌入式技术、图像识别技术、数据库技术和移动互联网技术，通过STM32硬件端实时采集车库现场信息，包括车牌识别、车位占用状态监测等，并将数据上传至Qt上位机进行处理与展示。利用MySQL数据库存储车辆出入库记录及车位使用情况，确保数据的安全性和可追溯性；通过Android手机APP为用户提供查询、支付等功能，实现远程交互与便捷服务。
QT基础之字符串类
墨1024
07-13 1436
QT字符串类简单介绍，操作字符串、查询字符串、字符串转换
QT的QLatin1String类的使用
Book_Sea的博客
09-07 510
总结一下，QLatin1String类提供了一种方便的方式来处理Latin-1编码的字符串，它可以减少内存开销并提供快速访问和操作字符串的方法。QLatin1String的主要作用是将Latin-1编码的字符串封装为一个对象，并提供一些方便的方法来操作这些字符串。它不会复制字符串的数据，只是存储了指向字符串数据的指针，并提供了一些成员函数来访问和操作字符串。需要注意的是，QLatin1String并不提供修改字符串的方法，因为它只是对字符串进行了封装，并没有复制字符串数据。函数用于获取字符串的长度，
QStringLiteral、QLatin1String作用及性能总结
danshiming的博客
04-09 4062
QStringLiteral、QLatin1String用法总结
QT---之QLatin1String概念
weixin_39609623的博客
10-10 2110
QLatin1String类的学习 QLatin1String类对US-ASCII/Latin-1编码的字符串进行了封装。     许多QString的成员函数都用const char*代替QString作为参数实现重载。这包含拷贝构造函数，赋值操作，比较操作和其他不同的函数，比如insert(), replace(), indexOf(). 这些函数都做了优化以避免在函数调用时从const ...
【Qt】关于QStringLiteral和QLatin1String
芒果黑的博客
11-10 2011
最近在看Qt Creator源码的时候，发现代码中字符串的地方很多都用到QStringLiteral和QLatinString，就查了一下这两个是做什么用，就在这里记录一下这两个的用法。 QStringLiteral(str) QStringLiteral是一个宏，该宏在编译时从字符串文字str中为QString生成数据。 在这种情况下，可以从中免费创建QString，并且将生成的字符串数据存储在已编译目标文件的只读段中 对于一下代码 // hasAttribute takes a QString
qt初入门0：结构体中QString用memset导致崩溃分析及QLatin1String简单查看源码
yun6853992的博客
08-17 2239
结构体中QString成员memset导致崩溃
QString、QLatin1String、QStringLiteral
lfnlook的博客
03-15 531
①参数能使用 const char*类型或 QLatin1String 类型的地方使用相应的参数。②参数需要 QString 参数类型的地方，若值不修改，则使用 QStringLiteral 宏③参数需要 QString 类型且 QString 可能被修改，则直接使用 QString 或隐式转换。
【QT开发教程】QLatin1String类详解及实战应用：高效处理Latin-1字符串的Qt利器
最新发布
科技改变人类，技术成就未来
11-01 160
在现代软件开发中，字符串处理是一个常见的任务。Qt提供了一系列字符串类来帮助开发者处理不同类型的字符串数据。其中，QLatin1String是一个专门用于处理Latin-1编码字符串的类。本文将深入探讨QLatin1String的功能及其在应用程序中的实际应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值