QString

QString的类提供了一个Unicode字符串
头文件：QString
QMAKE：QT +=core

成员列表
 宏定义及枚举
 构造函数
 append
 prepend
 arg
 asprintf
 vasprintf
 at
 front
 back
 push_front
 push_back
 insert
 fill
 begin和constBegin
 rbegin
 end和constEnd
 rend
 cbegin，cend，crbegin和crend
 data和constData
 capacity
 chop和chopped
 size
 length
 resize
 reserve
 squeeze
 truncate
 shrink_to_fit
 swap
 clear
 isEmpty
 isNull
 isRightToLeft
 trimmed
 simplified
 repeated
 section
 remove
 replace
 number
 setNum
 count
 right，rightJustified和rightRef
 left，leftJustified和leftRef
 mid和midRef
 normalized
 indexOf
 lastIndexOf
 compare
 localeAwareCompare
 contains
 startsWith
 endsWith
 split
 splitRef
 unicode和utf16
 setRawData，setUnicode和setUtf16
 返回指定格式的QString
 转换为其他格式
 转换为基础数据类型的函数
 toUpper和toLower
操作符重载

---

成员列表

嵌套类，枚举，宏定义

class NULL;
enum NormalizationForm;
enum SectionFlag;
enum SplitBehavior;
flags SectionFlags;

typedef ConstIterator;
typedef const_iterator;
typedef const_reverse_iterator;
typedef const_pointer;
typedef const_reference;
typedef Iterator;
typedef reverse_iterator;
typedef pointer;
typedef reference;

typedef difference_type;
typedef size_type;
typedef value_type;

const NULL null;

构造函数，祈构函数

QString();
QString(const QChar *, int );
QString(QChar );
QString(int , QChar );
QString(QLatin1String );
QString(const QString &);
QString(QString &&);
QString(const char *);
QString(const QByteArray &);
~QString();

--------------公有成员函数-------------------

将字符串追加到此字符串末尾

QString& append(const QString &);
QString& append(const QChar *, int );
QString& append(QChar );
QString& append(const QStringRef &);
QString& append(QLatin1String );
QString& append(const char *);
QString& append(const QByteArray &);

将字符串追加到此字符串开头

QString& prepend(const QString &);
QString& prepend(const QChar *, int );
QString& prepend(QChar );
QString& prepend(const QStringRef &);
QString& prepend(QLatin1String );
QString& prepend(const char *);
QString& prepend(const QByteArray &);

①将字符串中的%1，%2，… %99的数字用第一个参数代替
②第二个参数fieldWidth = 0，指定第一个参数应占用的最小空间量
③如果第一个参数占用空间小于fieldWidth，则用最后一个参数字符填充，默认为“”
④base参数表示进制数，默认为10
⑤precision参数指示第一个参数按指定的格式和精度进行格式化
后面几个重载函数可以当成是2至n个arg函数组成的
注：%1，%2，… %99最好按顺序，不然当数据为整数时会产生意料之外的结果

QString arg(const QString &, int fieldWidth, QChar ) const;
QString arg(qulonglong , int fieldWidth, int base, QChar ) const;
QString arg(long , int fieldWidth, int base, QChar ) const;
QString arg(ulong , int fieldWidth, int base, QChar ) const;
QString arg(int , int fieldWidth, int base, QChar ) const;
QString arg(uint , int fieldWidth, int base, QChar ) const;
QString arg(short , int fieldWidth, int base, QChar ) const;
QString arg(ushort , int fieldWidth, int base, QChar ) const;
QString arg(double , int fieldWidth, char , int precision, QChar ) const;
QString arg(char , int fieldWidth, QChar ) const;
QString arg(QChar , int fieldWidth, QChar ) const;
QString arg(qlonglong , int fieldWidth, int base, QChar ) const;
QString arg(QStringView , int fieldWidth, QChar ) const;
QString arg(QLatin1String , int fieldWidth, QChar ) const;
QString arg(const QString &, const QString &) const;
QString arg(const QString &, const QString &, const QString &) const;
QString arg(const QString &, const QString &, const QString &, const QString &) const;
QString arg(const QString &, const QString &, const QString &, const QString &, const QString &) const;
QString arg(const QString &, const QString &, const QString &, const QString &, const QString &, const QString &) const;
QString arg(const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &) const;
QString arg(const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &) const;
QString arg(const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &, const QString &) const ;

