qcstring man page on aLinux

Man page or keyword search:  
man Server   7435 pages
apropos Keyword Search (all sections)
Output format
aLinux logo
[printable version]

QCString(3qt)							 QCString(3qt)

NAME
       QCString - Abstraction of the classic C zero-terminated char array
       (char *)

SYNOPSIS
       All the functions in this class are reentrant when Qt is built with
       thread support.</p>

       #include <qcstring.h>

       Inherits QByteArray.

   Public Members
       QCString ()
       QCString ( int size )
       QCString ( const QCString & s )
       QCString ( const char * str )
       QCString ( const char * str, uint maxsize )
       QCString & operator= ( const QCString & s )
       QCString & operator= ( const char * str )
       bool isNull () const
       bool isEmpty () const
       uint length () const
       bool resize ( uint len )
       bool truncate ( uint pos )
       bool fill ( char c, int len = -1 )
       QCString copy () const
       QCString & sprintf ( const char * format, ... )
       int find ( char c, int index = 0, bool cs = TRUE ) const
       int find ( const char * str, int index = 0, bool cs = TRUE ) const
       int find ( const QRegExp & rx, int index = 0 ) const
       int findRev ( char c, int index = -1, bool cs = TRUE ) const
       int findRev ( const char * str, int index = -1, bool cs = TRUE ) const
       int findRev ( const QRegExp & rx, int index = -1 ) const
       int contains ( char c, bool cs = TRUE ) const
       int contains ( const char * str, bool cs = TRUE ) const
       int contains ( const QRegExp & rx ) const
       QCString left ( uint len ) const
       QCString right ( uint len ) const
       QCString mid ( uint index, uint len = 0xffffffff ) const
       QCString leftJustify ( uint width, char fill = ' ', bool truncate =
	   FALSE ) const
       QCString rightJustify ( uint width, char fill = ' ', bool truncate =
	   FALSE ) const
       QCString lower () const
       QCString upper () const
       QCString stripWhiteSpace () const
       QCString simplifyWhiteSpace () const
       QCString & insert ( uint index, const char * s )
       QCString & insert ( uint index, char c )
       QCString & append ( const char * str )
       QCString & prepend ( const char * s )
       QCString & remove ( uint index, uint len )
       QCString & replace ( uint index, uint len, const char * str )
       QCString & replace ( const QRegExp & rx, const char * str )
       QCString & replace ( char c, const char * after )
       QCString & replace ( const char * before, const char * after )
       QCString & replace ( char c1, char c2 )
       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 ( const char * str )
       QCString & setNum ( short n )
       QCString & setNum ( ushort n )
       QCString & setNum ( int n )
       QCString & setNum ( uint n )
       QCString & setNum ( long n )
       QCString & setNum ( ulong n )
       QCString & setNum ( float n, char f = 'g', int prec = 6 )
       QCString & setNum ( double n, char f = 'g', int prec = 6 )
       bool setExpand ( uint index, char c )
       operator const char * () const
       QCString & operator+= ( const char * str )
       QCString & operator+= ( char c )

RELATED FUNCTION DOCUMENTATION
       void * qmemmove ( void * dst, const void * src, uint len )
       char * qstrdup ( const char * src )
       char * qstrcpy ( char * dst, const char * src )
       char * qstrncpy ( char * dst, const char * src, uint len )
       uint qstrlen ( const char * str )
       int qstrcmp ( const char * str1, const char * str2 )
       int qstrncmp ( const char * str1, const char * str2, uint len )
       int qstricmp ( const char * str1, const char * str2 )
       int qstrnicmp ( const char * str1, const char * str2, uint len )
       QDataStream & operator<< ( QDataStream & s, const QCString & str )
       QDataStream & operator>> ( QDataStream & s, QCString & str )
       bool operator== ( const QCString & s1, const QCString & s2 )
       bool operator== ( const QCString & s1, const char * s2 )
       bool operator== ( const char * s1, const QCString & s2 )
       bool operator!= ( const QCString & s1, const QCString & s2 )
       bool operator!= ( const QCString & s1, const char * s2 )
       bool operator!= ( const char * s1, const QCString & s2 )
       bool operator< ( const QCString & s1, const char * s2 )
       bool operator< ( const char * s1, const QCString & s2 )
       bool operator<= ( const QCString & s1, const char * s2 )
       bool operator<= ( const char * s1, const QCString & s2 )
       bool operator> ( const QCString & s1, const char * s2 )
       bool operator> ( const char * s1, const QCString & s2 )
       bool operator>= ( const QCString & s1, const char * s2 )
       bool operator>= ( const char * s1, const QCString & s2 )
       const QCString operator+ ( const QCString & s1, const QCString & s2 )
       const QCString operator+ ( const QCString & s1, const char * s2 )
       const QCString operator+ ( const char * s1, const QCString & s2 )
       const QCString operator+ ( const QCString & s, char c )
       const QCString operator+ ( char c, const QCString & s )

