Question

QCString类提供了一个经典C语言的以零结尾的字符数组（char *）的抽象。 详情请见……

#include <qcstring.h>

继承了QByteArray。

所有成员函数的列表。

公有成员

• QCString ()
• QCString ( intsize )
• QCString ( constQCString&s )
• QCString ( constchar*str )
• QCString ( constchar*str, uintmaxsize )
• QCString & operator= ( constQCString&s )
• QCString & operator= ( constchar*str )
• bool isNull () const
• bool isEmpty () const
• uint length () const
• bool resize ( uintlen )
• bool truncate ( uintpos )
• bool fill ( charc, intlen = -1 )
• QCString copy () const
• QCString & sprintf ( constchar*format, ... )
• int find ( charc, intindex = 0, boolcs = TRUE ) const
• int find ( constchar*str, intindex = 0, boolcs = TRUE ) const
• int find ( constQRegExp&rx, intindex = 0 ) const
• int findRev ( charc, intindex = -1, boolcs = TRUE ) const
• int findRev ( constchar*str, intindex = -1, boolcs = TRUE ) const
• int findRev ( constQRegExp&rx, intindex = -1 ) const
• int contains ( charc, boolcs = TRUE ) const
• int contains ( constchar*str, boolcs = TRUE ) const
• int contains ( constQRegExp&rx ) const
• QCString left ( uintlen ) const
• QCString right ( uintlen ) const
• QCString mid ( uintindex, uintlen = 0xffffffff ) const
• QCString leftJustify ( uintwidth, charfill = ' ', booltruncate = FALSE ) const
• QCString rightJustify ( uintwidth, charfill = ' ', booltruncate = FALSE ) const
• QCString lower () const
• QCString upper () const
• QCString stripWhiteSpace () const
• QCString simplifyWhiteSpace () const
• QCString & insert ( uintindex, constchar*s )
• QCString & insert ( uintindex, charc )
• QCString & append ( constchar*str )
• QCString & prepend ( constchar*s )
• QCString & remove ( uintindex, uintlen )
• QCString & replace ( uintindex, uintlen, constchar*str )
• QCString & replace ( constQRegExp&rx, constchar*str )
• short toShort ( bool*ok = 0 ) const
• ushort toUShort ( bool*ok = 0 ) const
• int toInt ( bool*ok = 0 ) const
• uint toUInt ( bool*ok = 0 ) const
• long toLong ( bool*ok = 0 ) const
• ulong toULong ( bool*ok = 0 ) const
• float toFloat ( bool*ok = 0 ) const
• double toDouble ( bool*ok = 0 ) const
• QCString & setStr ( constchar*str )
• QCString & setNum ( shortn )
• QCString & setNum ( ushortn )
• QCString & setNum ( intn )
• QCString & setNum ( uintn )
• QCString & setNum ( longn )
• QCString & setNum ( ulongn )
• QCString & setNum ( floatn, charf = 'g', intprec = 6 )
• QCString & setNum ( doublen, charf = 'g', intprec = 6 )
• bool setExpand ( uintindex, charc )
• operator const char * () const
• QCString & operator+= ( constchar*str )
• QCString & operator+= ( charc )

相关函数