从格式字符串cformat和任意参数列表安全地构建格式化字符串

QString asprintf(const char *cformat，...);

asprintf的等效方法

QString vasprintf(const char *, va_list );

返回字符串中索引为i的字符，第一个值为0

const QChar at(int i) const;

返回字符串中第一个字符
用于兼容STL
注：在空字符串上调用会造成未定义的行为

QChar front() const;
QCharRef front();

返回字符串中最后一个字符
用于兼容STL
注：在空字符串上调用会造成未定义的行为

QChar back() const;
QCharRef back();

将给定的其他字符串附加到此字符串的开头。它相当于append，用于STL兼容性

void push_front(const QString &);
void push_front(QChar );

将给定的其他字符串附加到此字符串的末尾。它相当于append，用于STL兼容性

void push_back(const QString &);
void push_back(QChar );

将第二个参数插入到第一个参数的索引位置，返回此字符串的引用
给定索引大于size() 则调用resize()扩展

QString& insert(int , const QString &);
QString& insert(int , const QChar *, int );//第三个参数指定第二个参数大小
QString& insert(int , QChar );
QString& insert(int , const QStringRef &);
QString& insert(int , QLatin1String );
QString& insert(int , const char *);
QString& insert(int , const QByteArray &);

将字符串用第一个参数填充满
size=-1为默认大小，如果指定其他大小值，则会重构大小

QString& fill(QChar , int size=-1) ;

返回指向第一个字符的迭代器

iterator begin();
const_iterator begin() const;
const_iterator constBegin() const;

返回指向字符串最后一个子符的逆向迭代器

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

返回指向字符串最后一个子符的后一个位置的迭代器

iterator end();
const_iterator end() const;
const_iterator constEnd() const;

返回指向第一个字符的前一个位置的逆向迭代器

reverse_iterator rend();
const_reverse_iterator rend();

1.返回指向最后一个字符的后一个位置的const迭代器
2.返回指向第一个字符的const迭代器
3.返回指向最后一个字符的const逆向迭代器
4.返回指向第一个字符的前一个位置的const逆向迭代器

const_iterator cend() const;
const_iterator cbegin() const;
const_reverse_iterator crbegin() const;
const_reverse_iterator crend() const;

返回指向存储在QString的数据的指针，可用于访问字符串的字符
注：只要字符串未被修改，指针就保持有效
注：返回的字符串可能不会被\0终止，第一个data函数返回的数据始终为\0终止

QChar* data();
const QChar* data() const;
const QChar* constData() const;

返回可以存储在字符串中的最大字节数，而不强制重新分配

int capacity() const;

从字符串末尾删除n个字符，第一个改变自身，后一个不改变自身但返回改变后的值

void chop(int n);
QString chopped(int n) const;

返回字符串的大小

int size() const;

返回此字符串中的字符数，相当于size()

int length() const;

将字符串的大小设置为size，如果size小于当前大小，则从末尾删除多余字符，如果size大于当前大小，则在末尾添加额外字符
第二个函数用第二个参数填充多出的空间

void resize(int size);
void resize(int , QChar );

重新分配内存，大小为size

void reserve(int size);

释放存储字符数据不需要的任何内存

void squeeze();

截断index处的字符串，即丢弃index后面的字符串

void truncate(int index);

此功能用于STL兼容性。它相当于squeeze

void shrink_to_fit();

交换字符串

void swap(QString &);

清空字符串的内容，并使其为null

void clear();

如果字符串为空，则返回true，否则返回false

bool isEmpty() const;

如果字符串为null，则返回true，否则返回false

bool isNull() const;

如果从左到右读取字符串，则返回true，否则返回false

bool isRightToLeft() const;