DESCRIPTION
       The QCString class provides an abstraction of the classic C zero-
       terminated char array (char *).

       QCString inherits QByteArray, which is defined as QMemArray<char>.
       Since QCString is a QMemArray, it uses explicit sharing with a
       reference count.

       QCString tries to behave like a more convenient const char *. The price
       of doing this is that some algorithms will perform badly. For example,
       append() is O(length()) since it scans for a null terminator. Although
       you might use QCString for text that is never exposed to the user, for
       most purposes, and especially for user-visible text, you should use
       QString. QString provides implicit sharing, Unicode and other
       internationalization support, and is well optimized.

       Note that for the QCString methods that take a const char * parameter
       the const char * must either be 0 (null) or not-null and '\0' (NUL
       byte) terminated; otherwise the results are undefined.

       A QCString that has not been assigned to anything is null, i.e. both
       the length and the data pointer is 0. A QCString that references the
       empty string ("", a single '\0' char) is empty. Both null and empty
       QCStrings are legal parameters to the methods. Assigning const char * 0
       to QCString produces a null QCString.

       The length() function returns the length of the string; resize()
       resizes the string and truncate() truncates the string. A string can be
       filled with a character using fill(). Strings can be left or right
       padded with characters using leftJustify() and rightJustify().
       Characters, strings and regular expressions can be searched for using
       find() and findRev(), and counted using contains().

       Strings and characters can be inserted with insert() and appended with
       append(). A string can be prepended with prepend(). Characters can be
       removed from the string with remove() and replaced with replace().

       Portions of a string can be extracted using left(), right() and mid().
       Whitespace can be removed using stripWhiteSpace() and
       simplifyWhiteSpace(). Strings can be converted to uppercase or
       lowercase with upper() and lower() respectively.

       Strings that contain numbers can be converted to numbers with
       toShort(), toInt(), toLong(), toULong(), toFloat() and toDouble().
       Numbers can be converted to strings with setNum().

       Many operators are overloaded to work with QCStrings. QCString also
       supports some more obscure functions, e.g. sprintf(), setStr() and
       setExpand().

       <blockquote><p align="center"> Note on Character Comparisons

       In QCString the notion of uppercase and lowercase and of which
       character is greater than or less than another character is locale
       dependent. This affects functions which support a case insensitive
       option or which compare or lowercase or uppercase their arguments. Case
       insensitive operations and comparisons will be accurate if both strings
       contain only ASCII characters. (If $LC_CTYPE is set, most Unix systems
       do "the right thing".) Functions that this affects include contains(),
       find(), findRev(), operator<(), operator<=(), operator>(),
       operator>=(), lower() and upper().

       This issue does not apply to QStrings since they represent characters
       using Unicode. </blockquote>

       Performance note: The QCString methods for QRegExp searching are
       implemented by converting the QCString to a QString and performing the
       search on that. This implies a deep copy of the QCString data. If you
       are going to perform many QRegExp searches on a large QCString, you
       will get better performance by converting the QCString to a QString
       yourself, and then searching in the QString.

       See also Collection Classes, Implicitly and Explicitly Shared Classes,
       Text Related Classes, and Non-GUI Classes.