• void * qmemmove ( void*dst, constvoid*src, uintlen )
• char * qstrdup ( constchar*src )
• char * qstrcpy ( char*dst, constchar*src )
• char * qstrncpy ( char*dst, constchar*src, uintlen )
• int qstrcmp ( constchar*str1, constchar*str2 )
• int qstrncmp ( constchar*str1, constchar*str2, uintlen )
• int qstricmp ( constchar*str1, constchar*str2 )
• int qstrnicmp ( constchar*str1, constchar*str2, uintlen )
• QDataStream & operator<< ( QDataStream&s, constQCString&str )
• QDataStream & operator>> ( QDataStream&s, QCString&str )
• bool operator== ( constQCString&s1, constQCString&s2 )
• bool operator== ( constQCString&s1, constchar*s2 )
• bool operator== ( constchar*s1, constQCString&s2 )
• bool operator!= ( constQCString&s1, constQCString&s2 )
• bool operator!= ( constQCString&s1, constchar*s2 )
• bool operator!= ( constchar*s1, constQCString&s2 )
• bool operator< ( constQCString&s1, constchar*s2 )
• bool operator< ( constchar*s1, constQCString&s2 )
• bool operator<= ( constQCString&s1, constchar*s2 )
• bool operator<= ( constchar*s1, constQCString&s2 )
• bool operator> ( constQCString&s1, constchar*s2 )
• bool operator> ( constchar*s1, constQCString&s2 )
• bool operator>= ( constQCString&s1, constchar*s2 )
• bool operator>= ( constchar*s1, constQCString&s2 )
• const QCString operator+ ( constQCString&s1, constQCString&s2 )
• const QCString operator+ ( constQCString&s1, constchar*s2 )
• const QCString operator+ ( constchar*s1, constQCString&s2 )
• const QCString operator+ ( constQCString&s, charc )
• const QCString operator+ ( charc, constQCString&s )

---

详细描述

QCString类提供了一个经典C语言的以零结尾的字符数组（char *）的抽象。

QCString继承了QByteArray，后者是被QMemArray<char>这样定义的。

因为QCString是一个QMemArray，它使用了带引用计数的明显共享。

你可以在从不暴露给用户的文本中使用QCString。对于用户可见的文本，你应该使用QString（它提供隐含共享、Unicode和其它国际化支持。

注意QCString是Qt中比较薄弱的类，它的设计是有缺陷的（它试图在行为上变为更方便的const char *）并且作为结果，QCString使用的所有算法经常执行得很差。例如，因为append()扫描一个零结束符，所以它是O(length())，这也严重地影响着很多使用QCString的算法。

注意对于使用const char *参数的QCString的方法，如果QCString不是以零结尾的，结果是不确定的。const char *参数为0是合法的。

没有分配任何事物的QCString是零，也就是长度和数据指针都是0。一个引用空字符串（“”，单一的'\0'字符）的QCString是空。在方法中，零和空QCString都是合法参数。把const char * 0分配给QCString就给定了一个零QCString。

length()函数返回字符串的长度，resize()重新定义字符串的大小并且truncate()截短字符串。字符串可以使用fill()来用一个字符填充。使用leftJustify()和rightJustify()在字符串的左面或者右面填补字符。使用find()和findRev()可以搜索字符、字符串和正则表达式，并且使用contains()来计数。

字符串和字符可以通过insert()来插入并且通过append()来添加。字符串可以通过prepend()在前面添加。字符串中的字符可以通过remove()来移除并且通过replace()来替换。

字符串的一部分可以使用left()、right()和mid()来提取。空白符号可以使用stripWhiteSpace()和simplifyWhiteSpace()来移除。字符串可以使用upper()和lower()分别转换为大写或小写。

包含数字的字符串可以使用toShort()、toInt()、toLong()、toULong()、toFloat()和toDouble()来被转换为数字。数字可以使用setNum()来被转换为字符串。

很多操作符被重载以用来为QCString工作。QCString也支持更多的不明显的功能，例如sprintf()、setStr()和setExpand()。

在字符比较上请注意

在QCString中，大写和小写的字符大于或者小于另一个依赖于本地的字符。这个影响支持不区分大小写选项的或者比较大写或者小写参数的函数。如果两个字符串都只包含ACSII码，不区分大小写的操作和比较将是正确的。（如果$LC_CTYPE被设置，绝大多数Unix系统都会做“正确的事情”。）受这个影响的函数包括contains()、find()、findRev()、operator<()、operator<=()、operator>()、operator>=()、lower()和upper()。