将字符串开头和结尾的空格删除
与simplified（）不同，trimmed（）仅留下内部空白

QString trimmed() const;

将字符串开头和结尾的空格删除

QString simplified() const;

返回字符串n次重复副本

QString repeated(int n) const;

第一个参数为字符串中字符或子串
第二个参数为第一个参数第start次出现的位置
第三个参数为第一个参数结尾的位置，默认为整个字符串
flags参数用来影响功能的行为，具体查看官方文档

QString section(QChar , int start, int end=-1, SectionFlags flags = SectionDefault) const;
QString section(const QString &, int , int , SectionFlags ) const;
QString section(const QRegExp &, int , int , SectionFlags ) const;
QString section(const QRegularExpression &, int , int , SectionFlags ) const;

第一个函数为，以第一个参数为索引，从字符串中删除第二个参数个字符
后续的则是删除该字符串中所有的第一个参数
Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写

QString& remove(int , int ) ;
QString& remove(QChar , Qt::CaseSensitivity ) ;
QString& remove(const QString &, Qt::CaseSensitivity );
QString& remove(const QRegExp &);
QString& remove(const QRegularExpression &);

前三个函数为以index为起点，用第三个参数代替后面的n个字符
后序的函数为，将字符串中的第一个参数替换为第二个参数值
Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写

QString& replace(int index, int n, const QString &);
QString& replace(int index, int n, const QChar *, int );
QString& replace(int index, int n, QChar );
QString& replace(QChar , QChar , Qt::CaseSensitivity );
QString& replace(const QChar *, int , const QChar *, int , Qt::CaseSensitivity );
QString& replace(QLatin1String , QLatin1String , Qt::CaseSensitivity );
QString& replace(QLatin1String , const QString &, Qt::CaseSensitivity );
QString& replace(const QString &, QLatin1String , Qt::CaseSensitivity );
QString& replace(const QString &, const QString &, Qt::CaseSensitivity );
QString& replace(QChar , const QString &, Qt::CaseSensitivity );
QString& replace(QChar , QLatin1String , Qt::CaseSensitivity );
QString& replace(const QRegExp &, const QString &);
QString& replace(const QRegularExpression &, const QString &);

该函数为静态成员函数
根据给定的二进制，返回等于数字n的字符串
format为双精度数的格式，具体查看参数格式

QString number(long n, int base);
QString number(uint n, int base);
QString number(int n, int base);
QString number(ulong n, int base);
QString number(qlonglong n, int base);
QString number(qulonglong n, int base);
QString number(double n, char format ='g', int base);

将字符串设置为给定进制数的数字
最后两个函数的第二个参数为格式，查看官方文档
最后两个函数的第三个参数为精度

QString& setNum(int , int base=10);
QString& setNum(ushort , int );
QString& setNum(short , int );
QString& setNum(uint , int );
QString& setNum(long , int );
QString& setNum(ulong , int );
QString& setNum(qlonglong , int );
QString& setNum(qulonglong , int );
QString& setNum(float , char , int );
QString& setNum(double , char , int );

返回第一个参数在字符串中出现的个数
Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写

int count(const QString &, Qt::CaseSensitivity ) const;
int count(QChar , Qt::CaseSensitivity ) const;
int count() const;//等同于size()；
int count(const QStringRef &, Qt::CaseSensitivity ) const;
int count(const QRegExp &) const;
int count(const QRegularExpression &) const;

返回最右侧大小为n的子串，如果n大于等于size或为负数，则返回整个字符串
当n大于size()时用fill填充
truncate，为true且size大于n，则删除n之后的字符，为false则返回大小为n的字符串

QString right(int n) const;
QString rightJustified(int n, QChar fill, bool truncate=false) const;
QStringRef rightRef(int n) const;

返回最左侧大小为n的子串，如果n大于等于size或为负数，则返回整个字符串
当n大于size()时用fill填充
truncate，为true且size大于n，则删除n之后的字符，为false则返回大小为n的字符串

