目录

Qt中处理字符串最常用的肯定是QString，但是在qt creator源码中出现了大量的QLatin1String。下面我们来介绍下区别。

我们首先来看QLatinString。类详细介绍如下：

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

QLatin1String类为US-ASCII/Latin-1编码的字符串文字提供了一个小型包装器。

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

  1.   if (str == "auto" || str == "extern"
  2.           || str == "static" || str == "register") {
  3.       ...
  4.   }

比下面的快很多

  1.   if (str == QString("auto") || str == QString("extern")
  2.           || str == QString("static") || str == QString("register"))   {
  3.       ...
  4.   }

因为它不会构造四个临时QString对象并进行字符数据的深拷贝。

定义QT_NO_CAST_FROM_ASCII宏（如QString文档中所述）的应用程序无法访问QString的const char * 接口API。为了提供一种指定常量Latin-1字符串的有效方法，Qt提供了QLatin1String，它是const char *的非常薄的包装。使用QLatin1String，上面的示例代码变为

  1.   if (str == QLatin1String("auto")
  2.           || str == QLatin1String("extern")
  3.           || str == QLatin1String("static")
  4.           || str == QLatin1String("register") {
  5.       ...
  6.   }

键入的时间稍长一些，但是它提供的功能与代码的第一个版本完全相同，并且比使用QString::fromLatin1()转换Latin-1字符串的速度更快。

多亏了QString(QLatin1String)构造函数，QLatin1String可以在需要QString的任何地方使用。 例如：

  1. QLabel *label = new QLabel(QLatin1String("MOD"), this);

注意：如果你调用的函数，使用QLatin1String作为参数，实际上并未被重载来使用QLatin1String，而是进行QString的隐式转换，并将触发内存分配，而这是你通常使用QLatin1String首先要避免的情况。在这些情况下，使用QStringLiteral可能是更好的选择。

我们看下QLatin1String源码，进行了截取，展现核心部分

  1. class QLatin1String
  2. {
  3. public:
  4.     inline QLatin1String() : m_size(0), m_data(nullptr) {}
  5.     inline explicit QLatin1String(const char *s) : m_size(s ? int(strlen(s)) : 0), m_data(s) {}
  6.     
  7.     private:
  8.     int m_size;
  9.     const char *m_data;
  10. }

我们可以发现，真的是简单的包装，也没有什么深拷贝什么的，只是把地址简单的赋给了成员变量m_data。

简单说，QLatin1String就是对const char*的简单包装，用在QT_NO_CAST_FROM_ASCII导致无法访问QString的const char*接口的地方。

QString这个大家都很熟悉了，我们也不过多介绍。这里提一下QStringLiteral，大家可以在QString类介绍中找到。

这是一个宏，在编译时从字符串文字str中为QString生成数据。 在这种情况下，可以免费创建QString，并且将生成的字符串数据存储在已编译目标文件的只读段中。

如果您的代码如下所示：

  1.   // hasAttribute takes a QString argument
  2.   if (node.hasAttribute("http-contents-length")) //...

然后这将创建一个临时QString作为hasAttribute函数参数进行传递。 这可能会非常昂贵，因为它涉及内存分配以及将数据复制/转换为QString的内部编码。

通过使用QStringLiteral可以避免此成本：

  1. if (node.hasAttribute(QStringLiteral(u"http-contents-length"))) //...

在这种情况下，QString的内部数据将在编译时生成。在运行时不会发生任何转换或分配。

使用QStringLiteral而不是用双引号引起来的纯C++字符串文字，可以显着加快根据编译时已知的数据创建QString实例的速度。

注意：当将字符串传递给具有重载QLatin1String参数的函数时，QLatin1String仍比QStringLiteral更有效，并且此重载避免了转换为QString。例如，QString::operator ==()可以直接与QLatin1String进行比较：

  1. if (attribute.name() == QLatin1String("http-contents-length")) //...

注意：某些编译器编码包含US-ASCII字符集以外字符的字符串会有bug。在这种情况下，请确保在字符串前加上u。否则是可选的。

我们查看宏定义源码

  1. template <int N>
  2. struct QStaticStringData
  3. {
  4.     QArrayData str;
  5.     qunicodechar data[N + 1];
  7.     QStringData *data_ptr() const
  8.     {
  9.         Q_ASSERT(str.ref.isStatic());
  10.         return const_cast<QStringData *>(static_cast<const QStringData*>(&str));
  11.     }
  12. };
  14. struct Q_CORE_EXPORT QArrayData
  15. {
  16.     QtPrivate::RefCount ref;
  17.     int size;
  18.     uint alloc : 31;
  19.     uint capacityReserved : 1;
  21.     qptrdiff offset; // in bytes from beginning of header
  22. }
  24. #define QStringLiteral(str) \
  25.     ([]() Q_DECL_NOEXCEPT -> QString { \
  26.         enum { Size = sizeof(QT_UNICODE_LITERAL(str))/2 - 1 }; \
  27.         static const QStaticStringData<Size> qstring_literal = { \
  28.             Q_STATIC_STRING_DATA_HEADER_INITIALIZER(Size), \
  29.             QT_UNICODE_LITERAL(str) }; \
  30.         QStringDataPtr holder = { qstring_literal.data_ptr() }; \
  31.         const QString qstring_literal_temp(holder); \
  32.         return qstring_literal_temp; \
  33.     }())
  34.     
  35.     #define Q_STATIC_STRING_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, offset) \
  36.     { Q_REFCOUNT_INITIALIZE_STATIC, size, 0, 0, offset }
  38. #define Q_STATIC_STRING_DATA_HEADER_INITIALIZER(size) \
  39.     Q_STATIC_STRING_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, sizeof(QStringData))

我们对Q_STATIC_STRING_DATA_HEADER_INITIALIZER宏进行替换，可以得到

  1. #define QStringLiteral(str) \
  2.     ([]() Q_DECL_NOEXCEPT -> QString { \
  3.         // 计算大小，unicode为16bit一个字符，所以除2
  4.         enum { Size = sizeof(QT_UNICODE_LITERAL(str))/2 - 1 }; \
  5.         // 核心，只读静态变量，POD结构，编译器创建
  6.         static const QStaticStringData<Size> qstring_literal = { \
  7.             // QArrayData
  8.             {-1, \
  9.              size, \
  10.              0, \
  11.              0, \
  12.              sizeof(QStringData) \
  13.             }, \
  14.             // qunicodechar []
  15.             QT_UNICODE_LITERAL(str) }; \
  16.         // 获取编译器创建的静态底层数据
  17.         QStringDataPtr holder = { qstring_literal.data_ptr() }; \
  18.         // 构造QString，不用进行内存分配了
  19.         const QString qstring_literal_temp(holder); \
  20.         // 返回QString，完成加速
  21.         return qstring_literal_temp; \
  22.     }())

说白了，QStringLiteral在编译期就创建了数据，避免了内存分配，加速了QString的创建。

原创造福大家，共享改变世界

献出一片爱心，温暖作者心灵

版权声明：本文为codeForFamily原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/codeForFamily/p/qt-creator-ide-source-learn-4-5.html