性能注意：使用QRegExp进行搜索的QCString方法通过把QCString转换为QString来重新实现的并且在它上面执行搜索的。这意味着QCString数据的深复制。如果你要在一个大的QCString中执行许多QRegExp的搜索，你最好自己把QCString转换为QString并且在QString中进行搜索可以得到更好的执行效果。

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

---

成员函数文档

QCString::QCString ()

构造一个零字符串。

也可以参考isNull()。

QCString::QCString ( intsize )

构造一个空间为size字符，包括'\0'结尾符的字符串。如果size == 0，这就是一个零字符串。

如果size > 0，那么字符串的第一个和最后一个字符被初始化为'\0'.。所有其它字符没有被初始化。

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

QCString::QCString ( constQCString&s )

构造一个s的浅复制。

也可以参考assign()。

QCString::QCString ( constchar*str )

构造一个str的深复制。

如果str0，那么零字符串被创建。

也可以参考isNull()。

QCString::QCString ( constchar*str, uintmaxsize )

构造一个str的深复制，包括'\0'结尾符不超过maxsize字节。

实例：

    QCString str( "helloworld", 6 ); // 把“hello”分配给str
  

如果str在开始的maxsize字节中包含一个0字节，那么结果QCString将被这个0结束。如果str0，那么零字符串被创建。

也可以参考isNull()。

QCString& QCString::append ( constchar*str )

把字符串str添加到字符串末尾并且返回这个字符串的引用。等于operator+=()。

int QCString::contains ( charc, boolcs = TRUE ) const

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

如果cs为真，匹配就区分大小写，或者如果cs为假，就不区分大小写。

也可以参考Note on character comparisons。

int QCString::contains ( constchar*str, boolcs = TRUE ) const

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

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

如果cs为真，匹配就区分大小写，或者如果cs为假，就不区分大小写。

这个函数对子字符串重叠计数，例如，“banana”包含两个“ana”。

也可以参考findRev()和Note on character comparisons。

int QCString::contains ( constQRegExp&rx ) const

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

字符串中rx出现的重叠计数。

实例：

    QString s = "banana and panama";
    QRegExp r = QRegExp( "a[nm]a", TRUE, FALSE );
    s.contains( r ); // 4个匹配项
  

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

QCString QCString::copy () const

返回这个字符串的深复制。

也可以参考detach()。

bool QCString::fill ( charc, intlen = -1 )

在字符串中填充len个字节的字符c和一个'\0'结束符。

如果len为负数，那么当前的字符串长度被使用。

返回假就是len为非负数并且没有足够的空间来重新定义字符串的大小，否则就返回真。

int QCString::find ( charc, intindex = 0, boolcs = TRUE ) const

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

如果cs为真，搜索是区分大小写的，否则如果cs为假，就不区分大小写。

返回c的位置，或者如果c没有被发现，返回-1。

也可以参考Note on character comparisons。

实例：network/networkprotocol/nntp.cpp。

int QCString::find ( constchar*str, intindex = 0, boolcs = TRUE ) const

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

在字符串中从index位置开始，找到字符串str第一次出现的位置。

如果cs为真，搜索是区分大小写的，否则如果cs为假，就不区分大小写。

返回str的位置，或者如果str没有被发现，返回-1。

也可以参考Note on character comparisons。

int QCString::find ( constQRegExp&rx, intindex = 0 ) const

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

在字符串中从index位置开始，找到正则表达式rx第一次出现的位置。

返回下一个匹配的位置，如果rx没有被发现，返回-1。

int QCString::findRev ( charc, intindex = -1, boolcs = TRUE ) const

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

如果cs为真，搜索是区分大小写的，否则如果cs为假，就不区分大小写。

返回c的位置，或者如果c没有被发现，返回-1。

也可以参考Note on character comparisons。

int QCString::findRev ( constchar*str, intindex = -1, boolcs = TRUE ) const

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

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