QString left(int n) const;
QString leftJustified(int n, QChar fill, bool truncate=false) const;
QStringRef leftRef(int n) const;

返回索引处开始大小为n的子串，如果n大于等于size或为负数，则返回整个字符串
如果从指定位置开始的可用字符小于m或m=-1，返回指定位置后可用的所有字符

QString mid(int n, int m=-1) const;
QStringRef midRef(int n, int m=-1) const;

根据给定的Unicode标准版本，返回给定Unicode规范化模式下的字符串
NormalizationForm有四个
QString::NormalizationForm_D：正则分解
QString::NormalizationForm_C：正则分解与正则成分
QString::NormalizationForm_KD：兼容性分解
QString::NormalizationForm_KC：相容分解与规范组合
QChar::UnicodeVersion=QChar :: Unicode_Unassigned默认值，具体查看官方文档

QString normalized(NormalizationForm mode, QChar::UnicodeVersion ) const;

返回第一个参数第一次在字符串中出现的索引位置，如果未找到，则返回-1
第二个参数为索引位置起始点默认值为0，如果为-1则搜索从最后一个字符开始，-2则是倒二，类推
Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写

int indexOf(const QString &, int , Qt::CaseSensitivity ) const;
int indexOf(QChar , int , Qt::CaseSensitivity ) const;
int indexOf(QLatin1String , int , Qt::CaseSensitivity ) const;
int indexOf(const QStringRef &, int , Qt::CaseSensitivity ) const;
int indexOf(const QRegExp &, int ) const;
int indexOf(QRegExp &, int ) const;
int indexOf(const QRegularExpression &, int ) const;
int indexOf(const QRegularExpression &, int , QRegularExpressionMatch *) const;

返回第一个参数最后一次在字符串中出现的索引位置，如果未找到，则返回-1
第二个参数为索引位置起始点，默认值为-1，如果为-1则搜索从最后一个字符开始，-2则是倒二，类推
Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写

int lastIndexOf(const QString &, int , Qt::CaseSensitivity ) const;
int lastIndexOf(QChar , int , Qt::CaseSensitivity ) const;
int lastIndexOf(QLatin1String , int , Qt::CaseSensitivity ) const;
int lastIndexOf(const QStringRef &, int , Qt::CaseSensitivity ) const;
int lastIndexOf(const QRegExp &, int ) const;
int lastIndexOf(QRegExp &, int ) const;
int lastIndexOf(const QRegularExpression &, int ) const;
int lastIndexOf(const QRegularExpression &, int , QRegularExpressionMatch *) const;

有三个参数的为静态成员函数，将s1和s2第一个不同的字符进行差法运算，返回差值
有两个参数函数，将当前字符串与目标字符串进行比较，将第一个不同的字符进行差法运算，返回差值
最后一个参数Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写

int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity );
int compare(QLatin1String , Qt::CaseSensitivity ) const;
int compare(const QString &, Qt::CaseSensitivity ) const;
int compare(const QString &, QLatin1String , Qt::CaseSensitivity );
int compare(QLatin1String , const QString &, Qt::CaseSensitivity );
int compare(const QStringRef &, Qt::CaseSensitivity ) const;
int compare(const QString &, const QStringRef &, Qt::CaseSensitivity );

l有两个参数的为静态成员函数，将s1和s2第一个不同的字符进行差法运算，返回差值
有一个参数函数，将当前字符串与目标字符串进行比较，将第一个不同的字符进行差法运算，返回差值
最后一个参数Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写
比较以平台相关进行

int localeAwareCompare(const QString &, const QString &);
int localeAwareCompare(const QString &) const;
int localeAwareCompare(const QStringRef &) const;
int localeAwareCompare(const QString &, const QStringRef &);

如果字符串中含有第一个参数这个子串，则返回true，否则返回false
最后一个参数Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写

bool contains(const QString &, Qt::CaseSensitivity ) const;
bool contains(QChar , Qt::CaseSensitivity ) const;
bool contains(QLatin1String , Qt::CaseSensitivity ) const;
bool contains(const QStringRef &, Qt::CaseSensitivity ) const;
bool contains(const QRegExp &) const;
bool contains(QRegExp &) const;
bool contains(const QRegularExpression &) const;
bool contains(const QRegularExpression &, QRegularExpressionMatch *) const;