MEMBER FUNCTION DOCUMENTATION
QCString::QCString ()
       Constructs a null string.

       See also isNull().

QCString::QCString ( int size )
       Constructs a string with room for size characters, including the
       '\0'-terminator. Makes a null string if size == 0.

       If size > 0, then the first and last characters in the string are
       initialized to '\0'. All other characters are uninitialized.

       See also resize() and isNull().

QCString::QCString ( const QCString & s )
       Constructs a shallow copy s.

       See also assign().

QCString::QCString ( const char * str )
       Constructs a string that is a deep copy of str.

       If str is 0 a null string is created.

       See also isNull().

QCString::QCString ( const char * str, uint maxsize )
       Constructs a string that is a deep copy of str. The copy will be at
       most maxsize bytes long including the '\0'-terminator.

       Example:

	   QCString str( "helloworld", 6 ); // assigns "hello" to str

       If str contains a 0 byte within the first maxsize bytes, the resulting
       QCString will be terminated by this 0. If str is 0 a null string is
       created.

       See also isNull().

QCString & QCString::append ( const char * str )
       Appends string str to the string and returns a reference to the string.
       Equivalent to operator+=().

int QCString::contains ( char c, bool cs = TRUE ) const
       Returns the number of times the character c occurs in the string.

       The match is case sensitive if cs is TRUE, or case insensitive if cs if
       FALSE.

       See also Note on character comparisons.

int QCString::contains ( const char * str, bool cs = TRUE ) const
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns the number of times str occurs in the string.

       The match is case sensitive if cs is TRUE, or case insensitive if cs if
       FALSE.

       This function counts overlapping substrings, for example, "banana"
       contains two occurrences of "ana".

       See also findRev() and Note on character comparisons.

int QCString::contains ( const QRegExp & rx ) const
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Counts the number of overlapping occurrences of rx in the string.

       Example:

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

       See also find() and findRev().

       Warning: If you want to apply this function repeatedly to the same
       string it is more efficient to convert the string to a QString and
       apply the function to that.

QCString QCString::copy () const
       Returns a deep copy of this string.

       See also detach().

bool QCString::fill ( char c, int len = -1 )
       Fills the string with len bytes of character c, followed by a
       '\0'-terminator.

       If len is negative, then the current string length is used.

       Returns FALSE is len is nonnegative and there is not enough memory to
       resize the string; otherwise returns TRUE.

int QCString::find ( char c, int index = 0, bool cs = TRUE ) const
       Finds the first occurrence of the character c, starting at position
       index.

       The search is case sensitive if cs is TRUE, or case insensitive if cs
       is FALSE.

       Returns the position of c, or -1 if c could not be found.

       See also Note on character comparisons.

       Example: network/networkprotocol/nntp.cpp.

int QCString::find ( const char * str, int index = 0, bool cs = TRUE ) const
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Finds the first occurrence of the string str, starting at position
       index.

       The search is case sensitive if cs is TRUE, or case insensitive if cs
       is FALSE.

       Returns the position of str, or -1 if str could not be found.

       See also Note on character comparisons.

int QCString::find ( const QRegExp & rx, int index = 0 ) const
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Finds the first occurrence of the regular expression rx, starting at
       position index.

       Returns the position of the next match, or -1 if rx was not found.

       Warning: If you want to apply this function repeatedly to the same
       string it is more efficient to convert the string to a QString and
       apply the function to that.

int QCString::findRev ( char c, int index = -1, bool cs = TRUE ) const
       Finds the first occurrence of the character c, starting at position
       index and searching backwards.

       The search is case sensitive if cs is TRUE, or case insensitive if cs
       is FALSE.

       Returns the position of c, or -1 if c could not be found.

       See also Note on character comparisons.

int QCString::findRev ( const char * str, int index = -1, bool cs = TRUE )
       const
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Finds the first occurrence of the string str, starting at position
       index and searching backwards.

       The search is case sensitive if cs is TRUE, or case insensitive if cs
       is FALSE.

       Returns the position of str, or -1 if str could not be found.

       See also Note on character comparisons.