如果cs为真，搜索是区分大小写的，否则如果cs为假，就不区分大小写。

返回str的位置，或者如果str没有被发现，返回-1。

也可以参考Note on character comparisons。

int QCString::findRev ( constQRegExp&rx, intindex = -1 ) const

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

在字符串中从index位置开始并且反向搜索，找到正则表达式rx第一次出现的位置。

返回下一个匹配的位置（反向），如果rx没有被发现，返回-1。

QCString& QCString::insert ( uintindex, charc )

在字符串的index位置插入字符c并且返回字符串的引用。

如果index超出字符串的结尾，字符串被使用空格（ASCII 32）延伸到index长度，然后c被添加。

实例：

    QCString s = "Yes";
    s.insert( 3, '!');                          // s == "Yes!"
  

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

QCString& QCString::insert ( uintindex, constchar*s )

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

在字符串的index位置插入字符串s并且返回字符串的引用。

如果index超出字符串的结尾，字符串被使用空格（ASCII 32）延伸到index长度，然后s被添加。

    QCString s = "I like fish";
    s.insert( 2, "don't "); // s == "I don't like fish"

    s = "x";                // index 01234
    s.insert( 3, "yz" );    // s == "x  yz"
  

bool QCString::isEmpty () const

如果字符串为空，例如如果length() == 0，返回真。空字符串不总是零字符串。

请参考isNull()中的实例。

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

bool QCString::isNull () const

如果字符串为零，例如如果data() == 0，返回真。零字符串也是空字符串。

实例：

    QCString a;         // a.data() == 0,  a.size() == 0, a.length() == 0
    QCString b == "";   // b.data() == "", b.size() == 1, b.length() == 0
    a.isNull();         // TRUE，因为a.data() == 0
    a.isEmpty();        // TRUE，因为a.length() == 0
    b.isNull();         // FALSE，因为 b.data() == ""
    b.isEmpty();        // TRUE，因为b.length() == 0
  

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

QCString QCString::left ( uintlen ) const

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

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

实例：

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

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

实例：network/networkprotocol/nntp.cpp。

QCString QCString::leftJustify ( uintwidth, charfill = ' ', booltruncate = FALSE ) const

返回一个长度为width的（为了结束符'\0'加一），包含这个字符串，并且用fill填补的字符串。

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

如果truncate为真并且字符串的长度超过width，那么返回的字符串是left(width)。

实例：

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

也可以参考rightJustify()。

uint QCString::length () const

返回字符串的长度，除了'\0'结束符。等于strlen(data())。

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

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

实例：network/networkprotocol/nntp.cpp。

QCString QCString::lower () const

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

实例：

    QCString s("Credit");
    QCString t = s.lower();                     // t == "credit"
  

也可以参考upper()和Note on character comparisons。

QCString QCString::mid ( uintindex, uintlen = 0xffffffff ) const

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

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

实例：

    QCString s = "Two pineapples";
    QCString t = s.mid( 4, 3 );                 // t == "pin"
  

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

实例：network/networkprotocol/nntp.cpp。

QCString::operator const char * () const

返回字符串数据。

QCString& QCString::operator+= ( constchar*str )

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

QCString& QCString::operator+= ( charc )

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

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

QCString& QCString::operator= ( constQCString&s )

把s的一个浅度复制赋值给这个字符串并且返回这个字符串的引用。

QCString& QCString::operator= ( constchar*str )

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

把str的一个深度复制赋值给这个字符串并且返回这个字符串的引用。

如果str为0，一个零字符串就被创建。

也可以参考isNull()。

QCString& QCString::prepend ( constchar*s )

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

也可以参考insert()。

QCString& QCString::remove ( uintindex, uintlen )

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

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

    QCString s = "Montreal";
    s.remove( 1, 4 );
    // s == "Meal"
  

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

实例：network/networkprotocol/nntp.cpp。