如果字符串以第一个参数开头，则返回true，否则返回false
Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写

bool startsWith(const QString &, Qt::CaseSensitivity ) const;
bool startsWith(const QStringRef &, Qt::CaseSensitivity ) const ;
bool startsWith(QStringView , Qt::CaseSensitivity ) const;
bool startsWith(QLatin1String , Qt::CaseSensitivity ) const;
bool startsWith(QChar , Qt::CaseSensitivity ) const;

如果字符串以第一个参数结尾，则返回true，否则返回false
Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写

bool endsWith(const QString &, Qt::CaseSensitivity ) const;
bool endsWith(const QStringRef &, Qt::CaseSensitivity ) const;
bool endsWith(QStringView , Qt::CaseSensitivity ) const ;
bool endsWith(QLatin1String , Qt::CaseSensitivity ) const;
bool endsWith(QChar , Qt::CaseSensitivity ) const;

以第一个参数为分界字符，将字符串分为多个子串
第二个参数为是否保留空串，默认为保存QString::KeepEmptyParts，QString::SkipEmptyParts
Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写

QStringList split(const QString &, SplitBehavior , Qt::CaseSensitivity ) const;
QStringList split(QChar , SplitBehavior , Qt::CaseSensitivity ) const;
QStringList split(const QRegExp &, SplitBehavior ) const;
QStringList split(const QRegularExpression &, SplitBehavior ) const;

以第一个参数为分界字符，将字符串分为多个子串
第二个参数为是否保留空串，默认为保存QString::KeepEmptyParts，QString::SkipEmptyParts
Qt :: CaseSensitivity，有两个值
Qt::CaseInsensitive：比较区分大小写，默认值
Qt::CaseSensitive：比较区不分大小写

QVector splitRef(const QString &, SplitBehavior , Qt::CaseSensitivity ) const;
QVector splitRef(QChar , SplitBehavior , Qt::CaseSensitivity ) const;
QVector splitRef(const QRegExp &, SplitBehavior ) const;
QVector splitRef(const QRegularExpression &, SplitBehavior ) const;

const QChar* unicode() const;
const ushort* utf16() const;

QString& setRawData(const QChar *, int );

QString& setUnicode(const QChar *, int );

QString& setUtf16(const ushort *, int );

返回指定格式的QString串(静态成员函数)

//构造一个包含字符串 CFString 副本的新QString，仅适用于OS X和iOS
QString fromCFString(CFStringRef string);

//1.返回使用Latin-1字符串str，大小为size的字符初始化的QString，size为str的长度，默认为整个字符串
//2.返回使用Latin-1字符串str初始化的QString
QString fromLatin1(const char *str, int size = -1 );
QString fromLatin1(const QByteArray &str);

//1.返回使用8位字符串str的大小为size的字符初始化的QString，size为str的长度，默认为整个字符串
//2.返回使用8位字符串str初始化的QString
QString fromLocal8Bit(const char *str, int size=-1 );
QString fromLocal8Bit(const QByteArray &str);


//构造一个包含字符串 NSString 副本的新QString，仅适用于OS X和iOS
QString fromNSString(const NSString *string);

//构造一个QString,使用数组unicode，大小为size。
//使用该函数创建的字符串不是“\0”结尾，除非原始数据以“\0”结尾
QString fromRawData(const QChar *unicode, int size);

//用std::string创建一个QString副本
QString fromStdString(const std::string &str);

//用UTF-16编码的字符串创建一个QString副本
QString fromStdU16String(const std::u16string &str);

//用UTF-32编码的字符串创建一个QString副本
QString fromStdU32String(const std::u32string &str);

//用wstring(wchar_t组成)创建一个QString副本
QString fromStdWString(const std::wstring &str);

//用UCS-4编码的字符串创建一个QString副本
QString fromUcs4(const uint *unicode, int size=-1);
QString fromUcs4(const char32_t *str, int size=-1);

