QString类参考

QString类参考

QString类提供了一个Unicode文本和经典的C以零结尾的字符数组的抽象。 详情请见……

#include <qstring.h>

所有成员函数的列表。

公有成员

• QString ()
• QString ( QChar ch )
• QString ( const QString & s )
• QString ( const QByteArray & ba )
• QString ( const QChar * unicode, uint length )
• QString ( const char * str )
• ~QString ()
• QString & operator= ( const QString & s )
• QString & operator= ( const char * str )
• QString & operator= ( const QCString & cs )
• QString & operator= ( QChar c )
• QString & operator= ( char c )
• bool isNull () const
• bool isEmpty () const
• uint length () const
• void truncate ( uint newLen )
• QString & fill ( QChar c, int len = -1 )
• QString copy () const  (obsolete)
• QString arg ( long a, int fieldwidth = 0, int base = 10 ) const
• QString arg ( ulong a, int fieldwidth = 0, int base = 10 ) const
• QString arg ( int a, int fieldwidth = 0, int base = 10 ) const
• QString arg ( uint a, int fieldwidth = 0, int base = 10 ) const
• QString arg ( short a, int fieldwidth = 0, int base = 10 ) const
• QString arg ( ushort a, int fieldwidth = 0, int base = 10 ) const
• QString arg ( char a, int fieldwidth = 0 ) const
• QString arg ( QChar a, int fieldwidth = 0 ) const
• QString arg ( const QString & a, int fieldwidth = 0 ) const
• QString arg ( double a, int fieldwidth = 0, char fmt = 'g', int prec = -1 ) const
• QString & sprintf ( const char * cformat, ... )
• int find ( QChar c, int index = 0, bool cs = TRUE ) const
• int find ( char c, int index = 0, bool cs = TRUE ) const
• int find ( const QString & str, int index = 0, bool cs = TRUE ) const
• int find ( const QRegExp & rx, int index = 0 ) const
• int find ( const char * str, int index = 0 ) const
• int findRev ( QChar c, int index = -1, bool cs = TRUE ) const
• int findRev ( char c, int index = -1, bool cs = TRUE ) const
• int findRev ( const QString & str, int index = -1, bool cs = TRUE ) const
• int findRev ( const QRegExp & rx, int index = -1 ) const
• int findRev ( const char * str, int index = -1 ) const
• int contains ( QChar c, bool cs = TRUE ) const
• int contains ( char c, bool cs = TRUE ) const
• int contains ( const char * str, bool cs = TRUE ) const
• int contains ( const QString & str, bool cs = TRUE ) const
• int contains ( const QRegExp & rx ) const
• enum SectionFlags { SectionDefault = 0x00, SectionSkipEmpty = 0x01, SectionIncludeLeadingSep = 0x02, SectionIncludeTrailingSep = 0x04, SectionCaseInsensitiveSeps = 0x08 }
• QString section ( QChar sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
• QString section ( char sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
• QString section ( const char * sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
• QString section ( const QString & sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const
• QString section ( const QRegExp & reg, int start, int end = 0xffffffff, int flags = SectionDefault ) const
• QString left ( uint len ) const
• QString right ( uint len ) const
• QString mid ( uint index, uint len = 0xffffffff ) const
• QString leftJustify ( uint width, QChar fill = ' ', bool truncate = FALSE ) const
• QString rightJustify ( uint width, QChar fill = ' ', bool truncate = FALSE ) const
• QString lower () const
• QString upper () const
• QString stripWhiteSpace () const
• QString simplifyWhiteSpace () const
• QString & insert ( uint index, const QString & s )
• QString & insert ( uint index, const QChar * s, uint len )
• QString & insert ( uint index, QChar c )
• QString & insert ( uint index, char c )
• QString & append ( char ch )
• QString & append ( QChar ch )
• QString & append ( const QString & str )
• QString & prepend ( char ch )
• QString & prepend ( QChar ch )
• QString & prepend ( const QString & s )
• QString & remove ( uint index, uint len )
• QString & replace ( uint index, uint len, const QString & s )
• QString & replace ( uint index, uint len, const QChar * s, uint slen )
• QString & replace ( const QRegExp & rx, const QString & str )
• short toShort ( bool * ok = 0, int base = 10 ) const
• ushort toUShort ( bool * ok = 0, int base = 10 ) const
• int toInt ( bool * ok = 0, int base = 10 ) const
• uint toUInt ( bool * ok = 0, int base = 10 ) const
• long toLong ( bool * ok = 0, int base = 10 ) const
• ulong toULong ( bool * ok = 0, int base = 10 ) const
• float toFloat ( bool * ok = 0 ) const
• double toDouble ( bool * ok = 0 ) const
• QString & setNum ( short n, int base = 10 )
• QString & setNum ( ushort n, int base = 10 )
• QString & setNum ( int n, int base = 10 )
• QString & setNum ( uint n, int base = 10 )
• QString & setNum ( long n, int base = 10 )
• QString & setNum ( ulong n, int base = 10 )
• QString & setNum ( float n, char f = 'g', int prec = 6 )
• QString & setNum ( double n, char f = 'g', int prec = 6 )
• void setExpand ( uint index, QChar c )  (obsolete)
• QString & operator+= ( const QString & str )
• QString & operator+= ( QChar c )
• QString & operator+= ( char c )
• QChar at ( uint i ) const
• QChar operator[] ( int i ) const
• QCharRef at ( uint i )
• QCharRef operator[] ( int i )
• QChar constref ( uint i ) const
• QChar & ref ( uint i )
• const QChar * unicode () const
• const char * ascii () const  (obsolete)
• const char * latin1 () const
• QCString utf8 () const
• QCString local8Bit () const
• bool operator! () const
• operator const char * () const
• QString & setUnicode ( const QChar * unicode, uint len )
• QString & setUnicodeCodes ( const ushort * unicode_as_ushorts, uint len )
• QString & setLatin1 ( const char * str, int len = -1 )
• int compare ( const QString & s ) const
• int localeAwareCompare ( const QString & s ) const
• void compose ()
• const char * data () const  (obsolete)
• bool startsWith ( const QString & s ) const
• bool endsWith ( const QString & s ) const
• void setLength ( uint newLen )

静态公有成员

• QString number ( long n, int base = 10 )
• QString number ( ulong n, int base = 10 )
• QString number ( int n, int base = 10 )
• QString number ( uint n, int base = 10 )
• QString number ( double n, char f = 'g', int prec = 6 )
• QString fromLatin1 ( const char * chars, int len = -1 )
• QString fromUtf8 ( const char * utf8, int len = -1 )
• QString fromLocal8Bit ( const char * local8Bit, int len = -1 )
• int compare ( const QString & s1, const QString & s2 )
• int localeAwareCompare ( const QString & s1, const QString & s2 )

相关函数

• bool operator== ( const QString & s1, const QString & s2 )
• bool operator== ( const QString & s1, const char * s2 )
• bool operator== ( const char * s1, const QString & s2 )
• bool operator!= ( const QString & s1, const QString & s2 )
• bool operator!= ( const QString & s1, const char * s2 )
• bool operator!= ( const char * s1, const QString & s2 )
• bool operator< ( const QString & s1, const char * s2 )
• bool operator< ( const char * s1, const QString & s2 )
• bool operator<= ( const QString & s1, const char * s2 )
• bool operator<= ( const char * s1, const QString & s2 )
• bool operator> ( const QString & s1, const char * s2 )
• bool operator> ( const char * s1, const QString & s2 )
• bool operator>= ( const QString & s1, const char * s2 )
• bool operator>= ( const char * s1, const QString & s2 )
• const QString operator+ ( const QString & s1, const QString & s2 )
• const QString operator+ ( const QString & s1, const char * s2 )
• const QString operator+ ( const char * s1, const QString & s2 )
• const QString operator+ ( const QString & s, char c )
• const QString operator+ ( char c, const QString & s )
• QDataStream & operator<< ( QDataStream & s, const QString & str )
• QDataStream & operator>> ( QDataStream & s, QString & str )

---

详细描述

QString类提供了一个Unicode文本和经典的C以零结尾的字符数组的抽象。

QString使用隐含共享，这使它非常有效率并且很容易使用。

所有的QString的方法都使用const char *参数，const char *被解释为经典的C风格的以零结尾的ASCII字符串。所以const char *参数为0是合法的。如果const char *不是以零结尾的，结果是不确定的。把经典的C字符串复制到QString的函数将不会复制结尾的0字符。QString的QChar数组（可以通过unicode()返回）通常不以零结尾。如果你需要把QString传递到一个需要C的以零结尾的字符串，请使用latin1()。

没有分配任何东西的QString是零，也就是长度和数据指针都为0。引用空字符串（“”，一个单一的'\0'字符）的QString是空。零和空这两个QString在方法中都是合法的。把(const char *) 0赋值给QString给定了一个零QString。为了方便，QString::null是一个零QString。当排序的时候，空字符串在最前面，然后是非空字符串，然后才是零字符串。我们建议使用if ( !str.isNull() )，而不是if ( !str )来检测非零字符串，关于解释说明也可以参考operator!()。

注意如果你发现你正在混合使用QCString、QString和QByteArray，这将会导致很多不必要的复制并且也许会预示着你正在处理的真实自然数据是不确定的。如果数据是以零结尾的八位数据，请使用QCString；如果它是没有结尾的（也就是包含0）八位数据，请使用QByteArray；如果它是文本，请使用QString。

字符串列表可以使用QStringList类来处理。你可以使用QStringList::split()来把一个字符串分割为一个字符串列表，并且可以使用QStringList::join()把一个字符串列表连接成一个使用随意间隔符的字符串。你也可以使用QStringList::grep()从一个字符串列表中获得包含特定子字符串或者包含匹配特定的regex的字符串列表。

C程序员的注意事项

由于C++的类型系统和QString是隐含共享的事实，QString也许会被看做整型或者其它简单基本类型。例如：

   QString boolToString( bool b )

    {

       QString result;

       if ( b )

           result = "True";

       else

           result = "False";

       return result;

    }

 

变量result是一个分配在栈中的自动变量。当return被调用时，因为我们正在返回值，复制构造函数被调用并且这个字符串的一个复制被返回。（我们要感谢隐含共享，没有实际的复制发生，请看下面。）

在Qt的源代码中，你将会遇到想这样的QString的用法：

   QString func( const QString& input )

    {

       QString output = input;

       // 处理输出

       return output;

    }

 

从input到output的“复制”几乎和复制指针一样快，因为后面的场景复制是通过增加引用计数器来实现的。QString操作是基于写时复制的，只有在实例发生实际改变时，才会被复制。

如果你想不丢失任何Unicode信息的情况下创建一个QString的深度复制，那么你应该使用QString中用QChar*作为参数的构造函数。例如：

   QString a("abcd");

   QString b( a.unicode(),b.length());

 

另外，使用QString中用constchar*参数的构造函数就足够了。例如：

   QString a("abcd");

   QString b( a.latin1());

 

也可以参考QChar、QCString、QByteArray、QConstString、隐含和明显共享类、文本相关类和非图形用户界面类。

---

成员类型文档

QString::SectionFlags

• QString::SectionDefault - 空的部分被考虑，开始的和结尾的分隔符不被包含并且区分大小写来比较分隔符。
• QString::SectionSkipEmpty - 把空的部分看做就像它们不存在一样，也就是说它们不被考虑为有关的start和end。
• QString::SectionIncludeLeadingSep - 在结果字符串中包含开始的分隔符（如果有的话）。
• QString::SectionIncludeTrailingSep - 在结果字符串中包含末尾的分隔符（如果有的话）。
• QString::SectionCaseInsensitiveSeps - 不区分大小写来比较分隔符。

最后的四个值可以被或运算在一起来形成一个标记。

也可以参考section()。

---

成员函数文档

QString::QString ()

构造一个零字符串。这是一个不被分配任何东西的字符串，也就是说长度和数据指针都为0。

也可以参考isNull()。

QString::QString ( QChar ch )

构造一个长度为一个字符，内容为给定字符ch的字符串。

QString::QString (const QString & s)

构造一个s的隐含共享的复制。这是短时间的，因为引用计数被使用。

QString::QString (const QByteArray & ba)

构造一个被解释为经典C字符串的ba的深度复制的字符串。

QString::QString (const QChar * unicode,uint length )

构造一个QChar数组中开始length个字符的深度复制的字符串。

如果unicode和length为0，那么一个零字符串被创建。

如果只是unicode为0，字符串为空，但是被分配为length个字符空间——无论如何QString可以自动扩展，但是这也许会在一些情况下提高速度。我们建议根据这个目的使用简单的构造函数和setLength()，因为它的结果是有更多的可读代码。

也可以参考isNull()和setLength()。

QString::QString (const char * str )

构造一个被解释为经典C字符串的str的深度复制的字符串。

如果str，那么一个零字符串被创建。

这是一个抛出构造函数，但是它是完全安全的：把一个Latin1的constchar*转化到QString保存了所有的信息。当你编译你的应用程序时，你可以通过定义QT_NO_CAST_ASCII来关闭这个构造函数。你可以使用setLatin1()、fromLatin1()、fromLocal8Bit()和fromUtf8()来生成QString。或者无论什么适合你的八位数据的编码方式。

也可以参考isNull()。

QString::~QString ()

销毁这个字符串并且如果这是这个字符串的最后一个复制，就释放“真实的”字符串。

QString &QString::append ( const QString & str)

把str添加到字符串中并且返回结果的引用。

   string = "Test";

   string.append( "ing" );       // string == "Testing"

 

等于operator+=()。

实例：dirview/dirview.cpp。

QString &QString::append ( char ch )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

把字符ch添加到字符串中并且返回结果的引用。

等于operator+=()。

QString &QString::append ( QChar ch )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

把字符ch添加到字符串中并且返回结果的引用。

等于operator+=()。

QStringQString::arg ( const QString & a,int fieldwidth = 0 ) const

这个函数将返回使用a来替换最低层出现的%i（i为'1'或'2'或……'9'）的字符串。

fieldwidth值指定了填充到a中的最小空间。正值将产生右对齐文本，负值将产生左对齐文本。

   QString firstName( "Joe" );

   QString lastName( "Bloggs" );

   QString fullName;

   fullName = QString("First name is '%1', last name is '%2'" )

              .arg( firstName )

              .arg( lastName );

 

    //fullName == First name is 'Joe', last name is 'Bloggs'

 

警告：如果你是用arg()来构造一个想上面实例中的“真正”的句子，那么这可能导致一些翻译的问题（当你使用tr()函数时）。

如果没有%i模式，一个警告信息（qWarning()）被输出并且这个文本被添加到字符串的末尾。这被做为错误恢复的功能并且不应该在正确的代码中出现。

也可以参考QObject::tr()。

QStringQString::arg ( long a, int fieldwidth = 0,int base = 10 ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

fieldwidth值指定了填充到a中的最小空间。正值将产生右对齐文本，负值将产生左对齐文本。

a被基于base表示，默认为10，并且必须在2到36之间。

   QString str;

    str= QString("Decimal 63 is %1 inhexadecimal" )

         .arg( 63, 0, 16 );

    //str == "Decimal 63 is 3fin hexadecimal"

 

QStringQString::arg ( ulong a, int fieldwidth = 0,int base = 10 ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

a被基于base表示，默认为10，并且必须在2到36之间。

QStringQString::arg ( int a, int fieldwidth = 0,int base = 10 ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

a被基于base表示，默认为10，并且必须在2到36之间。

QStringQString::arg ( uint a, int fieldwidth = 0,int base = 10 ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

a被基于base表示，默认为10，并且必须在2到36之间。

QStringQString::arg ( short a, int fieldwidth = 0,int base = 10 ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

a被基于base表示，默认为10，并且必须在2到36之间。

QStringQString::arg ( ushort a, int fieldwidth = 0,int base = 10 ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

a被基于base表示，默认为10，并且必须在2到36之间。

QStringQString::arg ( char a, int fieldwidth = 0 ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

a被假设在Latin1字符集中。

QStringQString::arg ( QChar a,int fieldwidth = 0 ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

QStringQString::arg ( double a, int fieldwidth = 0,char fmt = 'g', int prec = -1 ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

根据fmt指定的格式，参数a被格式化，g为默认情况并且可以为下列之一：

• e - 格式化为[-]9.9e[+|-]999
• E - 格式化为[-]9.9E[+|-]999
• f - 格式化为[-]9.9
• g - 使用e或f格式，看哪一个更简练
• G - 使用E或f格式，看哪一个更简练

在所有的情况下，小数点之后数字的个数等于prec指定的精度。

   double d = 12.34;

   QString ds = QString("'E' format, precision 3, gives %1" )

                 .arg( d, 0, 'E', 3 );

    //ds == "1.234E+001"

 

const char * QString::ascii () const

这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

这个函数简单的调用latin1()并且返回结果。

实例：network/networkprotocol/nntp.cpp。

QCharQString::at ( uint i ) const

返回在索引i处的字符，或者如果i超过字符串的长度返回0。

   const QString string( "abcdefgh" );

    QChar ch = string.at( 4 );

    //ch == 'e'

 

如果QString不是常量（也就是constQString）或者const&（也就是constQString&），那么at()的非常量重载将被用来替代。

QCharRefQString::at ( uint i )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

这个函数返回在索引i处的字符的引用。这个结果引用在这之后可以被分配，或者立即使用，但是一旦超过原字符串进行根多的修改，它将会变为无效。

如果i超过了字符串的长度，那么这个字符串将会被使用QChar::null扩大。

int QString::compare ( const QString & s1,const QString & s2) [静态]

对s1和s2进行词典比较，如果s1小于、等于或者大于s2，就返回小于、等于或者大于0的整数。

这个比较是专有的基于字符的数字Unicode值并且非常快，但是不是人们所期待的。排序用户界面字符串请考虑使用QString::localeAwareCompare()。

    inta = QString::compare("def", "abc" );   //a > 0

    intb = QString::compare("abc", "def" );   //b < 0

    intc = QString::compare("abc", "abc" );   // c == 0

 

int QString::compare ( const QString & s) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

对这个字符串和s进行词典比较，如果它小于、等于或者大于s，就返回小于、等于或者大于0的整数。

void QString::compose ()

注意这个函数在Qt 3.0中不被支持并且仅仅用于实验和说明目的。它主要是关注于阿拉伯的和其它多成分文本的实验。

适用于可能带连字的QString。当多成分文本需要表现缺乏象形字的字体时非常有用，但是它也可以制造像QChar(0x0041)（'A'）和QChar(0x0308)（Unicodeaccent diaresis），给定的QChar(0x00c4)（德语的A元音变音）。

QCharQString::constref ( uint i ) const

返回在索引i处的QChar的值。

等于at(i)。

也可以参考ref()。

int QString::contains ( QChar c,bool cs = TRUE ) const

返回在这个字符串中字符c出现的次数。

如果cs为真，那么匹配是区分大小写的。如果cs为假，那么匹配是不区分大小写的。

   QString string( "Trolltech and Qt" );

    inti = string.contains('t', FALSE );  // i == 3

 

实例：fileiconview/qfileiconview.cpp和mdi/application.cpp。

int QString::contains (char c, bool cs = TRUE ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

int QString::contains (const char * str, bool cs = TRUE ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

返回在这个字符串中字符串str出现的次数。

如果cs为真，那么匹配是区分大小写的。如果cs为假，那么匹配是不区分大小写的。

int QString::contains (const QString & str,bool cs = TRUE ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

返回在这个字符串中str出现的次数。

如果cs为真，那么匹配是区分大小写的。如果cs为假，那么匹配是不区分大小写的。

这个函数计算重叠的字符串，所以在下面的实例中，“bananas”中有两个“ana”的实例。

   QString str( "bananas" );

    inti = str.contains("ana" );  // i == 2

 

也可以参考findRev()。

int QString::contains (const QRegExp & rx) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

返回在字符串中正则表达式rx出现的次数。

这个函数计算重叠的字符串，所以在下面的实例中，有四个“ana”或者“ama”的实例。

   QString str = "banana and panama";

    QRegExp rxp = QRegExp("a[nm]a", TRUE, FALSE );

    inti = str.contains(rxp );    // i == 4

 

也可以参考find()和findRev()。

QStringQString::copy () const

这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

在Qt 2.0和以后的版本中，对这个函数的所有调用都是不需要的。只要移除它们就可以了。

const char * QString::data () const

这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

返回以零结尾的经典的C字符串的指针。

在Qt 1.x中，这将返回按自己顺序允许直接维护的字符串的char*。在Qt 2.x中，QString是一个Unicode字符串，char*变换构造了一个临时字符串，并且因此直接字符处理是没有意义的了。

bool QString::endsWith ( const QString & s) const

如果字符串以s结尾，返回真，否则返回假。

也可以参考startsWith()。

实例：chart/main.cpp。

QString &QString::fill ( QChar c,int len = -1 )

填充字符串为len个字符的值c，并且返回字符串的引用。

如果len为负数（默认），当前字符串长度被使用。

   QString str;

   str.fill('g', 5 );      // string =="ggggg"

 

int QString::find ( const QRegExp & rx,int index = 0 ) const

从位置index开始，找到常量正则表达式rx第一次出现的位置。如果index为-1，搜索从最后一个字符开始，如果是-1，从紧挨着最后一个字符的字符开始，依此类推。（对于反向搜索也可以参考findRev()。）

返回rx第一次出现的位置，如果rx没有被找到，返回-1。

   QString string( "bananas" );

    inti = string.find(QRegExp("an"), 0 );    // i ==1

 

也可以参考findRev()、replace()和contains()。

实例：network/mail/smtp.cpp。

int QString::find ( QChar c,int index = 0, bool cs = TRUE ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

从位置index开始，找到字符c第一次出现的位置。如果index为-1，搜索从最后一个字符开始，如果是-1，从紧挨着最后一个字符的字符开始，依此类推。（对于反向搜索也可以参考findRev()。）

如果cs为真，那么匹配是区分大小写的。如果cs为假，那么匹配是不区分大小写的。

返回c第一次出现的位置，如果c没有被找到，返回-1。

int QString::find ( char c,int index = 0, bool cs = TRUE ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

从位置index开始，找到字符c第一次出现的位置。

如果cs为真，那么匹配是区分大小写的。如果cs为假，那么匹配是不区分大小写的。

int QString::find ( const QString & str,int index = 0, bool cs = TRUE ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

从位置index开始，找到字符串str第一次出现的位置。如果index为-1，搜索从最后一个字符开始，如果是-1，从紧挨着最后一个字符的字符开始，依此类推。（对于反向搜索也可以参考findRev()。）

如果cs为真，那么匹配是区分大小写的。如果cs为假，那么匹配是不区分大小写的。

返回str第一次出现的位置，如果str没有被找到，返回-1。

int QString::find (const char * str, int index = 0 ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

等于find(QString(str),index)。

int QString::findRev (const char * str, int index = -1 ) const

等于findRev(QString(str),index)。

int QString::findRev ( QChar c,int index = -1, bool cs = TRUE ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

从位置index开始并且反向搜索，找到字符c第一次出现的位置。如果index为-1，搜索从最后一个字符开始，如果是-1，从紧挨着最后一个字符的字符开始，依此类推。

返回c第一次出现的位置，如果c没有被找到，返回-1。

如果cs为真，那么匹配是区分大小写的。如果cs为假，那么匹配是不区分大小写的。

   QString string( "bananas" );

    inti = string.findRev('a' );      // i == 5

 

int QString::findRev ( char c,int index = -1, bool cs = TRUE ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

从位置index开始并且反向搜索，找到字符c第一次出现的位置。

如果cs为真，那么匹配是区分大小写的。如果cs为假，那么匹配是不区分大小写的。

int QString::findRev ( const QString & str,int index = -1, bool cs = TRUE ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

从位置index开始并且反向搜索，找到字符串str第一次出现的位置。如果index为-1，搜索从最后一个字符开始，如果是-1，从紧挨着最后一个字符的字符开始，依此类推。

返回str第一次出现的位置，如果str没有被找到，返回-1。

如果cs为真，那么匹配是区分大小写的。如果cs为假，那么匹配是不区分大小写的。

   QString string("bananas");

    inti = string.findRev("ana" );      // i == 3

 

int QString::findRev ( const QRegExp & rx,int index = -1 ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

从位置index开始并且反向搜索，找到正则表达式rx第一次出现的位置。如果index为-1，搜索从最后一个字符开始，如果是-1，从紧挨着最后一个字符的字符开始，依此类推。

返回rx第一次出现的位置，如果rx没有被找到，返回-1。

   QString string( "bananas" );

    inti = string.findRev(QRegExp("an") );      // i == 3

 

也可以参考find()。

QStringQString::fromLatin1 ( const char * chars,int len = -1 ) [静态]

返回从chars的前len个字符解码得到的Unicode字符串，忽略chars的其余字符。如果len为-1，那么chars的长度将被使用。如果len大于chars的长度，那么chars的长度将被使用。

这个和QString(const char*)构造函数一样，但是如果你在编译的时候定义了QT_NO_CAST_ASCII，你可以使那个构造函数不可见，在这种情况下你可以使用这个函数来从Latin-1文本中明显地创建一个QString。

   QString str = QString::fromLatin1("123456789", 5 );

    //str == "12345"

 

实例：listbox/listbox.cpp和network/mail/smtp.cpp。

QStringQString::fromLocal8Bit (const char * local8Bit, int len = -1 ) [静态]

返回从local8Bit的前len个字符解码得到的Unicode字符串，忽略local8Bit的其余字符。如果len为-1，那么local8Bit的长度将被使用。如果len大于chars的长度，那么local8Bit的长度将被使用。

   QString str = QString::fromLocal8Bit("123456789", 5 );

    //str == "12345"

 

local8Bit被假设使用本地指定的格式编码的。

关于Unicode字符串的编码/解码更多变化请参考QTextCodec。

QStringQString::fromUtf8 ( const char * utf8,int len = -1 ) [静态]

返回从utf8的前len个字符解码得到的Unicode字符串，忽略utf8的其余字符。如果len为-1，那么utf8的长度将被使用。如果len大于chars的长度，那么utf8的长度将被使用。

    QStringstr = QString::fromUtf8("123456789", 5 );

    //str == "12345"

 

关于Unicode字符串的编码/解码更多变化请参考QTextCodec。

实例：fonts/simple-qfont-demo/viewer.cpp。

QString &QString::insert ( uint index, const QString & s)

把s插入到字符串的index位置之前。

如果index超过字符串的结尾，字符串被填充空格扩展到index长度并且然后s被添加，返回这个字符串的引用。

   QString string( "I like fish" );

    str= string.insert(2, "don't " );

    //str == "I don't like fish"

 

也可以参考remove()和replace()。

实例：themes/themes.cpp和xform/xform.cpp。

QString &QString::insert ( uint index, const QChar * s,uint len )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

把s中的字符插入到字符串的index位置之前len次并且返回这个字符串的引用。

QString &QString::insert ( uint index, QChar c )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

把c插入到字符串的index位置之前并且返回这个字符串的引用。

如果index超过字符串的结尾，字符串被填充空格（ASCII码为32）扩展到index长度并且然后s被添加，返回这个字符串的引用。

QString &QString::insert ( uint index, char c )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

在index位置插入字符c。

bool QString::isEmpty () const

如果字符串为空，也就是如果length()== 0，返回真。因此，零字符串也是空字符串。

   QString a( "" );

    a.isEmpty();        // 真

    a.isNull();         // 假

 

   QString b;

    b.isEmpty();        // 真

    b.isNull();         // 真

 

也可以参考isNull()和length()。

实例：addressbook/mainwindow.cpp、chart/chartform.cpp、chart/chartform_canvas.cpp、network/networkprotocol/nntp.cpp、qmag/qmag.cpp和qwerty/qwerty.cpp。

bool QString::isNull () const

如果字符串为零，返回真。零字符串总是空的。

   QString a;          // a.unicode()== 0，a.length()== 0

    a.isNull();         // 真，因为a.unicode()== 0

    a.isEmpty();        // 真

 

也可以参考isEmpty()和length()。

实例：i18n/main.cpp和qdir/qdir.cpp。

const char * QString::latin1 () const

返回字符串的Latin-1表述。注意如果字符串包含非Latin-1字符，返回值是不确定的。如果你想把字符串转化为Unicode以为的格式，请参考QTextCodec类。

这个函数主要对于使用Unicode的开机时的老程序有用处。

只要源字符串的一个未修改复制存在，这个结果就保持有效。

也可以参考utf8()和local8Bit()。

实例：fileiconview/qfileiconview.cpp和network/networkprotocol/nntp.cpp。

QStringQString::left ( uint len ) const

返回包含字符串最左面的len个字符的子字符串。

如果len超过字符串的长度，则整个字符串被返回。

   QString s = "Pineapple";

   QString t = s.left( 4);    // t == "Pine"

 

也可以参考right()、mid()和isEmpty()。

实例：themes/themes.cpp。

QStringQString::leftJustify ( uint width, QChar fill = ' ',bool truncate = FALSE ) const

返回一个长度为width的，包含这个字符串，并且用fill填补的字符串。

如果truncate为假并且字符串的长度超过width，那么返回的字符串是这个字符串的复制。

如果truncate为真并且字符串的长度超过width，那么这个字符串的复制中超过width长度的任何字符都被移除并且这个复制被返回。

   QString s( "apple" );

    QString t = s.leftJustify(8, '.' );        // t =="apple..."

 

也可以参考rightJustify()。

uint QString::length () const

返回字符串的长度。

零字符串和空字符串的长度都为0。

也可以参考isNull()和isEmpty()。

实例：fileiconview/qfileiconview.cpp、network/networkprotocol/nntp.cpp、rot13/rot13.cpp和themes/themes.cpp。

QCStringQString::local8Bit () const

返回被编码为本地指定格式的字符串。在X11上，这是QTextCodec::codecForLocale()。在Windows上，它是系统定义的编码方式。在Mac OS X上，总是使用utf8作为编码方式。

关于Unicode字符串的编码/解码更多变化请参考QTextCodec。

也可以参考QString::fromLocal8Bit()、latin1()和utf8()。

int QString::localeAwareCompare( const QString & s1,const QString & s2) [静态]

对s1和s2进行比较，如果s1小于、等于或者大于s2，就返回小于、等于或者大于0的整数。

这个比较是基于本地的并且也是基于平台的方式。使用这个函数可以把排好序的字符串列表呈现给用户。

也可以参考QString::compare()和QTextCodec::locale()。

int QString::localeAwareCompare( const QString & s) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

对这个字符串和s进行比较。

QStringQString::lower () const

返回由这个字符串转换的小写字符串。

   QString string( "TROlltECH" );

    str= string.lower();   // str == "trolltech"

 

也可以参考upper()。

实例：scribble/scribble.cpp。

QStringQString::mid ( uint index, uint len = 0xffffffff )const

返回包含这个字符串从index位置开始len个字符的字符串。

如果这个字符串为空或者index超出范围，返回零。如果index+len超过这个字符串的长度，返回从index开始的整个字符串。

   QString s( "Five pineapples" );

   QString t = s.mid( 5, 4);                  // t =="pine"

 

也可以参考left()和right()。

实例：network/mail/smtp.cpp、qmag/qmag.cpp和themes/themes.cpp。

QStringQString::number ( long n, int base = 10 ) [静态]

一个把数字n转换为字符串的方便函数，n被基于base表示，默认为10，并且必须在2到36之间。

   long a = 63;

    QString str = QString::number(a, 16 );             // str == "3f"

   QString str = QString::number(a, 16 ).upper();     // str == "3F"

 

也可以参考setNum()。

实例：action/application.cpp、application/application.cpp、chart/chartform.cpp、fonts/simple-qfont-demo/viewer.cpp、mdi/application.cpp和sql/overview/extract/main.cpp。

QStringQString::number ( ulong n, int base = 10 ) [静态]

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

也可以参考setNum()。

QStringQString::number ( int n, int base = 10 ) [静态]

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

也可以参考setNum()。

QStringQString::number ( uint n, int base = 10 ) [静态]

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

一个把数字n转换为字符串表示的方便制造函数，n被基于base表示，默认为10，并且必须在2到36之间。

也可以参考setNum()。

QStringQString::number ( double n, char f = 'g',int prec = 6 ) [静态]

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

根据fmt指定的格式，参数n被格式化，g为默认情况并且可以为下列之一：

• e - 格式化为[-]9.9e[+|-]999
• E - 格式化为[-]9.9E[+|-]999
• f - 格式化为[-]9.9
• g - 使用e或f格式，看哪一个更简练
• G - 使用E或f格式，看哪一个更简练

在所有的情况下，小数点之后数字的个数等于prec指定的精度。

   double d = 12.34;

   QString ds = QString("'E' format, precision 3, gives %1" )

                 .arg( d, 0, 'E', 3 );

    //ds == "1.234E+001"

 

也可以参考setNum()。

QString::operatorconst char * () const

返回latin1()。请确定已经看到这里的警告文档。注意对于你希望严格遵守Unicode的新代码，当你编译你的代码时，你可以定义QT_NO_ASCII_CAST宏来隐藏这个函数，这样自动抛出就不会被完成。这样可以添加你可以抓住在operator!()下描述的编程错误的优点。

bool QString::operator! () const

如果它不是零字符串，返回真，否则返回假。

   QString name = getName();

    if( !name )

       name = "Rodney";

 

注意如果你这样做

   QString name = getName();

    if( name )

       doSomethingWith(name);

 

它将调用“operatorconst char*()”，这是没有效率的，当你希望写遵守Unicode的代码时，你可以定义QT_NO_ASCII_CAST宏。

当你想使用上述的语义时，请使用：

   QString name = getName();

    if( !name.isNull())

       doSomethingWith(name);

 

QString &QString::operator+= ( const QString & str)

把str添加到字符串中并且返回结果的引用。

QString &QString::operator+= ( QChar c )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

把字符c添加到字符串中并且返回结果的引用。

QString &QString::operator+= ( char c )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

把字符c添加到字符串中并且返回结果的引用。

QString &QString::operator= ( QChar c )

设置字符串只包含单个字符c。

QString &QString::operator= ( const QString & s)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

把s的一个浅度复制赋值给这个字符串并且返回这个字符串的引用。这是非常快的，因为字符串没有被实际复制。

QString &QString::operator= ( const char * str)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

把解释为经典C字符串的str的一个深度复制赋值给这个字符串并且返回这个字符串的引用。

如果str为0，那么零字符串被创建。

也可以参考isNull()。

QString &QString::operator= ( const QCString & cs)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

把解释为经典C字符串的cs的一个深度复制赋值给这个字符串并且返回这个字符串的引用。

QString &QString::operator= ( char c )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

设置字符串只包含单个字符c。

QCharQString::operator[] ( int i ) const

返回在索引i处的字符，或者如果i超过字符串的长度返回QChar::null。

如果QString不是常量（也就是constQString）或者const&（也就是constQString&），那么operator[]的非常量重载将被使用来替代它。

QCharRefQString::operator[] ( int i )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

这个函数返回在索引i处的字符的引用。这个结果引用可以立即被赋值或者使用，但是一旦初始字符串发生了改变，它将会变为无效。

如果i超过了字符串的长度，那么字符串将会被使用QChar::null来扩展，这样QCharRef就可以引用字符串中的有效（零）字符。

QCharRef内部类可以被常量QChar使用，但是如果你对它赋值，你就会改变初始字符串（它将会自动分离，因为QString是写时复制）。如果你试图把结果作为QChar以外的东西使用，你将得到编译错误。

QString &QString::prepend ( const QString & s)

在字符串开始处插入s并且返回这个字符串的引用。

等于insert(0,s)。

   QString string = "42";

   string.prepend("The answer is " );

    //string == "The answer is 42"

 

也可以参考insert()。

QString &QString::prepend ( char ch )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

在字符串开始处插入ch并且返回这个字符串的引用。

等于insert(0,ch)。

也可以参考insert()。

QString &QString::prepend ( QChar ch )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

在字符串开始处插入ch并且返回这个字符串的引用。

等于insert(0,ch)。

也可以参考insert()。

QChar &QString::ref ( uint i )

返回在索引i的QChar的引用，如果需要就是用QChar::null扩展字符串。这个结果引用可以立即被赋值或者使用，但是一旦初始字符串发生了改变，它将会变为无效。

   QString string("ABCDEF");

    QChar ch = string.ref( 3 );         // ch == 'D'

 

也可以参考constref()。

QString &QString::remove ( uint index, uint len )

从字符串中的index位置开始移除len个字符并且返回这个字符串的引用。

如果index超出字符串的长度，就什么也不发生。如果index在字符串中间，但是index加上len超过字符串的结尾，这个字符串将从index开始被截短。

   QString string( "Montreal");

   string.remove(1, 4 );      // string =="Meal"

 

也可以参考insert()和replace()。

QString &QString::replace ( uint index, uint len,const QString & s)

从字符串中的index位置开始使用s替换len个字符，并且返回这个字符串的引用。

如果index超出字符串的长度，就什么也不被删除并且s被添加到字符串结尾。如果 index有效并且index加上len超过字符串的结尾，那么这个字符串将从index开始被截短，并且s被添加到字符串结尾。

   QString string( "Say yes!" );

   string = string.replace(4, 3, "NO" );

    //string == "Say NO!"

 

也可以参考insert()和remove()。

实例：listviews/listviews.cpp、network/networkprotocol/nntp.cpp和qmag/qmag.cpp。

QString &QString::replace ( uint index, uint len,const QChar * s,uint slen )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

从字符串中的index位置开始使用s中的slen个字符的QChar数据替换len个字符，并且返回这个字符串的引用。

也可以参考insert()和remove()。

QString &QString::replace ( const QRegExp & rx,const QString & str)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

用str替换字符串中出现的每一个正则表达式rx。返回这个字符串的引用。

   QString string = "banana";

   string = string.replace(QRegExp("an"), "" ); // string == "ba"

 

也可以参考find()和findRev()。

QStringQString::right ( uint len ) const

返回包含字符串最右面的len个字符的子字符串。

如果len超过字符串的长度，则整个字符串被返回。

   QString string( "Pineapple" );

   QString t = string.right( 5);   // t == "apple"

 

也可以参考left()、mid()和isEmpty()。

实例：fileiconview/qfileiconview.cpp。

QStringQString::rightJustify ( uint width, QChar fill = ' ',bool truncate = FALSE ) const

返回一个长度为width的，包含fill填补的字符串，后面跟着这个字符串。

如果truncate为假并且字符串的长度超过width，那么返回的字符串是这个字符串的复制。

如果truncate为真并且字符串的长度超过width，那么这个字符串的复制中超过width长度的任何字符都被移除并且这个复制被返回。

   QString string( "apple" );

   QString t = string.rightJustify(8, '.' );  // t == "...apple"

 

也可以参考leftJustify()。

QStringQString::section ( QChar sep,int start, int end = 0xffffffff, int flags = SectionDefault )const

这个函数用来返回字符串的一部分。

这个字符串被看作由字符sep分隔开的顺序的区段。返回的从位置start到位置end（两个都包含）的区段组成的字符串。如果end没有被指定，那么从位置start开始到字符串的结尾的所有区段都被返回。区段是从左面是0、1、2等等计数，或者从右面-1、-2等等计数的。

flags参数可以用来影响这个函数行为的特征，例如是否区分大小写，是否忽略空区段并且如何处理开始和结尾的分隔符，请参考SectionFlags。

   QString csv( "forename,middlename,surname,phone" );

   QString s = csv.section(',', 2, 2 );   // s =="surname"

 

   QString path( "/usr/local/bin/myapp" ); // First field isempty

   QString s = path.section('/', 3, 4 );  // s =="bin/myapp"

   QString s = path.section('/', 3, 3, SectionSkipEmpty ); // s == "myapp"

   

如果start或者end为负数，我们就从字符串的右面开始计数，最右面的是-1，接着是-2，依此类推。

   QString csv( "forename,middlename,surname,phone" );

   QString s = csv.section(',', -3, -2 );  // s =="middlename,surname"

 

   QString path( "/usr/local/bin/myapp" ); // First field isempty

   QString s = path.section('/', -1 ); // s == "myapp"

   

也可以参考QStringList::split()。

实例：chart/element.cpp。

QStringQString::section ( char sep, int start,int end = 0xffffffff, int flags = SectionDefault ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

QStringQString::section ( const char * sep,int start, int end = 0xffffffff, int flags = SectionDefault ) const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

QStringQString::section ( const QString & sep,int start, int end = 0xffffffff, int flags = SectionDefault )const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

这个函数用来返回字符串的一部分。

这个字符串被看作由字符串sep分隔开的顺序的区段。返回的从位置start到位置end（两个都包含）的区段组成的字符串。如果end没有被指定，那么从位置start开始到字符串的结尾的所有区段都被返回。区段是从左面是0、1、2等等计数，或者从右面-1、-2等等计数的。

flags参数可以用来影响这个函数行为的特征，例如是否区分大小写，是否忽略空区段并且如何处理开始和结尾的分隔符，请参考SectionFlags。

   QString data( "forename**middlename**surname**phone" );

   QString s = data.section("**", 2, 2 ); // s == "surname"

   

如果start或者end为负数，我们就从字符串的右面开始计数，最右面的是-1，接着是-2，依此类推。

   QString data( "forename**middlename**surname**phone" );

   QString s = data.section("**", -3, -2 ); // s == "middlename**surname"

   

也可以参考QStringList::split()。

QStringQString::section ( const QRegExp & reg,int start, int end = 0xffffffff, int flags = SectionDefault )const

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

这个函数用来返回字符串的一部分。

这个字符串被看作由正则表达式reg分隔开的顺序的区段。返回的从位置start到位置end（两个都包含）的区段组成的字符串。如果end没有被指定，那么从位置start开始到字符串的结尾的所有区段都被返回。区段是从左面是0、1、2等等计数，或者从右面-1、-2等等计数的。

flags参数可以用来影响这个函数行为的特征，例如是否区分大小写，是否忽略空区段并且如何处理开始和结尾的分隔符，请参考SectionFlags。

   QString line( "forename\tmiddlename surname \t \t phone" );

    QRegExp sep("\s+" );

   QString s = line.section(sep, 2, 2 ); // s == "surname"

   

如果start或者end为负数，我们就从字符串的右面开始计数，最右面的是-1，接着是-2，依此类推。

   QString line( "forename\tmiddlename surname \t \t phone" );

    QRegExp sep("\\s+" );

   QString s = line.section(sep, -3, -2 ); // s == "middlename surname"

   

警告： QRegExp这一部分比其它字符串和字符的重载版本要花费更多。

也可以参考QStringList::split()和simplifyWhiteSpace()。

void QString::setExpand (uint index, QChar c)

这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

设置在index位置的字符为c并且如果需要使用空格来扩展这个字符串。

这个方法在Qt 3.x中是多余的，因为operator[]可以在需要的时候扩展字符串。

QString &QString::setLatin1 ( const char * str,int len = -1 )

设置这个字符串为解释为经典的Latin1的C字符串的str。如果len为-1（默认），那么它将被设置为strlen(str)。

如果str为0，那么零字符串被创建。如果str为“”，那么空字符串被创建。

也可以参考isNull()和isEmpty()。

void QString::setLength (uint newLen )

确保至少newLen个字符被分配给这个字符串，并且设置这个字符串的长度为newLen。任何分配的新空间保留任意的数据。

如果newLen为0，那么这个字符串将变为空，除非这个字符串是零，这种情况下它仍保持为零。

如果不能分配足够的内存，字符串保持不变。

这个函数总是把这个字符串和有同样数据的其它引用分离。

这个函数对于需要构建一个长字符创并且想避免重复重新分配空间的代码很有用。在这个实例中，我们想添加字符串，直到条件为真，并且我们十分确信分配给它的大小是足够大的：

   QString result;

    intresultLength = 0;

   result.setLength(newLen ) // 分配一些空间

   while ( ... ) {

       result[resultLength++] = ... // 填充（部分的）空格作为数据

    }

   result.truncate[resultLength]; // 并且去掉不确定的垃圾

 

如果newLen是不足的话，最坏的情况就是将会循环将会变慢。

也可以参考truncate()、isNull()、isEmpty()和length()。

QString &QString::setNum ( long n, int base = 10 )

设置字符串为打印的数据n，n是基于base并且返回这个字符串的引用。

base默认为10并且必须在2到36之间。

   QString string;

   string = string.setNum(1234 );     // string == "1234"

 

QString &QString::setNum ( short n, int base = 10 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。设置字符串为打印的数据n，n是基于base并且返回这个字符串的引用。

base默认为10并且必须在2到36之间。

QString &QString::setNum ( ushort n, int base = 10 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。设置字符串为打印的数据n，n是基于base并且返回这个字符串的引用。

base默认为10并且必须在2到36之间。

QString &QString::setNum ( int n, int base = 10 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。设置字符串为打印的数据n，n是基于base并且返回这个字符串的引用。

base默认为10并且必须在2到36之间。

QString &QString::setNum ( uint n, int base = 10 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。设置字符串为打印的数据n，n是基于base并且返回这个字符串的引用。

base默认为10并且必须在2到36之间。

QString &QString::setNum ( ulong n, int base = 10 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。设置字符串为打印的数据n，n是基于base并且返回这个字符串的引用。

base默认为10并且必须在2到36之间。

QString &QString::setNum ( float n, char f = 'g',int prec = 6 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

设置字符串为打印的由格式f和精度prec格式化的数据n并且返回这个字符串的引用。

格式f可以为“f”、“F”、“e”、“E”、“g”或者“G”。关于这些格式的解释请参考arg()。

QString &QString::setNum ( double n, char f = 'g',int prec = 6 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

设置字符串为打印的由格式f和精度prec格式化的数据n并且返回这个字符串的引用。

格式f可以为“f”、“F”、“e”、“E”、“g”或者“G”。关于这些格式的解释请参考arg()。

QString &QString::setUnicode ( const QChar * unicode,uint len )

重新定义字符串的大小为len并且把unicode复制到字符串中。如果unicode为零，什么都不被复制，但是字符串还是被重新定义为len。如果len为0，那么字符串变为零字符串。

也可以参考setLatin1()和isNull()。

QString &QString::setUnicodeCodes (const ushort * unicode_as_ushorts, uint len )

重新定义字符串的大小为len并且把unicode_as_ushorts复制到字符串中（在一些X11客户端平台上这将进入到二进制缓存通道中）。

如果unicode_as_ushorts为零，什么都不被复制，但是字符串还是被重新定义为len。如果len为0，那么字符串变为零字符串。

也可以参考setLatin1()和isNull()。

QStringQString::simplifyWhiteSpace () const

返回一个移除了这个字符串的开始和结尾的空白符号的字符串，并且内部的空白符号都被替代为单一的空格。

空白符号是指任何QChar::isSpace()返回真的字符。这里面包括十进制为9（TAB）、10（LF）、11（VT）、12（FF）、13（CR）和32（Space）的UNICODE字符。

   QString string = "  lots\tof\nwhite    space ";

   QString t = string.simplifyWhiteSpace();

    //t == "lots of white space"

 

也可以参考stripWhiteSpace()。

QString &QString::sprintf ( const char * cformat, ...)

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

%s转义序列希望一个utf8()编码字符串。格式化字符串cformat希望是一个Latin1的。如果你需要一个Unicode格式字符串，使用arg()来替代。为了完全支持Unicode的类型安全的字符串构建，你可以像这样使用QTextOStream：

   QString str;

   QString s = ...;

    intx = ...;

   QTextOStream( &str ) << s << " : " << x;

 

对于翻译，特别是如果字符串包含超过一个的转义序列，你应该考虑使用arg()来替代它。这将允许翻译者来控制替换的顺序并且支持Unicode。

也可以参考arg()。

实例：dclock/dclock.cpp、forever/forever.cpp、layout/layout.cpp、qmag/qmag.cpp、scrollview/scrollview.cpp、tooltip/tooltip.cpp和xform/xform.cpp。

bool QString::startsWith (const QString & s) const

如果字符串以s开始，返回真，否则返回假。

   QString string("Bananas");

   bool a = string.startsWith("Ban");      //  a== TRUE

 

也可以参考endsWith()。

QStringQString::stripWhiteSpace () const

返回一个移除了这个字符串的开始和结尾的空白符号的字符串，并且内部的空白符号都被替代为单一的空格。

空白符号是指任何QChar::isSpace()返回真的字符。这里面包括十进制为9（TAB）、10（LF）、11（VT）、12（FF）、13（CR）和32（Space）的UNICODE字符。

   QString string = "   whitespace   ";

   QString s = string.stripWhiteSpace();       // s == "white space"

 

也可以参考simplifyWhiteSpace()。

double QString::toDouble (bool * ok = 0 ) const

返回由这个字符串转化的double值。

如果转化发生错误，*ok被设置为假（除非ok为0，这是默认的）并且0被返回。否则*ok被设置为真。

   QString string( "1234.56" );

   double a = string.toDouble();   // a == 1234.56

 

也可以参考number()。

float QString::toFloat (bool * ok = 0 ) const

返回由这个字符串转化的float值。

如果转化发生错误，*ok被设置为假（除非ok为0，这是默认的）并且0被返回。否则*ok被设置为真。

也可以参考number()。

int QString::toInt (bool * ok = 0, int base = 10 ) const

返回由这个字符串转化的int值，是基于base的，默认为10并且必须在2到36之间。

如果转化发生错误，*ok被设置为假（除非ok为0，这是默认的）并且0被返回。否则*ok被设置为真。

   QString str( "FF" );

   bool ok;

    inthex = str.toInt(&ok, 16 );     // hex == 255, ok ==TRUE

    intdec = str.toInt(&ok, 10 );     // dec == 0, ok ==FALSE

 

也可以参考number()。

long QString::toLong (bool * ok = 0, int base = 10 ) const

返回由这个字符串转化的long值，是基于base的，默认为10并且必须在2到36之间。

如果转化发生错误，*ok被设置为假（除非ok为0，这是默认的）并且0被返回。否则*ok被设置为真。

也可以参考number()。

short QString::toShort (bool * ok = 0, int base = 10 ) const

返回由这个字符串转化的short值，是基于base的，默认为10并且必须在2到36之间。

如果转化发生错误，*ok被设置为假（除非ok为0，这是默认的）并且0被返回。否则*ok被设置为真。

uint QString::toUInt (bool * ok = 0, int base = 10 ) const

返回由这个字符串转化的unsigned int值，是基于base的，默认为10并且必须在2到36之间。

如果转化发生错误，*ok被设置为假（除非ok为0，这是默认的）并且0被返回。否则*ok被设置为真。

也可以参考number()。

ulong QString::toULong (bool * ok = 0, int base = 10 ) const

返回由这个字符串转化的unsigned long值，是基于base的，默认为10并且必须在2到36之间。

如果转化发生错误，*ok被设置为假（除非ok为0，这是默认的）并且0被返回。否则*ok被设置为真。

也可以参考number()。

ushort QString::toUShort (bool * ok = 0, int base = 10 ) const

返回由这个字符串转化的unsigned short值，是基于base的，默认为10并且必须在2到36之间。

如果转化发生错误，*ok被设置为假（除非ok为0，这是默认的）并且0被返回。否则*ok被设置为真。

void QString::truncate (uint newLen )

如果newLen小于字符串的长度，那么字符串将从newLen位置被截短。否则就什么也不发生。

   QString s = "truncate me";

    s.truncate(5 );            // s == "trunc"

 

也可以参考setLength()。

实例：network/mail/smtp.cpp。

const QChar * QString::unicode () const

返回这个字符串的Unicode表述。直到这个字符串被修改，这个结果保持有效。

QStringQString::upper () const

返回由这个字符串转换的大写字符串。

   QString string( "TeXt" );

    str= string.upper();     // t == "TEXT"

 

也可以参考lower()。

实例：scribble/scribble.cpp和sql/overview/custom1/main.cpp。

QCStringQString::utf8 () const

返回按UTF8格式编码的字符串。

关于Unicode字符串的编码/解码更多变化请参考QTextCodec。

也可以参考QString::fromUtf8()、local8Bit()和latin1()。

---

相关函数

bool operator!= ( const QString & s1,const QString & s2)

如果s1在词典中不等于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) != 0。

bool operator!= (const QString & s1,const char * s2 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

如果s1在词典中不等于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) != 0。

bool operator!= (const char * s1, const QString & s2)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

如果s1在词典中不等于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) != 0。

const QString operator+ ( const QString & s1,const QString & s2)

返回字符串s1和字符串s2连接的结果的字符串。

等于s1.append(s2)。

const QString operator+ ( const QString & s1,const char * s2 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

返回字符串s1和字符串s2连接的结果的字符串。

等于s1.append(s2)。

const QString operator+ ( const char * s1, const QString & s2)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

返回字符串s1和字符串s2连接的结果的字符串。

const QString operator+ ( const QString & s,char c )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

返回字符串s和字符c连接的结果的字符串。

等于s.append(c)。

const QString operator+ ( char c, const QString & s)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

返回字符c和字符串s连接的结果的字符串。

等于s.prepend(c)。

bool operator< ( const QString & s1,const char * s2 )

如果s1在词典中小于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) < 0。

bool operator< (const char * s1, const QString & s2)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

如果s1在词典中小于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) < 0。

QDataStream &operator<< ( QDataStream & s,const QString & str)

把字符串str写到流s中。

也可以参考QDataStream操作符的格式。

bool operator<= (const QString & s1,const char * s2 )

如果s1在词典中小于或等于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2)<= 0。

bool operator<= (const char * s1, const QString & s2)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

如果s1在词典中小于或等于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2)<= 0。

bool operator== ( const QString & s1,const QString & s2)

如果s1在词典中等于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) != 0。

bool operator== (const QString & s1,const char * s2 )

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

如果s1在词典中等于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) != 0。

bool operator== (const char * s1, const QString & s2)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

如果s1在词典中等于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) != 0。

bool operator> ( const QString & s1,const char * s2 )

如果s1在词典中大于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) > 0。

bool operator> (const char * s1, const QString & s2)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

如果s1在词典中大于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) > 0。

bool operator>= (const QString & s1,const char * s2 )

如果s1在词典中大于或等于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) >= 0。

bool operator>= (const char * s1, const QString & s2)

这是一个重载成员函数，提供了方便。它的行为基本上和上面的函数相同。

如果s1在词典中大于或等于s2，返回真，否则如果不是，返回假。这个比较是区分大小写的。注意一个零字符串不等于一个非零的空字符串。

等于compare(s1,s2) >= 0。

QDataStream &operator>> ( QDataStream & s,QString & str)

从流s中读取一个字符串到字符串str中。

也可以参考QDataStream操作符的格式。

 

 

 

 

 

 

 

 

 

 

 

 

 

#include<string>

#include<iostream>

#include <qstring>

 

 

 

QString TransFileClientThread::bytetoaddstr(quint8 *buf)

            {quint8 hex1;

              quint8  hex2;

              quint8  hex3;

              quint8  hex4;

              QString addstr("");

            quint16 add1=buf[10];

               quint16 v1=add1/16;

                quint16 v2=add1%16;

               //将商转成字母

                 if(v1>=0&&v1<=9);

               hex1=(quint8)(48+v1);

                 else

                  hex1=(quint8)(55+v1);

                 //将余数转成字母

               if(v2>=0&&v2<=9);

                 hex2=(quint8)(48+v2);

                 else

                    hex2=(quint8)(55+v2);

               quint16 add2=buf[9];

               quint16 v1=add2/16;

                quint16 v2=add2%16;

               //将商转成字母

                 if(v1>=0&&v1<=9);

               hex3=(quint8)(48+v1);

                 else

                  hex3=(quint8)(55+v1);

                 //将余数转成字母

               if(v2>=0&&v2<=9);

                 hex4=(quint8)(48+v2);

                 else

                    hex4=(quint8)(55+v2);

               addstr=hex1+hex2+hex3+hex4;

                 returnaddstr;

              }

              /*准备发送的字节转换成进制字符串*/

QString TransFileClientThread::bytetoHexstr(quint8 *buf,quint16 Bytes)

              {

                 QString hexstr("");

                 for(int i=0;i<Bytes;i++)

                 {

               quint8  hex1;

               quint8  hex2;

               quint16 value=buf[i];

                 quint16 v1=value/16;

                quint16 v2=value%16;

                 //将商转成字母

                 if(v1>=0&&v1<=9);

               hex1=(quint8)(48+v1);

                 else

                  hex1=(quint8)(55+v1);

                 //将余数转成字母

                if(v2>=0&&v2<=9);

                 hex2=(quint8)(48+v2);

                  else

                    hex2=(quint8)(55+v2);

                 //将字母连接成串

                  hexstr+=hex1+hex2+"\0";

                  }

                  returnhexstr;

             }

QString TransFileClientThread::assemblestrCommand()

              { QString strReturn;

                QString strCommand("<?xmlversion=&quot;1.0&quot;encoding=&quot;gbk&quot; ?> ");

                strCommand.append("<para><rtuAddress>");

             strCommand.append(ZDDZM);

                strCommand.append("</rtuAddress><frameContent>");

              strCommand.append(XFYMNR);

                strCommand.append("</frameContent><timeOut>100000</timeOut><needResponse>1</needResponse></para>");

                strReturn =Service.sendSourceFrameByRtuAddress (strCommand); //????编译怎么通过呢

                returnstrReturn;

              }

if (sendProc())

         {   

            /*将终端地址取出来转换成字符串*/

            QString  ZDDZM;

              QString  XFYMNR;

              QString  Return;

              ZDDZM=bytetoaddstr(sendbuf);

              XFYMNR=bytetoHexstr(sendbuf,sendBytes);

              Return=assemblestrCommand();

              if ( !Return.isNull() )         //检测非零字符串

              //if(Return.length() >0  )

            {

                        QString Rcvstr("");

                       //quint8*Pbuf;

                        int i= Return.find( QRegExp("/frameContent"),0 );

                      Return.remove(i, i );

                        FHYMNR=data.section( "<frameContent>", 1, 1 );

                       {       

                         quint16     len=0;

                         quint8      str[1600];

                         len=  FHYMNR.length();

                         strcpy((quint8*)(str),FHYMNR);

                        //FHYMNR.ReleaseBuffer();

                         for(i=0;i<len;i+=3)

                        {

                          if((str[i]>47)&&(str[i]<58))

                                  {str[i]-=48;}

                        elseif((str[i]>64)&&(str[i]<71))

                                {str[i]-=55;}

                        elseif((str[i]>96)&&(str[i]<103))

                                {str[i]-=87;}

                        else  {return -1;}

                        if((str[i+1]>47)&&(str[i+1]<58))

                                 {str[i+1]-=48;}

                        elseif((str[i+1]>64)&&(str[i+1]<71))

                               {str[i+1]-=55;}

                        elseif((str[i+1]>96)&&(str[i+1]<103))

                               {str[i+1]-=87;}

                        else  {return -1;}

                         }

                        i=0;

                         while(i<len)

                        {str[j]=(((str[i]<<4)&&f0)|(str[i+1]&&0f));

                          i+=3;

                          j++;

                         }

                      }

              }

 

 

           //bool TransData(QString FHYMNR)

            //int    i=0;j=0;

            //pbuf=TransData(Rcvstr)

          

 

 

 

        

 

 

             

          /*

           <?xmlversion="1.0" encoding="gbk" ?>

<result>

     <terAddress>ZDDZM</terAddress>

     <frameContent>FHYMNR</frameContent>

</result>

 

 

 

 

 

           IsEmpty(expression)

          如果expression含有多个变量，则IsEmpty 总是返回False。IsEmpty 只返回对variant 表达式有意义的信息。

 

 

          strReturn :=Service. sendSourceFrameByRtuAddress (strCommand);

         <?xmlversion="1.0" encoding="gbk" ?>

<para> 

<rtuAddress>ZDDZM</rtuAddress>

 <frameContent>  XFYMNR</frameContent>

  <!-- 原帧调试超时时间-->

 <timeOut>100000</timeOut>  

  <!-- 是否需要等待终端响应1：需要0：不需要-->

 <needResponse>1</needResponse>

</para>

             

             

             

               1. QString str = "User: "; 

   2. str += userName +"\n";

 

QString的append()函数则提供了类似的操作，例如：

 

   1. str = "User:"; 

   2. str.append(userName); 

   3.str.append("\n");

 

   string ="Test";

    string.append("ing" );        // string =="Testing"

 

等于operator+=()。

 

&apos; ' 单引号

&quot; " 双引号

 

 

 

 

<?xml version="1.0" encoding="gbk"?>

<result>

     <terAddress>ZDDZM</terAddress>

     <frameContent>FHYMNR</frameContent>

</result>

 

 

 

*/

             

 

 

 

          

          

          

          

          

          

          

          

          

          

          

          

          }

 

 

 

 

 

       

 

 

 

 

 

 

 

 

 

 

 

 

    int ret = tcpClient.write((char*)(sendBuf), sendBytes);

              if (tcpClient.waitForBytesWritten(timeOut2))   /*必须使用该方式才可以(阻塞)发送成功*/

              {

                   writePktToLog(0,sendBuf, sendBytes);

                  

                   sendStat = false;

                   recvStat = true;

                  

                   recvSyncFlag = false;

                   recvCount = 0;

                   recvBytes = 0;

                   recvBuf[0] = 0xfe;

                   recvBuf[1] = 0xfe;

              }

              else if (ret < 0)

              {

                   emit updateTransInfo(tmnlAddr,8, tr("发送出错"));

                   writeLogFile(LogSys,tr("Socket发送出错!"));

                   stopped = true;

              }

         }