QCString& QCString::replace ( uintindex, uintlen, constchar*str )

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

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

    QCString s = "Say yes!";
    s.replace( 4, 3, "NO" );                    // s == "Say NO!"
  

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

QCString& QCString::replace ( constQRegExp&rx, constchar*str )

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

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

实例：

    QString s = "banana";
    s.replace( QRegExp("a.*a"), "" );           // 变为“b”

    s = "banana";
    s.replace( QRegExp("^[bn]a"), " " );        // 变为“ nana”

    s = "banana";
    s.replace( QRegExp("^[bn]a"), "" );         // 注意！变为“”
  

最后一个例子可能很令人惊奇。正则表达式的语义重复地应用于这个字符串，所以首先最开始的“ba”被移除了，接着是“na”，然后是最后的“na”，剩下的就是一个空字符串了。

bool QCString::resize ( uintlen )

扩展或者收缩字符串到len字节，包括'\0'结束符。

'\0'结束符被设置在len - 1位置，除非len == 0。

实例：

    QCString s = "resize this string";
    s.resize( 7 );                              // s == "resize"
  

也可以参考truncate()。

实例：network/networkprotocol/nntp.cpp。

QCString QCString::right ( uintlen ) const

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

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

实例：

    QCString s = "Pineapple";
    QCString t = s.right( 5 );                  // t == "apple"
  

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

实例：network/networkprotocol/nntp.cpp。

QCString QCString::rightJustify ( uintwidth, charfill = ' ', booltruncate = FALSE ) const

返回一个长度为width的（为了结束符'\0'加一），包含fill填补的字符串，后面跟着这个字符串。

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

如果truncate为真并且字符串的长度超过width，那么返回的字符串是right(width).。

实例：

    QCString s("pie");
    QCString t = s.rightJustify(8, '.');                // t == ".....pie"
  

也可以参考leftJustify()。

bool QCString::setExpand ( uintindex, charc )

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

如果index超出范围并且如果字符串不能被扩大，返回假，否则为真。

QCString& QCString::setNum ( doublen, charf = 'g', intprec = 6 )

设置字符串为数字n的字符表示并且返回字符串的引用。

字符表示的格式由格式字符f指定，并且精度（小数点之后的位数）由prec指定。

有效的f的格式为'e'、'E'、'f'、'g'和'G'。和sprintf()的格式相同，在QString::arg()中有它们的解释。

QCString& QCString::setNum ( shortn )

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

设置字符串为数字n的字符表示并且返回字符串的引用。

QCString& QCString::setNum ( ushortn )

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

设置字符串为数字n的字符表示并且返回字符串的引用。

QCString& QCString::setNum ( intn )

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

设置字符串为数字n的字符表示并且返回字符串的引用。

QCString& QCString::setNum ( uintn )

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

设置字符串为数字n的字符表示并且返回字符串的引用。

QCString& QCString::setNum ( longn )

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

设置字符串为数字n的字符表示并且返回字符串的引用。

QCString& QCString::setNum ( ulongn )

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

设置字符串为数字n的字符表示并且返回字符串的引用。

QCString& QCString::setNum ( floatn, charf = 'g', intprec = 6 )

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

QCString& QCString::setStr ( constchar*str )

把str的一个深度复制赋值给这个字符串并且返回这个字符串的引用。

QCString QCString::simplifyWhiteSpace () const

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

空白符号是指十进制ASCII码为9、10、11、12、13和32。

    QCString s = "  lots\t of\nwhite    space ";
    QCString t = s.simplifyWhiteSpace(); // t == "lots of white space"
  

也可以参考stripWhiteSpace()。

QCString& QCString::sprintf ( constchar*format, ... )

重新实现为本地的vsprintf()的一个调用（请参考你的C库的手册）。

如果字符串小于256字符，这个sprintf()调用resize(256)来减少内存的占用。在sprintf()返回之前，字符串被重新定义为它实际的长度。