//用UTF-8编码的字符串创建一个QString副本
QString fromUtf8(const char *str, int size=-1);
QString fromUtf8(const QByteArray &str);

//用UTF-16编码的字符串创建一个QString副本
QString fromUtf16(const ushort *unicode, int size=-1);
QString fromUtf16(const char16_t *str, int size=-1);

//用wchar_t字符串指针创建一个QString副本
QString fromWCharArray(const wchar_t *str, int size=-1);

//QString转换为CFString
CFStringRef toCFString() const;

//返回折叠等效字符串的大小写。对于大多数Unicode字符，与toLower相同
QString toCaseFolded() const;

//从QString创建NSString 。NSString是自动释放的。此功能仅适用于OS X和iOS
NSString* toNSString() const;

//一个纯文本字符串转换为HTML字符串HTML元字符<，>，&，并"通过HTML实体取代
QString toHtmlEscaped() const;

//返回类型为Latin-1的QByteArray
QByteArray toLatin1() const;

//返回8位编码的QByteArray，一般用来存储中文
QByteArray toLocal8Bit() const;

//返回UTF-8编码的QByteArray
QByteArray toUtf8() const;

//使用此QString对象中包含的数据填充数组。该阵列在wchar_t为2字节宽的平台（例如windows）上以UTF-16编码，在wchar_t为4字节宽的平台（大多数Unix系统）上以UCS-4编码
int toWCharArray(wchar_t *) const;

//返回一个std :: string对象
std::string toStdString() const;

//返回一个std :: u16string对象
std::u16string toStdU16String() const;

//返回一个std :: u32string对象
std::u32string toStdU32String() const;

//返回一个std :: wstring对象
std::wstring toStdWString() const;

//转换为double
double toDouble(bool *) const

//转换为float
float toFloat(bool *) const;

//第二个参数指示以何种进制表示，默认10进制

//转换为int
int toInt(bool *, int ) const;

//转换为short
short toShort(bool *, int ) const;

//转换为long
long toLong(bool *, int ) const;

//转换为long long
qlonglong toLongLong(bool *, int ) const;

//转换为uint
uint toUInt(bool *, int ) const;

//转换为ushort
ushort toUShort(bool *, int ) const;

//转换为ulong
ulong toULong(bool *, int ) const;

//转换为ulonglong
qulonglong toULongLong(bool *, int ) const;

//返回字符串的UCS-4 / UTF-32表示形式的QVector 
QVector toUcs4() const;

//返回字符串的大写形式或小写形式
QString toUpper() const;
QString toLower() const;

操作符重载

bool operator!=(QLatin1String ) const;
bool operator!=(const char *) const;
bool operator!=(const QByteArray &) const;

bool operator==(QLatin1String ) const;
bool operator==(const char *) const;
bool operator==(const QByteArray &) const;

QString& operator+=(const QString &);
QString& operator+=(QChar );
QString& operator+=(const QStringRef &);
QString& operator+=(QLatin1String );
QString& operator+=(const char *);
QString& operator+=(const QByteArray &);
QString& operator+=(char );

QString& operator=(const QString &);
QString& operator=(QChar );
QString& operator=(QLatin1String );
QString& operator=(QString &&);
QString& operator=(const char *);
QString& operator=(const QByteArray &);
QString& operator=(char );
QString& operator=(const Null &);

bool operator<(QLatin1String ) const;
bool operator<(const char *) const;
bool operator<(const QByteArray &) const;

bool operator<=(QLatin1String ) const;
bool operator<=(const char *) const;
bool operator<=(const QByteArray &) const;


bool operator>(QLatin1String ) const;
bool operator>(const char *) const;
bool operator>(const QByteArray &) const;

bool operator>=(QLatin1String ) const;
bool operator>=(const char *) const;
bool operator>=(const QByteArray &) const;

QCharRef operator[](int );
const QChar operator[](int ) const;
const QChar operator[](uint ) const;
QCharRef operator[](uint );