int QCString::findRev ( const QRegExp & rx, int index = -1 ) const
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Finds the first occurrence of the regular expression rx, starting at
       position index and searching backwards.

       Returns the position of the next match (backwards), or -1 if rx was not
       found.

       Warning: If you want to apply this function repeatedly to the same
       string it is more efficient to convert the string to a QString and
       apply the function to that.

QCString & QCString::insert ( uint index, char c )
       Inserts character c into the string at position index and returns a
       reference to the string.

       If index is beyond the end of the string, the string is padded with
       spaces (ASCII 32) to length index and then c is appended.

       Example:

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

       See also remove() and replace().

QCString & QCString::insert ( uint index, const char * s )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Inserts string s into the string at position index.

       If index is beyond the end of the string, the string is padded with
       spaces (ASCII 32) to length index and then s is appended.

	   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
       Returns TRUE if the string is empty, i.e. if length() == 0; otherwise
       returns FALSE. An empty string is not always a null string.

       See example in isNull().

       See also isNull(), length(), and size().

bool QCString::isNull () const
       Returns TRUE if the string is null, i.e. if data() == 0; otherwise
       returns FALSE. A null string is also an empty string.

       Example:

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

       See also isEmpty(), length(), and size().

QCString QCString::left ( uint len ) const
       Returns a substring that contains the len leftmost characters of the
       string.

       The whole string is returned if len exceeds the length of the string.

       Example:

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

       See also right() and mid().

       Example: network/networkprotocol/nntp.cpp.

QCString QCString::leftJustify ( uint width, char fill = ' ', bool truncate =
       FALSE ) const
       Returns a string of length width (plus one for the terminating
       '\0') that contains this string padded with the fill character.

       If the length of the string exceeds width and truncate is FALSE (the
       default), then the returned string is a copy of the string. If the
       length of the string exceeds width and truncate is TRUE, then the
       returned string is a left(width).

       Example:

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

       See also rightJustify().

uint QCString::length () const
       Returns the length of the string, excluding the '\0'-terminator.
       Equivalent to calling strlen(data()).

       Null strings and empty strings have zero length.

       See also size(), isNull(), and isEmpty().

       Example: network/networkprotocol/nntp.cpp.

QCString QCString::lower () const
       Returns a new string that is a copy of this string converted to lower
       case.

       Example:

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

       See also upper() and Note on character comparisons.

QCString QCString::mid ( uint index, uint len = 0xffffffff ) const
       Returns a substring that contains at most len characters from this
       string, starting at position index.

       Returns a null string if the string is empty or if index is out of
       range. Returns the whole string from index if index+len exceeds the
       length of the string.

       Example:

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

       See also left() and right().

       Example: network/networkprotocol/nntp.cpp.

QCString::operator const char * () const
       Returns the string data.

QCString & QCString::operator+= ( const char * str )
       Appends string str to the string and returns a reference to the string.

QCString & QCString::operator+= ( char c )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Appends character c to the string and returns a reference to the
       string.

QCString & QCString::operator= ( const QCString & s )
       Assigns a shallow copy of s to this string and returns a reference to
       this string.

QCString & QCString::operator= ( const char * str )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Assigns a deep copy of str to this string and returns a reference to
       this string.

       If str is 0 a null string is created.

       See also isNull().

QCString & QCString::prepend ( const char * s )
       Prepend s to the string. Equivalent to insert(0, s).

       See also insert().

QCString & QCString::remove ( uint index, uint len )
       Removes len characters from the string, starting at position index, and
       returns a reference to the string.

       If index is out of range, nothing happens. If index is valid, but index
       + len is larger than the length of the string, the string is truncated
       at position index.

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

       See also insert() and replace().

       Example: network/networkprotocol/nntp.cpp.