实例：

    QCString s;
    s.sprintf( "%d - %s", 1, "first" );         // result < 256 字符

    QCString big( 25000 );                      // 很长的字符串
    big.sprintf( "%d - %s", 2, longString );    // result < 25000 字符
  

警告： limit. 如果format规格和参数比目标字符串常，所有的vsprintf()实现将会越过目标字符串（*this）进行写操作，并且如果目标字符串比一些任意实现限制长，会有一些失败。

把用户给定的参数传给sprintf()会导致一些问题。迟早会有一些人将会把3000个字符的行传给你的应用程序。

QCString QCString::stripWhiteSpace () const

返回一个移除了这个字符串的开始和结尾的空白符号的字符串。

空白符号是指十进制ASCII码为9、10、11、12、13和32。

实例：

    QCString s = " space ";
    QCString t = s.stripWhiteSpace();           // t == "space"
  

也可以参考simplifyWhiteSpace()。

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

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

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

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

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

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

int QCString::toInt ( bool*ok = 0 ) const

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

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

long QCString::toLong ( bool*ok = 0 ) const

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

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

short QCString::toShort ( bool*ok = 0 ) const

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

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

uint QCString::toUInt ( bool*ok = 0 ) const

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

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

ulong QCString::toULong ( bool*ok = 0 ) const

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

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

ushort QCString::toUShort ( bool*ok = 0 ) const

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

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

bool QCString::truncate ( uintpos )

在pos位置截短字符串。

等于调用resize(pos+1)。

实例：

    QCString s = "truncate this string";
    s.truncate( 5 );                            // s == "trunc"
  

也可以参考resize()。

QCString QCString::upper () const

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

实例：

    QCString s( "Debit" );
    QCString t = s.upper();                     // t == "DEBIT"
  

也可以参考lower()和Note on character comparisons。

---

相关函数

bool operator!= ( constQCString&s1, constQCString&s2 )

如果s1和s2不同，返回真，否则返回假。

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

bool operator!= ( constQCString&s1, constchar*s2 )

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

如果s1和s2不同，返回真，否则返回假。

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

bool operator!= ( constchar*s1, constQCString&s2 )

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

如果s1和s2不同，返回真，否则返回假。

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

constQCString operator+ ( constQCString&s1, constQCString&s2 )

返回由s1和s2串联组成的字符串。

constQCString operator+ ( constQCString&s1, constchar*s2 )

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

返回由s1和s2串联组成的字符串。

constQCString operator+ ( constchar*s1, constQCString&s2 )

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

返回由s1和s2串联组成的字符串。

constQCString operator+ ( constQCString&s, charc )

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

返回由s和c串联组成的字符串。

constQCString operator+ ( charc, constQCString&s )

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

返回由c和s串联组成的字符串。

bool operator< ( constQCString&s1, constchar*s2 )

如果s1小于s2，返回真，否则返回假。

等于qstrcmp(s1, s2) < 0。

也可以参考有关字符比较的注意。

bool operator< ( constchar*s1, constQCString&s2 )

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

如果s1小于s2，返回真，否则返回假。

等于qstrcmp(s1, s2) < 0。

也可以参考有关字符比较的注意。

QDataStream& operator<< ( QDataStream&s, constQCString&str )

把字符串str写到流s中。

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

bool operator<= ( constQCString&s1, constchar*s2 )

如果s1小于等于s2，返回真，否则返回假。

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

也可以参考有关字符比较的注意。

bool operator<= ( constchar*s1, constQCString&s2 )

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

如果s1小于等于s2，返回真，否则返回假。

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

也可以参考有关字符比较的注意。

bool operator== ( constQCString&s1, constQCString&s2 )

如果s1和s2相等，返回真，否则返回假。

等于qstrcmp(s1, s2) == 0。

bool operator== ( constQCString&s1, constchar*s2 )

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

如果s1和s2相等，返回真，否则返回假。

等于qstrcmp(s1, s2) == 0。

