1 \section{\class{wxString
}}\label{wxstring
}
3 wxString is a class representing a character string. Please see the
4 \helpref{wxString overview
}{wxstringoverview
} for more information about it. As explained
5 there, wxString implements about
90\% of methods of the std::string class (iterators
6 are not supported, nor all methods which use them).
7 These standard functions are not documented in this manual so please see the STL documentation.
8 The behaviour of all these functions is identical to the behaviour described
9 there (except that wxString is sensitive to null character).
11 You may notice that wxString sometimes has many functions which do the same
12 thing like, for example,
\helpref{Length()
}{wxstringlength
},
13 \helpref{Len()
}{wxstringlen
} and
{\tt length()
} which all return the string
14 length. In all cases of such duplication the
{\tt std::string
}-compatible
15 method (
{\tt length()
} in this case, always the lowercase version) should be
16 used as it will ensure smoother transition to
{\tt std::string
} when wxWidgets
17 starts using it instead of wxString.
19 Also please note that in this manual
\texttt{char
} is sometimes used instead of
20 \texttt{wxChar
} because it hasn't been fully updated yet. Please substitute as
21 necessary and refer to the sources in case of a doubt.
24 \wxheading{Derived from
}
28 \wxheading{Include files
}
32 \wxheading{Predefined objects
}
40 \overview{Overview
}{wxstringoverview
}
42 \latexignore{\rtfignore{\wxheading{Function groups
}}}
44 \membersection{Constructors and assignment operators
}\label{constructorsinwxstring
}
46 A string may be constructed either from a C string, (some number of copies of)
47 a single character or a wide (UNICODE) string. For all constructors (except the
48 default which creates an empty string) there is also a corresponding assignment
51 \helpref{wxString
}{wxstringconstruct
}\\
52 \helpref{operator $=$
}{wxstringoperatorassign
}\\
53 \helpref{\destruct{wxString
}}{wxstringdestruct
}
55 \membersection{String length
}\label{lengthfunctionsinwxstring
}
57 These functions return the string length and check whether the string is empty
60 \helpref{Len
}{wxstringlen
}\\
61 \helpref{IsEmpty
}{wxstringisempty
}\\
62 \helpref{operator!
}{wxstringoperatornot
}\\
63 \helpref{Empty
}{wxstringempty
}\\
64 \helpref{Clear
}{wxstringclear
}
66 \membersection{Character access
}\label{characteraccessinwxstring
}
68 Many functions in this section take a character index in the string. As with C
69 strings and/or arrays, the indices start from $
0$, so the first character of a
70 string is string
[$
0$
]. Attempt to access a character beyond the end of the
71 string (which may be even $
0$ if the string is empty) will provoke an assert
72 failure in
\helpref{debug build
}{debuggingoverview
}, but no checks are done in
75 This section also contains both implicit and explicit conversions to C style
76 strings. Although implicit conversion is quite convenient, it is advised to use
77 explicit
\helpref{c
\_str()
}{wxstringcstr
} method for the sake of clarity. Also
78 see
\helpref{overview
}{wxstringadvices
} for the cases where it is necessary to
81 \helpref{GetChar
}{wxstringgetchar
}\\
82 \helpref{GetWritableChar
}{wxstringgetwritablechar
}\\
83 \helpref{SetChar
}{wxstringsetchar
}\\
84 \helpref{Last
}{wxstringlast
}\\
85 \helpref{operator
[]}{wxstringoperatorbracket
}\\
86 \helpref{c
\_str}{wxstringcstr
}\\
87 \helpref{mb
\_str}{wxstringmbstr
}\\
88 \helpref{wc
\_str}{wxstringwcstr
}\\
89 \helpref{fn
\_str}{wxstringfnstr
}\\
90 \helpref{operator const char*
}{wxstringoperatorconstcharpt
}
92 \membersection{Concatenation
}\label{concatenationinwxstring
}
94 Anything may be concatenated (appended to) with a string. However, you can't
95 append something to a C string (including literal constants), so to do this it
96 should be converted to a wxString first.
98 \helpref{operator
\cinsert}{wxstringoperatorout
}\\
99 \helpref{operator $+=$
}{wxstringplusequal
}\\
100 \helpref{operator $+$
}{wxstringoperatorplus
}\\
101 \helpref{Append
}{wxstringappend
}\\
102 \helpref{Prepend
}{wxstringprepend
}
104 \membersection{Comparison
}\label{comparisoninwxstring
}
106 The default comparison function
\helpref{Cmp
}{wxstringcmp
} is case-sensitive and
107 so is the default version of
\helpref{IsSameAs
}{wxstringissameas
}. For case
108 insensitive comparisons you should use
\helpref{CmpNoCase
}{wxstringcmpnocase
} or
109 give a second parameter to IsSameAs. This last function is may be more
110 convenient if only equality of the strings matters because it returns a boolean
111 true value if the strings are the same and not
0 (which is usually false in C)
114 \helpref{Matches
}{wxstringmatches
} is a poor man's regular expression matcher:
115 it only understands '*' and '?' metacharacters in the sense of DOS command line
118 \helpref{StartsWith
}{wxstringstartswith
} is helpful when parsing a line of
119 text which should start with some predefined prefix and is more efficient than
120 doing direct string comparison as you would also have to precalculate the
121 length of the prefix then.
123 \helpref{Cmp
}{wxstringcmp
}\\
124 \helpref{CmpNoCase
}{wxstringcmpnocase
}\\
125 \helpref{IsSameAs
}{wxstringissameas
}\\
126 \helpref{Matches
}{wxstringmatches
}\\
127 \helpref{StartsWith
}{wxstringstartswith
}
129 \membersection{Substring extraction
}\label{substringextractioninwxstring
}
131 These functions allow to extract substring from this string. All of them don't
132 modify the original string and return a new string containing the extracted
135 \helpref{Mid
}{wxstringmid
}\\
136 \helpref{operator()
}{wxstringoperatorparenth
}\\
137 \helpref{Left
}{wxstringleft
}\\
138 \helpref{Right
}{wxstringright
}\\
139 \helpref{BeforeFirst
}{wxstringbeforefirst
}\\
140 \helpref{BeforeLast
}{wxstringbeforelast
}\\
141 \helpref{AfterFirst
}{wxstringafterfirst
}\\
142 \helpref{AfterLast
}{wxstringafterlast
}\\
143 \helpref{StartsWith
}{wxstringstartswith
}
145 \membersection{Case conversion
}\label{caseconversioninwxstring
}
147 The MakeXXX() variants modify the string in place, while the other functions
148 return a new string which contains the original text converted to the upper or
149 lower case and leave the original string unchanged.
151 \helpref{MakeUpper
}{wxstringmakeupper
}\\
152 \helpref{Upper
}{wxstringupper
}\\
153 \helpref{MakeLower
}{wxstringmakelower
}\\
154 \helpref{Lower
}{wxstringlower
}
156 \membersection{Searching and replacing
}\label{searchingandreplacinginwxstring
}
158 These functions replace the standard
{\it strchr()
} and
{\it strstr()
}
161 \helpref{Find
}{wxstringfind
}\\
162 \helpref{Replace
}{wxstringreplace
}
164 \membersection{Conversion to numbers
}\label{conversiontonumbersinwxstring
}
166 The string provides functions for conversion to signed and unsigned integer and
167 floating point numbers. All three functions take a pointer to the variable to
168 put the numeric value in and return true if the
{\bf entire
} string could be
169 converted to a number.
171 \helpref{ToLong
}{wxstringtolong
}\\
172 \helpref{ToULong
}{wxstringtoulong
}\\
173 \helpref{ToDouble
}{wxstringtodouble
}
175 \membersection{Writing values into the string
}\label{writingintostringinwxstring
}
177 Both formatted versions (
\helpref{Printf
}{wxstringprintf
}) and stream-like
178 insertion operators exist (for basic types only). Additionally, the
179 \helpref{Format
}{wxstringformat
} function allows to use simply append
180 formatted value to a string:
183 // the following
2 snippets are equivalent
186 s += wxString::Format("
%d", n);
189 s.Printf("...
%d", n);
192 \helpref{Format
}{wxstringformat
}\\
193 \helpref{FormatV
}{wxstringformatv
}\\
194 \helpref{Printf
}{wxstringprintf
}\\
195 \helpref{PrintfV
}{wxstringprintfv
}\\
196 \helpref{operator
\cinsert}{wxstringoperatorout
}
198 \membersection{Memory management
}\label{memoryinwxstring
}
200 These are "advanced" functions and they will be needed quite rarely.
201 \helpref{Alloc
}{wxstringalloc
} and
\helpref{Shrink
}{wxstringshrink
} are only
202 interesting for optimization purposes.
203 \helpref{GetWriteBuf
}{wxstringgetwritebuf
} may be very useful when working with
204 some external API which requires the caller to provide a writable buffer, but
205 extreme care should be taken when using it: before performing any other
206 operation on the string
\helpref{UngetWriteBuf
}{wxstringungetwritebuf
} {\bf
209 \helpref{Alloc
}{wxstringalloc
}\\
210 \helpref{Shrink
}{wxstringshrink
}\\
211 \helpref{GetWriteBuf
}{wxstringgetwritebuf
}\\
212 \helpref{UngetWriteBuf
}{wxstringungetwritebuf
}
214 \membersection{Miscellaneous
}\label{miscellaneousinwxstring
}
216 Other string functions.
218 \helpref{Trim
}{wxstringtrim
}\\
219 \helpref{Pad
}{wxstringpad
}\\
220 \helpref{Truncate
}{wxstringtruncate
}
222 \membersection{wxWidgets
1.xx compatibility functions
}\label{backwardcompatibilityinwxstring
}
224 These functions are deprecated, please consider using new wxWidgets
2.0
225 functions instead of them (or, even better, std::string compatible variants).
227 \helpref{SubString
}{wxstringsubstring
}\\
228 \helpref{sprintf
}{wxstringsprintf
}\\
229 \helpref{CompareTo
}{wxstringcompareto
}\\
230 \helpref{Length
}{wxstringlength
}\\
231 \helpref{Freq
}{wxstringfreq
}\\
232 \helpref{LowerCase
}{wxstringlowercase
}\\
233 \helpref{UpperCase
}{wxstringuppercase
}\\
234 \helpref{Strip
}{wxstringstrip
}\\
235 \helpref{Index
}{wxstringindex
}\\
236 \helpref{Remove
}{wxstringremove
}\\
237 \helpref{First
}{wxstringfirst
}\\
238 \helpref{Last
}{wxstringlast
}\\
239 \helpref{Contains
}{wxstringcontains
}\\
240 \helpref{IsNull
}{wxstringisnull
}\\
241 \helpref{IsAscii
}{wxstringisascii
}\\
242 \helpref{IsNumber
}{wxstringisnumber
}\\
243 \helpref{IsWord
}{wxstringisword
}
245 \membersection{std::string compatibility functions
}\label{wxstringat
}
247 The supported functions are only listed here, please see any STL reference for
251 // take nLen chars starting at nPos
252 wxString(const wxString& str, size_t nPos, size_t nLen);
253 // take all characters from pStart to pEnd (poor man's iterators)
254 wxString(const void *pStart, const void *pEnd);
256 // lib.string.capacity
257 // return the length of the string
259 // return the length of the string
260 size_t length() const;
261 // return the maximum size of the string
262 size_t max_size() const;
263 // resize the string, filling the space with c if c !=
0
264 void resize(size_t nSize, char ch = '
\0');
265 // delete the contents of the string
267 // returns true if the string is empty
271 // return the character at position n
272 char at(size_t n) const;
273 // returns the writable character at position n
276 // lib.string.modifiers
278 wxString& append(const wxString& str);
279 // append elements str
[pos
], ..., str
[pos+n
]
280 wxString& append(const wxString& str, size_t pos, size_t n);
281 // append first n (or all if n == npos) characters of sz
282 wxString& append(const char *sz, size_t n = npos);
284 // append n copies of ch
285 wxString& append(size_t n, char ch);
287 // same as `this_string = str'
288 wxString& assign(const wxString& str);
289 // same as ` = str
[pos..pos + n
]
290 wxString& assign(const wxString& str, size_t pos, size_t n);
291 // same as `= first n (or all if n == npos) characters of sz'
292 wxString& assign(const char *sz, size_t n = npos);
293 // same as `= n copies of ch'
294 wxString& assign(size_t n, char ch);
296 // insert another string
297 wxString& insert(size_t nPos, const wxString& str);
298 // insert n chars of str starting at nStart (in str)
299 wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n);
301 // insert first n (or all if n == npos) characters of sz
302 wxString& insert(size_t nPos, const char *sz, size_t n = npos);
303 // insert n copies of ch
304 wxString& insert(size_t nPos, size_t n, char ch);
306 // delete characters from nStart to nStart + nLen
307 wxString& erase(size_t nStart =
0, size_t nLen = npos);
309 // replaces the substring of length nLen starting at nStart
310 wxString& replace(size_t nStart, size_t nLen, const char* sz);
311 // replaces the substring with nCount copies of ch
312 wxString& replace(size_t nStart, size_t nLen, size_t nCount, char ch);
313 // replaces a substring with another substring
314 wxString& replace(size_t nStart, size_t nLen,
315 const wxString& str, size_t nStart2, size_t nLen2);
316 // replaces the substring with first nCount chars of sz
317 wxString& replace(size_t nStart, size_t nLen,
318 const char* sz, size_t nCount);
321 void swap(wxString& str);
323 // All find() functions take the nStart argument which specifies the
324 // position to start the search on, the default value is
0. All functions
325 // return npos if there were no match.
328 size_t find(const wxString& str, size_t nStart =
0) const;
330 // find first n characters of sz
331 size_t find(const char* sz, size_t nStart =
0, size_t n = npos) const;
333 // find the first occurrence of character ch after nStart
334 size_t find(char ch, size_t nStart =
0) const;
336 // rfind() family is exactly like find() but works right to left
338 // as find, but from the end
339 size_t rfind(const wxString& str, size_t nStart = npos) const;
341 // as find, but from the end
342 size_t rfind(const char* sz, size_t nStart = npos,
343 size_t n = npos) const;
344 // as find, but from the end
345 size_t rfind(char ch, size_t nStart = npos) const;
347 // find first/last occurrence of any character in the set
350 size_t find_first_of(const wxString& str, size_t nStart =
0) const;
352 size_t find_first_of(const char* sz, size_t nStart =
0) const;
353 // same as find(char, size_t)
354 size_t find_first_of(char c, size_t nStart =
0) const;
356 size_t find_last_of (const wxString& str, size_t nStart = npos) const;
358 size_t find_last_of (const char* s, size_t nStart = npos) const;
359 // same as rfind(char, size_t)
360 size_t find_last_of (char c, size_t nStart = npos) const;
362 // find first/last occurrence of any character not in the set
365 size_t find_first_not_of(const wxString& str, size_t nStart =
0) const;
367 size_t find_first_not_of(const char* s, size_t nStart =
0) const;
369 size_t find_first_not_of(char ch, size_t nStart =
0) const;
371 size_t find_last_not_of(const wxString& str, size_t nStart=npos) const;
373 size_t find_last_not_of(const char* s, size_t nStart = npos) const;
375 size_t find_last_not_of(char ch, size_t nStart = npos) const;
377 // All compare functions return a negative, zero or positive value
378 // if the
[sub
]string is less, equal or greater than the compare() argument.
380 // just like strcmp()
381 int compare(const wxString& str) const;
382 // comparison with a substring
383 int compare(size_t nStart, size_t nLen, const wxString& str) const;
384 // comparison of
2 substrings
385 int compare(size_t nStart, size_t nLen,
386 const wxString& str, size_t nStart2, size_t nLen2) const;
387 // just like strcmp()
388 int compare(const char* sz) const;
389 // substring comparison with first nCount characters of sz
390 int compare(size_t nStart, size_t nLen,
391 const char* sz, size_t nCount = npos) const;
393 // substring extraction
394 wxString substr(size_t nStart =
0, size_t nLen = npos) const;
397 %%%%% MEMBERS HERE %%%%%
398 \helponly{\insertatlevel{2}{
404 \membersection{wxString::wxString
}\label{wxstringconstruct
}
406 \func{}{wxString
}{\void}
408 Default constructor. Initializes the string to
{\tt ""
} (empty string).
410 \func{}{wxString
}{\param{const wxString\&
}{ x
}}
414 \func{}{wxString
}{\param{char
}{ ch
},
\param{size
\_t}{ n =
1}}
416 Constructs a string of
{\it n
} copies of character
{\it ch
}.
418 \func{}{wxString
}{\param{const char*
}{ psz
},
\param{size
\_t}{ nLength = wxSTRING
\_MAXLEN}}
420 Takes first
{\it nLength
} characters from the C string
{\it psz
}.
421 The default value of
{\tt wxSTRING
\_MAXLEN} means to take all the string.
423 Note that this constructor may be used even if
{\it psz
} points to a buffer
424 with binary data (i.e. containing
{\tt NUL
} characters) as long as you provide
425 the correct value for
{\it nLength
}. However, the default form of it works
426 only with strings without intermediate
{\tt NUL
}s because it uses
427 {\tt strlen()
} to calculate the effective length and it would not give correct
430 \func{}{wxString
}{\param{const unsigned char*
}{ psz
},
\param{size
\_t}{ nLength = wxSTRING
\_MAXLEN}}
432 For compilers using unsigned char: takes first
{\it nLength
} characters from the C string
{\it psz
}.
433 The default value of
{\tt wxSTRING
\_MAXLEN} means take all the string.
435 {\bf Note:
} In Unicode build, all of the above constructors take
436 {\tt wchar
\_t} arguments instead of
{\tt char
}.
438 \wxheading{Constructors with conversion
}
440 The following constructors allow you to construct wxString from wide string
441 in ANSI build or from C string in Unicode build.
443 \func{}{wxString
}{\param{const wchar
\_t*
}{ psz
},
\param{wxMBConv\&
}{ conv
},
\param{size
\_t}{ nLength = wxSTRING
\_MAXLEN}}
445 Initializes the string from first
\arg{nLength
} characters of wide string.
446 The default value of
{\tt wxSTRING
\_MAXLEN} means take all the string.
447 In ANSI build,
\arg{conv
}'s
448 \helpref{WC2MB
}{wxmbconvwc2mb
} method is called to
449 convert
\arg{psz
} to wide string. It is ignored in Unicode build.
451 \func{}{wxString
}{\param{const char*
}{ psz
},
\param{wxMBConv\&
}{ conv
},
\param{size
\_t}{ nLength = wxSTRING
\_MAXLEN}}
453 Initializes the string from first
\arg{nLength
} characters of C string.
454 The default value of
{\tt wxSTRING
\_MAXLEN} means take all the string.
455 In Unicode build,
\arg{conv
}'s
456 \helpref{MB2WC
}{wxmbconvmb2wc
} method is called to
457 convert
\arg{psz
} to wide string. It is ignored in ANSI build.
461 \helpref{wxMBConv classes
}{mbconvclasses
},
\helpref{mb
\_str}{wxstringmbstr
},
462 \helpref{wc
\_str}{wxstringwcstr
}
464 \membersection{wxString::
\destruct{wxString
}}\label{wxstringdestruct
}
466 \func{}{\destruct{wxString
}}{\void}
468 String destructor. Note that this is not virtual, so wxString must not be inherited from.
470 \membersection{wxString::Alloc
}\label{wxstringalloc
}
472 \func{void
}{Alloc
}{\param{size
\_t}{ nLen
}}
474 Preallocate enough space for wxString to store
{\it nLen
} characters. This function
475 may be used to increase speed when the string is constructed by repeated
480 // delete all vowels from the string
481 wxString DeleteAllVowels(const wxString& original)
485 size_t len = original.length();
489 for ( size_t n =
0; n < len; n++ )
491 if ( strchr("aeuio", tolower(original
[n
])) == NULL )
492 result += original
[n
];
500 because it will avoid the need to reallocate string memory many times (in case
501 of long strings). Note that it does not set the maximal length of a string - it
502 will still expand if more than
{\it nLen
} characters are stored in it. Also, it
503 does not truncate the existing string (use
504 \helpref{Truncate()
}{wxstringtruncate
} for this) even if its current length is
505 greater than
{\it nLen
}
507 \membersection{wxString::Append
}\label{wxstringappend
}
509 \func{wxString\&
}{Append
}{\param{const char*
}{ psz
}}
511 Concatenates
{\it psz
} to this string, returning a reference to it.
513 \func{wxString\&
}{Append
}{\param{char
}{ ch
},
\param{int
}{ count =
1}}
515 Concatenates character
{\it ch
} to this string,
{\it count
} times, returning a reference
518 \membersection{wxString::AfterFirst
}\label{wxstringafterfirst
}
520 \constfunc{wxString
}{AfterFirst
}{\param{char
}{ ch
}}
522 Gets all the characters after the first occurrence of
{\it ch
}.
523 Returns the empty string if
{\it ch
} is not found.
525 \membersection{wxString::AfterLast
}\label{wxstringafterlast
}
527 \constfunc{wxString
}{AfterLast
}{\param{char
}{ ch
}}
529 Gets all the characters after the last occurrence of
{\it ch
}.
530 Returns the whole string if
{\it ch
} is not found.
532 \membersection{wxString::BeforeFirst
}\label{wxstringbeforefirst
}
534 \constfunc{wxString
}{BeforeFirst
}{\param{char
}{ ch
}}
536 Gets all characters before the first occurrence of
{\it ch
}.
537 Returns the whole string if
{\it ch
} is not found.
539 \membersection{wxString::BeforeLast
}\label{wxstringbeforelast
}
541 \constfunc{wxString
}{BeforeLast
}{\param{char
}{ ch
}}
543 Gets all characters before the last occurrence of
{\it ch
}.
544 Returns the empty string if
{\it ch
} is not found.
546 \membersection{wxString::c
\_str}\label{wxstringcstr
}
548 \constfunc{const wxChar *
}{c
\_str}{\void}
550 Returns a pointer to the string data (
{\tt const char*
} in ANSI build,
551 {\tt const wchar
\_t*
} in Unicode build).
555 \helpref{mb
\_str}{wxstringmbstr
},
\helpref{wc
\_str}{wxstringwcstr
},
556 \helpref{fn
\_str}{wxstringfnstr
}
558 \membersection{wxString::Clear
}\label{wxstringclear
}
560 \func{void
}{Clear
}{\void}
562 Empties the string and frees memory occupied by it.
564 See also:
\helpref{Empty
}{wxstringempty
}
566 \membersection{wxString::Cmp
}\label{wxstringcmp
}
568 \constfunc{int
}{Cmp
}{\param{const wxString\&
}{ s
}}
570 \constfunc{int
}{Cmp
}{\param{const char*
}{ psz
}}
572 Case-sensitive comparison.
574 Returns a positive value if the string is greater than the argument, zero if
575 it is equal to it or a negative value if it is less than the argument (same semantics
576 as the standard
{\it strcmp()
} function).
578 See also
\helpref{CmpNoCase
}{wxstringcmpnocase
},
\helpref{IsSameAs
}{wxstringissameas
}.
580 \membersection{wxString::CmpNoCase
}\label{wxstringcmpnocase
}
582 \constfunc{int
}{CmpNoCase
}{\param{const wxString\&
}{ s
}}
584 \constfunc{int
}{CmpNoCase
}{\param{const char*
}{ psz
}}
586 Case-insensitive comparison.
588 Returns a positive value if the string is greater than the argument, zero if
589 it is equal to it or a negative value if it is less than the argument (same semantics
590 as the standard
{\it strcmp()
} function).
592 See also
\helpref{Cmp
}{wxstringcmp
},
\helpref{IsSameAs
}{wxstringissameas
}.
594 \membersection{wxString::CompareTo
}\label{wxstringcompareto
}
597 #define NO_POS ((int)(-
1)) // undefined position
598 enum caseCompare
{exact, ignoreCase
};
601 \constfunc{int
}{CompareTo
}{\param{const char*
}{ psz
},
\param{caseCompare
}{ cmp = exact
}}
603 Case-sensitive comparison. Returns
0 if equal,
1 if greater or -
1 if less.
605 \membersection{wxString::Contains
}\label{wxstringcontains
}
607 \constfunc{bool
}{Contains
}{\param{const wxString\&
}{ str
}}
609 Returns
1 if target appears anywhere in wxString; else
0.
611 \membersection{wxString::Empty
}\label{wxstringempty
}
613 \func{void
}{Empty
}{\void}
615 Makes the string empty, but doesn't free memory occupied by the string.
617 See also:
\helpref{Clear()
}{wxstringclear
}.
619 \membersection{wxString::Find
}\label{wxstringfind
}
621 \constfunc{int
}{Find
}{\param{char
}{ ch
},
\param{bool
}{ fromEnd = false
}}
623 Searches for the given character. Returns the starting index, or -
1 if not found.
625 \constfunc{int
}{Find
}{\param{const char*
}{ sz
}}
627 Searches for the given string. Returns the starting index, or -
1 if not found.
629 \membersection{wxString::First
}\label{wxstringfirst
}
631 \func{int
}{First
}{\param{char
}{ c
}}
633 \constfunc{int
}{First
}{\param{const char*
}{ psz
}}
635 \constfunc{int
}{First
}{\param{const wxString\&
}{ str
}}
637 Same as
\helpref{Find
}{wxstringfind
}.
639 \membersection{wxString::fn
\_str}\label{wxstringfnstr
}
641 \constfunc{const wchar
\_t*
}{fn
\_str}{\void}
643 \constfunc{const char*
}{fn
\_str}{\void}
645 \constfunc{const wxCharBuffer
}{fn
\_str}{\void}
647 Returns string representation suitable for passing to OS' functions for
648 file handling. In ANSI build, this is same as
\helpref{c
\_str}{wxstringcstr
}.
649 In Unicode build, returned value can be either wide character string
650 or C string in charset matching the
{\tt wxConvFileName
} object, depending on
655 \helpref{wxMBConv
}{wxmbconv
},
656 \helpref{wc
\_str}{wxstringwcstr
},
\helpref{mb
\_str}{wxstringwcstr
}
658 \membersection{wxString::Format
}\label{wxstringformat
}
660 \func{static wxString
}{Format
}{\param{const wxChar
}{*format
},
\param{}{...
}}
662 This static function returns the string containing the result of calling
663 \helpref{Printf
}{wxstringprintf
} with the passed parameters on it.
667 \helpref{FormatV
}{wxstringformatv
},
\helpref{Printf
}{wxstringprintf
}
669 \membersection{wxString::FormatV
}\label{wxstringformatv
}
671 \func{static wxString
}{FormatV
}{\param{const wxChar
}{*format
},
\param{va
\_list }{argptr
}}
673 This static function returns the string containing the result of calling
674 \helpref{PrintfV
}{wxstringprintfv
} with the passed parameters on it.
678 \helpref{Format
}{wxstringformat
},
\helpref{PrintfV
}{wxstringprintfv
}
680 \membersection{wxString::Freq
}\label{wxstringfreq
}
682 \constfunc{int
}{Freq
}{\param{char
}{ch
}}
684 Returns the number of occurrences of
{\it ch
} in the string.
686 \membersection{wxString::FromAscii
}\label{wxstringfromascii
}
688 \func{static wxString
}{FromAscii
}{\param{const char*
}{ s
}}
690 \func{static wxString
}{FromAscii
}{\param{const char
}{ c
}}
692 Converts the string or character from an ASCII,
7-bit form
693 to the native wxString representation. Most useful when using
694 a Unicode build of wxWidgets.
695 Use
\helpref{wxString constructors
}{wxstringconstruct
} if you
696 need to convert from another charset.
698 \membersection{wxString::GetChar
}\label{wxstringgetchar
}
700 \constfunc{char
}{GetChar
}{\param{size
\_t}{ n
}}
702 Returns the character at position
{\it n
} (read-only).
704 \membersection{wxString::GetData
}\label{wxstringgetdata
}
706 \constfunc{const wxChar*
}{GetData
}{\void}
708 wxWidgets compatibility conversion. Returns a constant pointer to the data in the string.
710 \membersection{wxString::GetWritableChar
}\label{wxstringgetwritablechar
}
712 \func{char\&
}{GetWritableChar
}{\param{size
\_t}{ n
}}
714 Returns a reference to the character at position
{\it n
}.
716 \membersection{wxString::GetWriteBuf
}\label{wxstringgetwritebuf
}
718 \func{wxChar*
}{GetWriteBuf
}{\param{size
\_t}{ len
}}
720 Returns a writable buffer of at least
{\it len
} bytes.
721 It returns a pointer to a new memory block, and the
722 existing data will not be copied.
724 Call
\helpref{wxString::UngetWriteBuf
}{wxstringungetwritebuf
} as soon as possible
725 to put the string back into a reasonable state.
727 \membersection{wxString::Index
}\label{wxstringindex
}
729 \constfunc{size
\_t}{Index
}{\param{char
}{ ch
}}
731 \constfunc{size
\_t}{Index
}{\param{const char*
}{ sz
}}
733 Same as
\helpref{wxString::Find
}{wxstringfind
}.
736 %\membersection{wxString::insert}\label{wxstringinsert}
738 %\func{void}{insert}{\param{const wxString\&}{ str}, \param{size\_t}{ index}}
740 %Add new element at the given position.
742 \membersection{wxString::IsAscii
}\label{wxstringisascii
}
744 \constfunc{bool
}{IsAscii
}{\void}
746 Returns true if the string contains only ASCII characters.
748 \membersection{wxString::IsEmpty
}\label{wxstringisempty
}
750 \constfunc{bool
}{IsEmpty
}{\void}
752 Returns true if the string is empty.
754 \membersection{wxString::IsNull
}\label{wxstringisnull
}
756 \constfunc{bool
}{IsNull
}{\void}
758 Returns true if the string is empty (same as
\helpref{IsEmpty
}{wxstringisempty
}).
760 \membersection{wxString::IsNumber
}\label{wxstringisnumber
}
762 \constfunc{bool
}{IsNumber
}{\void}
764 Returns true if the string is an integer (with possible sign).
766 \membersection{wxString::IsSameAs
}\label{wxstringissameas
}
768 \constfunc{bool
}{IsSameAs
}{\param{const char*
}{ psz
},
\param{bool
}{ caseSensitive = true
}}
770 Test for string equality, case-sensitive (default) or not.
772 caseSensitive is true by default (case matters).
774 Returns true if strings are equal, false otherwise.
776 See also
\helpref{Cmp
}{wxstringcmp
},
\helpref{CmpNoCase
}{wxstringcmpnocase
}
778 \constfunc{bool
}{IsSameAs
}{\param{char
}{ c
},
\param{bool
}{ caseSensitive = true
}}
780 Test whether the string is equal to the single character
{\it c
}. The test is
781 case-sensitive if
{\it caseSensitive
} is true (default) or not if it is false.
783 Returns true if the string is equal to the character, false otherwise.
785 See also
\helpref{Cmp
}{wxstringcmp
},
\helpref{CmpNoCase
}{wxstringcmpnocase
}
787 \membersection{wxString::IsWord
}\label{wxstringisword
}
789 \constfunc{bool
}{IsWord
}{\void}
791 Returns true if the string is a word. TODO: what's the definition of a word?
793 \membersection{wxString::Last
}\label{wxstringlast
}
795 \constfunc{char
}{Last
}{\void}
797 Returns the last character.
799 \func{char\&
}{Last
}{\void}
801 Returns a reference to the last character (writable).
803 \membersection{wxString::Left
}\label{wxstringleft
}
805 \constfunc{wxString
}{Left
}{\param{size
\_t}{ count
}}
807 Returns the first
{\it count
} characters of the string.
809 \membersection{wxString::Len
}\label{wxstringlen
}
811 \constfunc{size
\_t}{Len
}{\void}
813 Returns the length of the string.
815 \membersection{wxString::Length
}\label{wxstringlength
}
817 \constfunc{size
\_t}{Length
}{\void}
819 Returns the length of the string (same as Len).
821 \membersection{wxString::Lower
}\label{wxstringlower
}
823 \constfunc{wxString
}{Lower
}{\void}
825 Returns this string converted to the lower case.
827 \membersection{wxString::LowerCase
}\label{wxstringlowercase
}
829 \func{void
}{LowerCase
}{\void}
833 \membersection{wxString::MakeLower
}\label{wxstringmakelower
}
835 \func{wxString\&
}{MakeLower
}{\void}
837 Converts all characters to lower case and returns the result.
839 \membersection{wxString::MakeUpper
}\label{wxstringmakeupper
}
841 \func{wxString\&
}{MakeUpper
}{\void}
843 Converts all characters to upper case and returns the result.
845 \membersection{wxString::Matches
}\label{wxstringmatches
}
847 \constfunc{bool
}{Matches
}{\param{const char*
}{ szMask
}}
849 Returns true if the string contents matches a mask containing '*' and '?'.
851 \membersection{wxString::mb
\_str}\label{wxstringmbstr
}
853 \constfunc{const char*
}{mb
\_str}{\param{wxMBConv\&
}{ conv
}}
855 \constfunc{const wxCharBuffer
}{mb
\_str}{\param{wxMBConv\&
}{ conv
}}
857 Returns multibyte (C string) representation of the string.
858 In Unicode build, converts using
\arg{conv
}'s
\helpref{cWC2MB
}{wxmbconvcwc2mb
}
859 method and returns wxCharBuffer. In ANSI build, this function is same
860 as
\helpref{c
\_str}{wxstringcstr
}.
861 The macro wxWX2MBbuf is defined as the correct return type (without const).
865 \helpref{wxMBConv
}{wxmbconv
},
866 \helpref{c
\_str}{wxstringcstr
},
\helpref{wc
\_str}{wxstringwcstr
},
867 \helpref{fn
\_str}{wxstringfnstr
}
869 \membersection{wxString::Mid
}\label{wxstringmid
}
871 \constfunc{wxString
}{Mid
}{\param{size
\_t}{ first
},
\param{size
\_t}{ count = wxSTRING
\_MAXLEN}}
873 Returns a substring starting at
{\it first
}, with length
{\it count
}, or the rest of
874 the string if
{\it count
} is the default value.
876 \membersection{wxString::Pad
}\label{wxstringpad
}
878 \func{wxString\&
}{Pad
}{\param{size
\_t}{ count
},
\param{char
}{ pad = ' '
},
\param{bool
}{ fromRight = true
}}
880 Adds
{\it count
} copies of
{\it pad
} to the beginning, or to the end of the string (the default).
882 Removes spaces from the left or from the right (default).
884 \membersection{wxString::Prepend
}\label{wxstringprepend
}
886 \func{wxString\&
}{Prepend
}{\param{const wxString\&
}{ str
}}
888 Prepends
{\it str
} to this string, returning a reference to this string.
890 \membersection{wxString::Printf
}\label{wxstringprintf
}
892 \func{int
}{Printf
}{\param{const char*
}{pszFormat
},
\param{}{...
}}
894 Similar to the standard function
{\it sprintf()
}. Returns the number of
895 characters written, or an integer less than zero on error.
897 {\bf NB:
} This function will use a safe version of
{\it vsprintf()
} (usually called
898 {\it vsnprintf()
}) whenever available to always allocate the buffer of correct
899 size. Unfortunately, this function is not available on all platforms and the
900 dangerous
{\it vsprintf()
} will be used then which may lead to buffer overflows.
902 \membersection{wxString::PrintfV
}\label{wxstringprintfv
}
904 \func{int
}{PrintfV
}{\param{const char*
}{pszFormat
},
\param{va
\_list}{ argPtr
}}
906 Similar to vprintf. Returns the number of characters written, or an integer less than zero
909 \membersection{wxString::Remove
}\label{wxstringremove
}
911 \func{wxString\&
}{Remove
}{\param{size
\_t}{ pos
}}
913 Same as Truncate. Removes the portion from
{\it pos
} to the end of the string.
915 \func{wxString\&
}{Remove
}{\param{size
\_t}{ pos
},
\param{size
\_t}{ len
}}
917 Removes
{\it len
} characters from the string, starting at
{\it pos
}.
919 \membersection{wxString::RemoveLast
}\label{wxstringremovelast
}
921 \func{wxString\&
}{RemoveLast
}{\void}
923 Removes the last character.
925 \membersection{wxString::Replace
}\label{wxstringreplace
}
927 \func{size
\_t}{Replace
}{\param{const char*
}{ szOld
},
\param{const char*
}{ szNew
},
\param{bool
}{ replaceAll = true
}}
929 Replace first (or all) occurrences of substring with another one.
931 {\it replaceAll
}: global replace (default), or only the first occurrence.
933 Returns the number of replacements made.
935 \membersection{wxString::Right
}\label{wxstringright
}
937 \constfunc{wxString
}{Right
}{\param{size
\_t}{ count
}}
939 Returns the last
{\it count
} characters.
941 \membersection{wxString::SetChar
}\label{wxstringsetchar
}
943 \func{void
}{SetChar
}{\param{size
\_t}{ n
},
\param{char
}{ch
}}
945 Sets the character at position
{\it n
}.
947 \membersection{wxString::Shrink
}\label{wxstringshrink
}
949 \func{void
}{Shrink
}{\void}
951 Minimizes the string's memory. This can be useful after a call to
952 \helpref{Alloc()
}{wxstringalloc
} if too much memory were preallocated.
954 \membersection{wxString::sprintf
}\label{wxstringsprintf
}
956 \func{void
}{sprintf
}{\param{const char*
}{ fmt
}}
960 \membersection{wxString::StartsWith
}\label{wxstringstartswith
}
962 \constfunc{bool
}{StartsWith
}{\param{const wxChar
}{*prefix
},
\param{wxString
}{*rest = NULL
}}
964 This function can be used to test if the string starts with the specified
965 {\it prefix
}. If it does, the function will return
{\tt true
} and put the rest
966 of the string (i.e. after the prefix) into
{\it rest
} string if it is not
967 {\tt NULL
}. Otherwise, the function returns
{\tt false
} and doesn't modify the
970 \membersection{wxString::Strip
}\label{wxstringstrip
}
973 enum stripType
{leading =
0x1, trailing =
0x2, both =
0x3};
976 \constfunc{wxString
}{Strip
}{\param{stripType
}{ s = trailing
}}
978 Strip characters at the front and/or end. The same as Trim except that it
979 doesn't change this string.
981 \membersection{wxString::SubString
}\label{wxstringsubstring
}
983 \constfunc{wxString
}{SubString
}{\param{size
\_t}{ from
},
\param{size
\_t}{ to
}}
985 Deprecated, use
\helpref{Mid
}{wxstringmid
} instead (but note that parameters
986 have different meaning).
988 Returns the part of the string between the indices
{\it from
} and
{\it to
}
991 \membersection{wxString::ToAscii
}\label{wxstringtoascii
}
993 \constfunc{const char*
}{ToAscii
}{\void}
995 Converts the string to an ASCII,
7-bit string (ANSI builds only).
997 \constfunc{const wxCharBuffer
}{ToAscii
}{\void}
999 Converts the string to an ASCII,
7-bit string in the form of
1000 a wxCharBuffer (Unicode builds only).
1002 Note that this conversion only works if the string contains only ASCII
1003 characters. The
\helpref{mb
\_str}{wxstringmbstr
} method provides more
1004 powerful means of converting wxString to C string.
1006 \membersection{wxString::ToDouble
}\label{wxstringtodouble
}
1008 \constfunc{bool
}{ToDouble
}{\param{double
}{ *val
}}
1010 Attempts to convert the string to a floating point number. Returns true on
1011 success (the number is stored in the location pointed to by
{\it val
}) or false
1012 if the string does not represent such number.
1014 \wxheading{See also
}
1016 \helpref{wxString::ToLong
}{wxstringtolong
},\\
1017 \helpref{wxString::ToULong
}{wxstringtoulong
}
1019 \membersection{wxString::ToLong
}\label{wxstringtolong
}
1021 \constfunc{bool
}{ToLong
}{\param{long
}{ *val
},
\param{int
}{base = $
10$
}}
1023 Attempts to convert the string to a signed integer in base
{\it base
}. Returns
1024 {\tt true
} on success in which case the number is stored in the location
1025 pointed to by
{\it val
} or
{\tt false
} if the string does not represent a
1026 valid number in the given base.
1028 The value of
{\it base
} must be comprised between $
2$ and $
36$, inclusive, or
1029 be a special value $
0$ which means that the usual rules of
{\tt C
} numbers are
1030 applied: if the number starts with
{\tt 0x
} it is considered to be in base
1031 $
16$, if it starts with
{\tt 0} - in base $
8$ and in base $
10$ otherwise. Note
1032 that you may not want to specify the base $
0$ if you are parsing the numbers
1033 which may have leading zeroes as they can yield unexpected (to the user not
1034 familiar with C) results.
1036 \wxheading{See also
}
1038 \helpref{wxString::ToDouble
}{wxstringtodouble
},\\
1039 \helpref{wxString::ToULong
}{wxstringtoulong
}
1041 \membersection{wxString::ToULong
}\label{wxstringtoulong
}
1043 \constfunc{bool
}{ToULong
}{\param{unsigned long
}{ *val
},
\param{int
}{base = $
10$
}}
1045 Attempts to convert the string to an unsigned integer in base
{\it base
}.
1046 Returns
{\tt true
} on success in which case the number is stored in the
1047 location pointed to by
{\it val
} or
{\tt false
} if the string does not
1048 represent a valid number in the given base. Please notice that this function
1049 behaves in the same way as the standard
\texttt{strtoul()
} and so it simply
1050 converts negative numbers to unsigned representation instead of rejecting them
1051 (e.g. $-
1$ is returned as
\texttt{ULONG
\_MAX}).
1053 See
\helpref{wxString::ToLong
}{wxstringtolong
} for the more detailed
1054 description of the
{\it base
} parameter.
1056 \wxheading{See also
}
1058 \helpref{wxString::ToDouble
}{wxstringtodouble
},\\
1059 \helpref{wxString::ToLong
}{wxstringtolong
}
1061 \membersection{wxString::Trim
}\label{wxstringtrim
}
1063 \func{wxString\&
}{Trim
}{\param{bool
}{ fromRight = true
}}
1065 Removes spaces from the left or from the right (default).
1067 \membersection{wxString::Truncate
}\label{wxstringtruncate
}
1069 \func{wxString\&
}{Truncate
}{\param{size
\_t}{ len
}}
1071 Truncate the string to the given length.
1073 \membersection{wxString::UngetWriteBuf
}\label{wxstringungetwritebuf
}
1075 \func{void
}{UngetWriteBuf
}{\void}
1077 \func{void
}{UngetWriteBuf
}{\param{size
\_t }{len
}}
1079 Puts the string back into a reasonable state (in which it can be used
1081 \rtfsp\helpref{wxString::GetWriteBuf
}{wxstringgetwritebuf
} was called.
1083 The version of the function without the
{\it len
} parameter will calculate the
1084 new string length itself assuming that the string is terminated by the first
1085 {\tt NUL
} character in it while the second one will use the specified length
1086 and thus is the only version which should be used with the strings with
1087 embedded
{\tt NUL
}s (it is also slightly more efficient as
{\tt strlen()
}
1088 doesn't have to be called).
1090 \membersection{wxString::Upper
}\label{wxstringupper
}
1092 \constfunc{wxString
}{Upper
}{\void}
1094 Returns this string converted to upper case.
1096 \membersection{wxString::UpperCase
}\label{wxstringuppercase
}
1098 \func{void
}{UpperCase
}{\void}
1100 The same as MakeUpper.
1102 \membersection{wxString::wc
\_str}\label{wxstringwcstr
}
1104 \constfunc{const wchar
\_t*
}{wc
\_str}{\param{wxMBConv\&
}{ conv
}}
1106 \constfunc{const wxWCharBuffer
}{wc
\_str}{\param{wxMBConv\&
}{ conv
}}
1108 Returns wide character representation of the string.
1109 In ANSI build, converts using
\arg{conv
}'s
\helpref{cMB2WC
}{wxmbconvcmb2wc
}
1110 method and returns wxWCharBuffer. In Unicode build, this function is same
1111 as
\helpref{c
\_str}{wxstringcstr
}.
1112 The macro wxWX2WCbuf is defined as the correct return type (without const).
1114 \wxheading{See also
}
1116 \helpref{wxMBConv
}{wxmbconv
},
1117 \helpref{c
\_str}{wxstringcstr
},
\helpref{mb
\_str}{wxstringwcstr
},
1118 \helpref{fn
\_str}{wxstringfnstr
}
1120 \membersection{wxString::operator!
}\label{wxstringoperatornot
}
1122 \constfunc{bool
}{operator!
}{\void}
1124 Empty string is false, so !string will only return true if the string is empty.
1125 This allows the tests for NULLness of a
{\it const char *
} pointer and emptiness
1126 of the string to look the same in the code and makes it easier to port old code
1129 See also
\helpref{IsEmpty()
}{wxstringisempty
}.
1131 \membersection{wxString::operator $=$
}\label{wxstringoperatorassign
}
1133 \func{wxString\&
}{operator $=$
}{\param{const wxString\&
}{ str
}}
1135 \func{wxString\&
}{operator $=$
}{\param{const char*
}{ psz
}}
1137 \func{wxString\&
}{operator $=$
}{\param{char
}{ c
}}
1139 \func{wxString\&
}{operator $=$
}{\param{const unsigned char*
}{ psz
}}
1141 \func{wxString\&
}{operator $=$
}{\param{const wchar
\_t*
}{ pwz
}}
1143 Assignment: the effect of each operation is the same as for the corresponding
1144 constructor (see
\helpref{wxString constructors
}{wxstringconstruct
}).
1146 \membersection{wxString::operator $+$
}\label{wxstringoperatorplus
}
1148 Concatenation: all these operators return a new string equal to the
1149 concatenation of the operands.
1151 \func{wxString
}{operator $+$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1153 \func{wxString
}{operator $+$
}{\param{const wxString\&
}{ x
},
\param{const char*
}{ y
}}
1155 \func{wxString
}{operator $+$
}{\param{const wxString\&
}{ x
},
\param{char
}{ y
}}
1157 \func{wxString
}{operator $+$
}{\param{const char*
}{ x
},
\param{const wxString\&
}{ y
}}
1159 \membersection{wxString::operator $+=$
}\label{wxstringplusequal
}
1161 \func{void
}{operator $+=$
}{\param{const wxString\&
}{ str
}}
1163 \func{void
}{operator $+=$
}{\param{const char*
}{ psz
}}
1165 \func{void
}{operator $+=$
}{\param{char
}{ c
}}
1167 Concatenation in place: the argument is appended to the string.
1169 \membersection{wxString::operator
[]}\label{wxstringoperatorbracket
}
1171 \func{char\&
}{operator
[]}{\param{size
\_t}{ i
}}
1173 \func{char
}{operator
[]}{\param{size
\_t}{ i
}}
1175 \func{char
}{operator
[]}{\param{int
}{ i
}}
1179 \membersection{wxString::operator ()
}\label{wxstringoperatorparenth
}
1181 \func{wxString
}{operator ()
}{\param{size
\_t}{ start
},
\param{size
\_t}{ len
}}
1183 Same as Mid (substring extraction).
1185 \membersection{wxString::operator
\cinsert}\label{wxstringoperatorout
}
1187 \func{wxString\&
}{operator
\cinsert}{\param{const wxString\&
}{ str
}}
1189 \func{wxString\&
}{operator
\cinsert}{\param{const char*
}{ psz
}}
1191 \func{wxString\&
}{operator
\cinsert}{\param{char
}{ch
}}
1195 \func{wxString\&
}{operator
\cinsert}{\param{int
}{ i
}}
1197 \func{wxString\&
}{operator
\cinsert}{\param{float
}{ f
}}
1199 \func{wxString\&
}{operator
\cinsert}{\param{double
}{ d
}}
1201 These functions work as C++ stream insertion operators: they insert the given
1202 value into the string. Precision or format cannot be set using them, you can use
1203 \helpref{Printf
}{wxstringprintf
} for this.
1205 \membersection{wxString::operator
\cextract}\label{wxstringoperatorin
}
1207 \func{friend istream\&
}{operator
\cextract}{\param{istream\&
}{ is
},
\param{wxString\&
}{ str
}}
1209 Extraction from a stream.
1211 \membersection{wxString::operator const char*
}\label{wxstringoperatorconstcharpt
}
1213 \constfunc{}{operator const char*
}{\void}
1215 Implicit conversion to a C string.
1217 \membersection{Comparison operators
}\label{wxstringcomparison
}
1219 \func{bool
}{operator $==$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1221 \func{bool
}{operator $==$
}{\param{const wxString\&
}{ x
},
\param{const char*
}{ t
}}
1223 \func{bool
}{operator $!=$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1225 \func{bool
}{operator $!=$
}{\param{const wxString\&
}{ x
},
\param{const char*
}{ t
}}
1227 \func{bool
}{operator $>$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1229 \func{bool
}{operator $>$
}{\param{const wxString\&
}{ x
},
\param{const char*
}{ t
}}
1231 \func{bool
}{operator $>=$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1233 \func{bool
}{operator $>=$
}{\param{const wxString\&
}{ x
},
\param{const char*
}{ t
}}
1235 \func{bool
}{operator $<$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1237 \func{bool
}{operator $<$
}{\param{const wxString\&
}{ x
},
\param{const char*
}{ t
}}
1239 \func{bool
}{operator $<=$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1241 \func{bool
}{operator $<=$
}{\param{const wxString\&
}{ x
},
\param{const char*
}{ t
}}
1245 These comparisons are case-sensitive.
1248 \section{\class{wxStringBuffer
}}\label{wxstringbuffer
}
1250 This tiny class allows to conveniently access the
\helpref{wxString
}{wxstring
}
1251 internal buffer as a writable pointer without any risk of forgetting to restore
1252 the string to the usable state later.
1254 For example, assuming you have a low-level OS function called
1255 {\tt GetMeaningOfLifeAsString(char *)
} returning the value in the provided
1256 buffer (which must be writable, of course) you might call it like this:
1260 GetMeaningOfLifeAsString(wxStringBuffer(theAnswer,
1024));
1261 if ( theAnswer != "
42" )
1263 wxLogError("Something is very wrong!");
1267 Note that the exact usage of this depends on whether on not wxUSE
\_STL is enabled. If
1268 wxUSE
\_STL is enabled, wxStringBuffer creates a separate empty character buffer, and
1269 if wxUSE
\_STL is disabled, it uses GetWriteBuf() from wxString, keeping the same buffer
1270 wxString uses intact. In other words, relying on wxStringBuffer containing the old
1271 wxString data is probably not a good idea if you want to build your program in both
1272 with and without wxUSE
\_STL.
1274 \wxheading{Derived from
}
1278 \wxheading{Include files
}
1282 \latexignore{\rtfignore{\wxheading{Members
}}}
1284 \membersection{wxStringBuffer::wxStringBuffer
}\label{wxstringbufferctor
}
1286 \func{}{wxStringBuffer
}{\param{const wxString\&
}{str
},
\param{size
\_t }{len
}}
1288 Constructs a writable string buffer object associated with the given string
1289 and containing enough space for at least
{\it len
} characters. Basically, this
1290 is equivalent to calling
\helpref{GetWriteBuf
}{wxstringgetwritebuf
} and
1293 \membersection{wxStringBuffer::
\destruct{wxStringBuffer
}}\label{wxstringbufferdtor
}
1295 \func{}{\destruct{wxStringBuffer
}}{\void}
1297 Restores the string passed to the constructor to the usable state by calling
1298 \helpref{UngetWriteBuf
}{wxstringungetwritebuf
} on it.
1300 \membersection{wxStringBuffer::operator wxChar *
}\label{wxstringbufferwxchar
}
1302 \func{wxChar *
}{operator wxChar *
}{\void}
1304 Returns the writable pointer to a buffer of the size at least equal to the
1305 length specified in the constructor.
1309 \section{\class{wxStringBufferLength
}}\label{wxstringbufferlength
}
1311 This tiny class allows to conveniently access the
\helpref{wxString
}{wxstring
}
1312 internal buffer as a writable pointer without any risk of forgetting to restore
1313 the string to the usable state later, and allows the user to set the internal
1314 length of the string.
1316 For example, assuming you have a low-level OS function called
1317 {\tt int GetMeaningOfLifeAsString(char *)
} copying the value in the provided
1318 buffer (which must be writable, of course), and returning the actual length
1319 of the string, you might call it like this:
1323 wxStringBuffer theAnswerBuffer(theAnswer,
1024);
1324 int nLength = GetMeaningOfLifeAsString(theAnswerBuffer);
1325 theAnswerBuffer.SetLength(nLength);
1326 if ( theAnswer != "
42" )
1328 wxLogError("Something is very wrong!");
1332 Note that the exact usage of this depends on whether on not wxUSE
\_STL is enabled. If
1333 wxUSE
\_STL is enabled, wxStringBuffer creates a separate empty character buffer, and
1334 if wxUSE
\_STL is disabled, it uses GetWriteBuf() from wxString, keeping the same buffer
1335 wxString uses intact. In other words, relying on wxStringBuffer containing the old
1336 wxString data is probably not a good idea if you want to build your program in both
1337 with and without wxUSE
\_STL.
1339 Note that SetLength
{\tt must
} be called before wxStringBufferLength destructs.
1341 \wxheading{Derived from
}
1345 \wxheading{Include files
}
1349 \latexignore{\rtfignore{\wxheading{Members
}}}
1351 \membersection{wxStringBufferLength::wxStringBufferLength
}\label{wxstringbufferlengthctor
}
1353 \func{}{wxStringBufferLength
}{\param{const wxString\&
}{str
},
\param{size
\_t }{len
}}
1355 Constructs a writable string buffer object associated with the given string
1356 and containing enough space for at least
{\it len
} characters. Basically, this
1357 is equivalent to calling
\helpref{GetWriteBuf
}{wxstringgetwritebuf
} and
1360 \membersection{wxStringBufferLength::
\destruct{wxStringBufferLength
}}\label{wxstringbufferlengthdtor
}
1362 \func{}{\destruct{wxStringBufferLength
}}{\void}
1364 Restores the string passed to the constructor to the usable state by calling
1365 \helpref{UngetWriteBuf
}{wxstringungetwritebuf
} on it.
1367 \membersection{wxStringBufferLength::SetLength
}\label{wxstringbufferlengthsetlength
}
1369 \func{void
}{SetLength
}{\param{size
\_t }{nLength
}}
1371 Sets the internal length of the string referred to by wxStringBufferLength to
1372 {\it nLength
} characters.
1374 Must be called before wxStringBufferLength destructs.
1376 \membersection{wxStringBufferLength::operator wxChar *
}\label{wxstringbufferlengthwxchar
}
1378 \func{wxChar *
}{operator wxChar *
}{\void}
1380 Returns the writable pointer to a buffer of the size at least equal to the
1381 length specified in the constructor.