QCString & QCString::replace ( uint index, uint len, const char * str )
       Replaces len characters from the string, starting at position index,
       with str, and returns a reference to the string.

       If index is out of range, nothing is removed and str is appended at the
       end of the string. If index is valid, but index + len is larger than
       the length of the string, str replaces the rest of the string from
       position index.

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

       See also insert() and remove().

QCString & QCString::replace ( const QRegExp & rx, const char * str )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Replaces every occurrence of rx in the string with str. Returns a
       reference to the string.

       Example:

	   QString s = "banana";
	   s.replace( QRegExp("a.*a"), "" );	 // becomes "b"
	   s = "banana";
	   s.replace( QRegExp("^[bn]a"), "X" );	 // becomes "Xnana"
	   s = "banana";
	   s.replace( QRegExp("^[bn]a"), "" );	 // becomes "nana"

       Warning: If you want to apply this function repeatedly to the same
       string it is more efficient to convert the string to a QString and
       apply the function to that.

QCString & QCString::replace ( char c, const char * after )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Replaces every occurrence of the character c in the string with after.
       Returns a reference to the string.

       Example:

	   QCString s = "a,b,c";
	   s.replace( ',', " or " );
	   // s == "a or b or c"

QCString & QCString::replace ( const char * before, const char * after )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Replaces every occurrence of the string before in the string with the
       string after. Returns a reference to the string.

       Example:

	   QCString s = "Greek is Greek";
	   s.replace( "Greek", "English" );
	   // s == "English is English"