bool operator== ( constchar*s1, constQCString&s2 )

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

如果s1和s2相等，返回真，否则返回假。

等于qstrcmp(s1, s2) == 0。

bool operator> ( constQCString&s1, constchar*s2 )

如果s1大于s2，返回真，否则返回假。

等于qstrcmp(s1, s2) > 0。

也可以参考有关字符比较的注意。

bool operator> ( constchar*s1, constQCString&s2 )

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

如果s1大于s2，返回真，否则返回假。

等于qstrcmp(s1, s2) > 0。

也可以参考有关字符比较的注意。

bool operator>= ( constQCString&s1, constchar*s2 )

如果s1大于等于s2，返回真，否则返回假。

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

也可以参考有关字符比较的注意。

bool operator>= ( constchar*s1, constQCString&s2 )

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

如果s1大于等于s2，返回真，否则返回假。

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

也可以参考有关字符比较的注意。

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

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

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

void * qmemmove ( void*dst, constvoid*src, uintlen )

这个函数通常是C库的一部分。Qt为不支持它的平台实现了memmove()。

memmove()从src中复制len字节到dst。甚至src重叠dst，数据都可以被正确复制。

int qstrcmp ( constchar*str1, constchar*str2 )

一个安全的strcmp()函数。

比较str1和str2。如果str1小于str2，返回一个负值，如果str1等于str2，返回0或者如果str1大于str2返回一个正值。

特例一：如果str1和str2都为零，返回0。

特例二：如果str1为零或者str2为零（但不全是），返回一个随机非零值。

也可以参考qstrncmp()、qstricmp()、qstrnicmp()和有关字符比较的注意。

char * qstrcpy ( char*dst, constchar*src )

一个安全的strcpy()函数。

把src中一直到'\0'的字符（包含它）的字符复制到dst中并且返回dst的指针。

char * qstrdup ( constchar*src )

返回一个复制的字符串。

为src的副本分配空间，复制并且返回副本的指针。如果src为零，它立即返回0。

返回的字符串需要使用delete[]来删除。

int qstricmp ( constchar*str1, constchar*str2 )

一个安全的stricmp()函数。

忽略大小写比较str1和str2。

如果str1小于str2，返回一个负值，如果str1等于str2，返回0或者如果str1大于str2返回一个正值。

特例一：如果str1和str2都为零，返回0。

特例二：如果str1为零或者str2为零（但不全是），返回一个随机非零值。

也可以参考qstrcmp()、qstrncmp()、qstrnicmp()和有关字符比较的注意。

int qstrncmp ( constchar*str1, constchar*str2, uintlen )

一个安全的strncmp()函数。

比较str1和str2一直到len字节。

如果str1小于str2，返回一个负值，如果str1等于str2，返回0或者如果str1大于str2返回一个正值。

特例一：如果str1和str2都为零，返回0。

特例二：如果str1为零或者str2为零（但不全是），返回一个随机非零值。

也可以参考qstrcmp()、qstricmp()、qstrnicmp()和有关字符比较的注意。

char * qstrncpy ( char*dst, constchar*src, uintlen )

一个安全的strncpy()函数。

从src中复制一直到len字节的全部字符（或者如果src更短就更少）复制到dst中并且返回dst的指针。保证dst是'\0'结尾的。如果src或dst为零，立即返回0。

也可以参考qstrcpy()。

int qstrnicmp ( constchar*str1, constchar*str2, uintlen )

一个安全的strnicmp()函数。

忽略大小写，比较str1和str2一直到len字节。

如果str1小于str2，返回一个负值，如果str1等于str2，返回0或者如果str1大于str2返回一个正值。

特例一：如果str1和str2都为零，返回0。

特例二：如果str1为零或者str2为零（但不全是），返回一个随机非零值。

也可以参考qstrcmp()、qstrncmp()、qstricmp()和有关字符比较的注意。