QCString & QCString::replace ( char c1, char c2 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Replaces every occurrence of c1 with the char c2. Returns a reference
       to the string.

bool QCString::resize ( uint len )
       Extends or shrinks the string to len bytes, including the
       '\0'-terminator.

       A '\0'-terminator is set at position len - 1 unless len == 0.

       Example:

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

       See also truncate().

       Example: network/networkprotocol/nntp.cpp.

QCString QCString::right ( uint len ) const
       Returns a substring that contains the len rightmost characters of the
       string.

       The whole string is returned if len exceeds the length of the string.

       Example:

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

       See also left() and mid().

       Example: network/networkprotocol/nntp.cpp.

QCString QCString::rightJustify ( uint width, char fill = ' ', bool truncate =
       FALSE ) const
       Returns a string of length width (plus one for the terminating
       '\0') that contains zero or more of the fill character followed by
       this string.

       If the length of the string exceeds width and truncate is FALSE (the
       default), then the returned string is a copy of the string. If the
       length of the string exceeds width and truncate is TRUE, then the
       returned string is a left(width).

       Example:

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

       See also leftJustify().

bool QCString::setExpand ( uint index, char c )
       Sets the character at position index to c and expands the string if
       necessary, padding with spaces.

       Returns FALSE if index was out of range and the string could not be
       expanded; otherwise returns TRUE.

QCString & QCString::setNum ( double n, char f = 'g', int prec = 6 )
       Sets the string to the string representation of the number n and
       returns a reference to the string.

       The format of the string representation is specified by the format
       character f, and the precision (number of digits after the decimal
       point) is specified with prec.

       The valid formats for f are 'e', 'E', 'f', 'g' and 'G'. The formats are
       the same as for sprintf(); they are explained in QString::arg().

QCString & QCString::setNum ( short n )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Sets the string to the string representation of the number n and
       returns a reference to the string.

QCString & QCString::setNum ( ushort n )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Sets the string to the string representation of the number n and
       returns a reference to the string.

QCString & QCString::setNum ( int n )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Sets the string to the string representation of the number n and
       returns a reference to the string.

QCString & QCString::setNum ( uint n )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Sets the string to the string representation of the number n and
       returns a reference to the string.

QCString & QCString::setNum ( long n )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Sets the string to the string representation of the number n and
       returns a reference to the string.

QCString & QCString::setNum ( ulong n )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Sets the string to the string representation of the number n and
       returns a reference to the string.

QCString & QCString::setNum ( float n, char f = 'g', int prec = 6 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

QCString & QCString::setStr ( const char * str )
       Makes a deep copy of str. Returns a reference to the string.

QCString QCString::simplifyWhiteSpace () const
       Returns a new string that has white space removed from the start and
       the end, plus any sequence of internal white space replaced with a
       single space (ASCII 32).

       White space means the decimal ASCII codes 9, 10, 11, 12, 13 and 32.

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

       See also stripWhiteSpace().

QCString & QCString::sprintf ( const char * format, ... )
       Implemented as a call to the native vsprintf() (see the manual for your
       C library).

       If the string is shorter than 256 characters, this sprintf() calls
       resize(256) to decrease the chance of memory corruption. The string is
       resized back to its actual length before sprintf() returns.

       Example:

	   QCString s;
	   s.sprintf( "%d - %s", 1, "first" );	       // result < 256 chars
	   QCString big( 25000 );		       // very long string
	   big.sprintf( "%d - %s", 2, longString );    // result < 25000 chars

       Warning: All vsprintf() implementations will write past the end of the
       target string (*this) if the format specification and arguments happen
       to be longer than the target string, and some will also fail if the
       target string is longer than some arbitrary implementation limit.

       Giving user-supplied arguments to sprintf() is risky: Sooner or later
       someone will paste a huge line into your application.

QCString QCString::stripWhiteSpace () const
       Returns a new string that has white space removed from the start and
       the end.

       White space means the decimal ASCII codes 9, 10, 11, 12, 13 and 32.

       Example:

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

       See also simplifyWhiteSpace().

double QCString::toDouble ( bool * ok = 0 ) const
       Returns the string converted to a double value.

       If ok is not 0: *ok is set to FALSE if the string is not a number, or
       if it has trailing garbage; otherwise *ok is set to TRUE.

float QCString::toFloat ( bool * ok = 0 ) const
       Returns the string converted to a float value.

       If ok is not 0: *ok is set to FALSE if the string is not a number, or
       if it has trailing garbage; otherwise *ok is set to TRUE.

int QCString::toInt ( bool * ok = 0 ) const
       Returns the string converted to a int value.

       If ok is not 0: *ok is set to FALSE if the string is not a number, or
       if it has trailing garbage; otherwise *ok is set to TRUE.

long QCString::toLong ( bool * ok = 0 ) const
       Returns the string converted to a long value.

       If ok is not 0: *ok is set to FALSE if the string is not a number, or
       if it has trailing garbage; otherwise *ok is set to TRUE.

short QCString::toShort ( bool * ok = 0 ) const
       Returns the string converted to a short value.

       If ok is not 0: *ok is set to FALSE if the string is not a number, is
       out of range, or if it has trailing garbage; otherwise *ok is set to
       TRUE.

uint QCString::toUInt ( bool * ok = 0 ) const
       Returns the string converted to an unsigned int value.

       If ok is not 0: *ok is set to FALSE if the string is not a number, or
       if it has trailing garbage; otherwise *ok is set to TRUE.

ulong QCString::toULong ( bool * ok = 0 ) const
       Returns the string converted to an unsigned long value.

       If ok is not 0: *ok is set to FALSE if the string is not a number, or
       if it has trailing garbage; otherwise *ok is set to TRUE.

ushort QCString::toUShort ( bool * ok = 0 ) const
       Returns the string converted to an unsigned short value.

       If ok is not 0: *ok is set to FALSE if the string is not a number, is
       out of range, or if it has trailing garbage; otherwise *ok is set to
       TRUE.

bool QCString::truncate ( uint pos )
       Truncates the string at position pos.

       Equivalent to calling resize(pos+1).

       Example:

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

       See also resize().

QCString QCString::upper () const
       Returns a new string that is a copy of this string converted to upper
       case.

       Example:

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

       See also lower() and Note on character comparisons.

RELATED FUNCTION DOCUMENTATION
bool operator!= ( const QCString & s1, const QCString & s2 )
       Returns TRUE if s1 and s2 are different; otherwise returns FALSE.

       Equivalent to qstrcmp(s1, s2) != 0.

bool operator!= ( const QCString & s1, const char * s2 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns TRUE if s1 and s2 are different; otherwise returns FALSE.

       Equivalent to qstrcmp(s1, s2) != 0.

bool operator!= ( const char * s1, const QCString & s2 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns TRUE if s1 and s2 are different; otherwise returns FALSE.

       Equivalent to qstrcmp(s1, s2) != 0.

const QCString operator+ ( const QCString & s1, const QCString & s2 )
       Returns a string which consists of the concatenation of s1 and s2.

const QCString operator+ ( const QCString & s1, const char * s2 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns a string which consists of the concatenation of s1 and s2.

const QCString operator+ ( const char * s1, const QCString & s2 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns a string which consists of the concatenation of s1 and s2.

const QCString operator+ ( const QCString & s, char c )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns a string which consists of the concatenation of s and c.

const QCString operator+ ( char c, const QCString & s )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns a string which consists of the concatenation of c and s.

bool operator<; ( const QCString & s1, const char * s2 )
       Returns TRUE if s1 is less than s2; otherwise returns FALSE.

       Equivalent to qstrcmp(s1, s2) < 0.

       See also Note on character comparisons.

bool operator<; ( const char * s1, const QCString & s2 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns TRUE if s1 is less than s2; otherwise returns FALSE.

       Equivalent to qstrcmp(s1, s2) < 0.

       See also Note on character comparisons.

QDataStream & operator<;< ( QDataStream & s, const QCString & str )
       Writes string str to the stream s.

       See also Format of the QDataStream operators.

bool operator<;= ( const QCString & s1, const char * s2 )
       Returns TRUE if s1 is less than or equal to s2; otherwise returns
       FALSE.

       Equivalent to qstrcmp(s1, s2) <= 0.

       See also Note on character comparisons.

bool operator<;= ( const char * s1, const QCString & s2 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns TRUE if s1 is less than or equal to s2; otherwise returns
       FALSE.

       Equivalent to qstrcmp(s1, s2) <= 0.

       See also Note on character comparisons.

bool operator== ( const QCString & s1, const QCString & s2 )
       Returns TRUE if s1 and s2 are equal; otherwise returns FALSE.

       Equivalent to qstrcmp(s1, s2) == 0.

bool operator== ( const QCString & s1, const char * s2 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns TRUE if s1 and s2 are equal; otherwise returns FALSE.

       Equivalent to qstrcmp(s1, s2) == 0.

bool operator== ( const char * s1, const QCString & s2 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns TRUE if s1 and s2 are equal; otherwise returns FALSE.

       Equivalent to qstrcmp(s1, s2) == 0.

bool operator> ( const QCString & s1, const char * s2 )
       Returns TRUE if s1 is greater than s2; otherwise returns FALSE.

       Equivalent to qstrcmp(s1, s2) > 0.

       See also Note on character comparisons.

bool operator> ( const char * s1, const QCString & s2 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns TRUE if s1 is greater than s2; otherwise returns FALSE.

       Equivalent to qstrcmp(s1, s2) > 0.

       See also Note on character comparisons.

bool operator>= ( const QCString & s1, const char * s2 )
       Returns TRUE if s1 is greater than or equal to s2; otherwise returns
       FALSE.

       Equivalent to qstrcmp(s1, s2) >= 0.

       See also Note on character comparisons.

bool operator>= ( const char * s1, const QCString & s2 )
       This is an overloaded member function, provided for convenience. It
       behaves essentially like the above function.

       Returns TRUE if s1 is greater than or equal to s2; otherwise returns
       FALSE.

       Equivalent to qstrcmp(s1, s2) >= 0.

       See also Note on character comparisons.

QDataStream & operator>> ( QDataStream & s, QCString & str )
       Reads a string into str from the stream s.

       See also Format of the QDataStream operators.

void * qmemmove ( void * dst, const void * src, uint len )
       This function is normally part of the C library. Qt implements
       memmove() for platforms that do not provide it.

       memmove() copies len bytes from src into dst. The data is copied
       correctly even if src and dst overlap.

int qstrcmp ( const char * str1, const char * str2 )
       A safe strcmp() function.

       Compares str1 and str2. Returns a negative value if str1 is less than
       str2, 0 if str1 is equal to str2 or a positive value if str1 is greater
       than str2.

       Special case I: Returns 0 if str1 and str2 are both 0.

       Special case II: Returns a random nonzero value if str1 is 0 or str2 is
       0 (but not both).

       See also qstrncmp(), qstricmp(), qstrnicmp(), and Note on character
       comparisons.

char * qstrcpy ( char * dst, const char * src )
       A safe strcpy() function.

       Copies all characters up to and including the '\0' from src into
       dst and returns a pointer to dst.

char * qstrdup ( const char * src )
       Returns a duplicate string.

       Allocates space for a copy of src, copies it, and returns a pointer to
       the copy. If src is 0, it immediately returns 0.

       The returned string must be deleted using delete[].

int qstricmp ( const char * str1, const char * str2 )
       A safe stricmp() function.

       Compares str1 and str2 ignoring the case.

       Returns a negative value if str1 is less than str2, 0 if str1 is equal
       to str2 or a positive value if str1 is greater than str2.

       Special case I: Returns 0 if str1 and str2 are both 0.

       Special case II: Returns a random nonzero value if str1 is 0 or str2 is
       0 (but not both).

       See also qstrcmp(), qstrncmp(), qstrnicmp(), and Note on character
       comparisons.

uint qstrlen ( const char * str )
       A safe strlen function.

       Returns the number of characters that precede the terminating '\0'.
       or 0 if str is 0.

int qstrncmp ( const char * str1, const char * str2, uint len )
       A safe strncmp() function.

       Compares at most len bytes of str1 and str2.

       Returns a negative value if str1 is less than str2, 0 if str1 is equal
       to str2 or a positive value if str1 is greater than str2.

       Special case I: Returns 0 if str1 and str2 are both 0.

       Special case II: Returns a random nonzero value if str1 is 0 or str2 is
       0 (but not both).

       See also qstrcmp(), qstricmp(), qstrnicmp(), and Note on character
       comparisons.

char * qstrncpy ( char * dst, const char * src, uint len )
       A safe strncpy() function.

       Copies at most len bytes from src (stopping at len or the terminating
       '\0' whichever comes first) into dst and returns a pointer to dst.
       Guarantees that dst is '\0'-terminated. If src or dst is 0, returns
       0 immediately.

       See also qstrcpy().

int qstrnicmp ( const char * str1, const char * str2, uint len )
       A safe strnicmp() function.

       Compares at most len bytes of str1 and str2 ignoring the case.

       Returns a negative value if str1 is less than str2, 0 if str1 is equal
       to str2 or a positive value if str1 is greater than str2.

       Special case I: Returns 0 if str1 and str2 are both 0.

       Special case II: Returns a random nonzero value if str1 is 0 or str2 is
       0 (but not both).

       See also qstrcmp(), qstrncmp(), qstricmp(), and Note on character
       comparisons.

SEE ALSO
       http://doc.trolltech.com/qcstring.html
       http://www.trolltech.com/faq/tech.html

COPYRIGHT
       Copyright 1992-2007 Trolltech ASA, http://www.trolltech.com.  See the
       license file included in the distribution for a complete license
       statement.

AUTHOR
       Generated automatically from the source code.

BUGS
       If you find a bug in Qt, please report it as described in
       http://doc.trolltech.com/bughowto.html.	Good bug reports help us to
       help you. Thank you.

       The definitive Qt documentation is provided in HTML format; it is
       located at $QTDIR/doc/html and can be read using Qt Assistant or with a
       web browser. This man page is provided as a convenience for those users
       who prefer man pages, although this format is not officially supported
       by Trolltech.

       If you find errors in this manual page, please report them to qt-
       bugs@trolltech.com.  Please include the name of the manual page
       (qcstring.3qt) and the Qt version (3.3.8).

Trolltech AS			2 February 2007			 QCString(3qt)
[top]

List of man pages available for aLinux

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net