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.
6 As explained there, wxString implements most of the methods of the std::string
8 These standard functions are not documented in this manual, please see the
9 \urlref{STL documentation
}{http://www.cppreference.com/cppstl.html
}).
10 The behaviour of all these functions is identical to the behaviour described
13 You may notice that wxString sometimes has many functions which do the same
14 thing like, for example,
\helpref{Length()
}{wxstringlength
},
15 \helpref{Len()
}{wxstringlen
} and
{\tt length()
} which all return the string
16 length. In all cases of such duplication the
{\tt std::string
}-compatible
17 method (
{\tt length()
} in this case, always the lowercase version) should be
18 used as it will ensure smoother transition to
{\tt std::string
} when wxWidgets
19 starts using it instead of wxString.
21 \wxheading{Derived from
}
25 \wxheading{Include files
}
29 \wxheading{Predefined objects
}
37 \helpref{wxString overview
}{wxstringoverview
},
\helpref{Unicode overview
}{unicode
}
39 \latexignore{\rtfignore{\wxheading{Function groups
}}}
42 \membersection{Constructors and assignment operators
}\label{constructorsinwxstring
}
44 A string may be constructed either from a C string, (some number of copies of)
45 a single character or a wide (UNICODE) string. For all constructors (except the
46 default which creates an empty string) there is also a corresponding assignment
49 \helpref{wxString
}{wxstringconstruct
}\\
50 \helpref{operator $=$
}{wxstringoperatorassign
}\\
51 \helpref{\destruct{wxString
}}{wxstringdestruct
}
54 \membersection{String length
}\label{lengthfunctionsinwxstring
}
56 These functions return the string length and check whether the string is empty
59 \helpref{Len
}{wxstringlen
}\\
60 \helpref{IsEmpty
}{wxstringisempty
}\\
61 \helpref{operator!
}{wxstringoperatornot
}\\
62 \helpref{Empty
}{wxstringempty
}\\
63 \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
}
93 \membersection{Concatenation
}\label{concatenationinwxstring
}
95 Anything may be concatenated (appended to) with a string. However, you can't
96 append something to a C string (including literal constants), so to do this it
97 should be converted to a wxString first.
99 \helpref{operator
\cinsert}{wxstringoperatorout
}\\
100 \helpref{operator $+=$
}{wxstringplusequal
}\\
101 \helpref{operator $+$
}{wxstringoperatorplus
}\\
102 \helpref{Append
}{wxstringappend
}\\
103 \helpref{Prepend
}{wxstringprepend
}
106 \membersection{Comparison
}\label{comparisoninwxstring
}
108 The default comparison function
\helpref{Cmp
}{wxstringcmp
} is case-sensitive and
109 so is the default version of
\helpref{IsSameAs
}{wxstringissameas
}. For case
110 insensitive comparisons you should use
\helpref{CmpNoCase
}{wxstringcmpnocase
} or
111 give a second parameter to IsSameAs. This last function is may be more
112 convenient if only equality of the strings matters because it returns a boolean
113 \true value if the strings are the same and not
0 (which is usually false in C)
116 \helpref{Matches
}{wxstringmatches
} is a poor man's regular expression matcher:
117 it only understands '*' and '?' metacharacters in the sense of DOS command line
120 \helpref{StartsWith
}{wxstringstartswith
} is helpful when parsing a line of
121 text which should start with some predefined prefix and is more efficient than
122 doing direct string comparison as you would also have to precalculate the
123 length of the prefix then.
125 \helpref{Cmp
}{wxstringcmp
}\\
126 \helpref{CmpNoCase
}{wxstringcmpnocase
}\\
127 \helpref{IsSameAs
}{wxstringissameas
}\\
128 \helpref{Matches
}{wxstringmatches
}\\
129 \helpref{StartsWith
}{wxstringstartswith
}\\
130 \helpref{EndsWith
}{wxstringendswith
}
133 \membersection{Substring extraction
}\label{substringextractioninwxstring
}
135 These functions allow to extract substring from this string. All of them don't
136 modify the original string and return a new string containing the extracted
139 \helpref{Mid
}{wxstringmid
}\\
140 \helpref{operator()
}{wxstringoperatorparenth
}\\
141 \helpref{Left
}{wxstringleft
}\\
142 \helpref{Right
}{wxstringright
}\\
143 \helpref{BeforeFirst
}{wxstringbeforefirst
}\\
144 \helpref{BeforeLast
}{wxstringbeforelast
}\\
145 \helpref{AfterFirst
}{wxstringafterfirst
}\\
146 \helpref{AfterLast
}{wxstringafterlast
}\\
147 \helpref{StartsWith
}{wxstringstartswith
}\\
148 \helpref{EndsWith
}{wxstringendswith
}
152 \membersection{Case conversion
}\label{caseconversioninwxstring
}
154 The MakeXXX() variants modify the string in place, while the other functions
155 return a new string which contains the original text converted to the upper or
156 lower case and leave the original string unchanged.
158 \helpref{MakeUpper
}{wxstringmakeupper
}\\
159 \helpref{Upper
}{wxstringupper
}\\
160 \helpref{MakeLower
}{wxstringmakelower
}\\
161 \helpref{Lower
}{wxstringlower
}
164 \membersection{Searching and replacing
}\label{searchingandreplacinginwxstring
}
166 These functions replace the standard
{\it strchr()
} and
{\it strstr()
}
169 \helpref{Find
}{wxstringfind
}\\
170 \helpref{Replace
}{wxstringreplace
}
173 \membersection{Conversion to numbers
}\label{conversiontonumbersinwxstring
}
175 The string provides functions for conversion to signed and unsigned integer and
176 floating point numbers. All three functions take a pointer to the variable to
177 put the numeric value in and return
\true if the
{\bf entire
} string could be
178 converted to a number.
180 \helpref{ToLong
}{wxstringtolong
}\\
181 \helpref{ToLongLong
}{wxstringtolonglong
}\\
182 \helpref{ToULong
}{wxstringtoulong
}\\
183 \helpref{ToULongLong
}{wxstringtoulonglong
}\\
184 \helpref{ToDouble
}{wxstringtodouble
}
187 \membersection{Writing values into the string
}\label{writingintostringinwxstring
}
189 Both formatted versions (
\helpref{Printf
}{wxstringprintf
}) and stream-like
190 insertion operators exist (for basic types only). Additionally, the
191 \helpref{Format
}{wxstringformat
} function allows to use simply append
192 formatted value to a string:
195 // the following
2 snippets are equivalent
198 s += wxString::Format("
%d", n);
201 s.Printf("...
%d", n);
204 \helpref{Format
}{wxstringformat
}\\
205 \helpref{FormatV
}{wxstringformatv
}\\
206 \helpref{Printf
}{wxstringprintf
}\\
207 \helpref{PrintfV
}{wxstringprintfv
}\\
208 \helpref{operator
\cinsert}{wxstringoperatorout
}
211 \membersection{Memory management
}\label{memoryinwxstring
}
213 These are "advanced" functions and they will be needed quite rarely.
214 \helpref{Alloc
}{wxstringalloc
} and
\helpref{Shrink
}{wxstringshrink
} are only
215 interesting for optimization purposes.
216 \helpref{wxStringBuffer
}{wxstringbuffer
}
217 and
\helpref{wxStringBufferLength
}{wxstringbufferlength
} classes may be very
218 useful when working with some external API which requires the caller to provide
221 \helpref{Alloc
}{wxstringalloc
}\\
222 \helpref{Shrink
}{wxstringshrink
}\\
223 \helpref{wxStringBuffer
}{wxstringbuffer
}\\
224 \helpref{wxStringBufferLength
}{wxstringbufferlength
}
227 \membersection{Miscellaneous
}\label{miscellaneousinwxstring
}
229 Other string functions.
231 \helpref{Trim
}{wxstringtrim
}\\
232 \helpref{Truncate
}{wxstringtruncate
}\\
233 \helpref{Pad
}{wxstringpad
}
236 \membersection{wxWidgets
1.xx compatibility functions
}\label{backwardcompatibilityinwxstring
}
238 These functions are deprecated, please consider using new wxWidgets
2.0
239 functions instead of them (or, even better, std::string compatible variants).
241 % keep ordered alphabetically
242 \helpref{CompareTo
}{wxstringcompareto
}\\
243 \helpref{Contains
}{wxstringcontains
}\\
244 \helpref{First
}{wxstringfirst
}\\
245 \helpref{Freq
}{wxstringfreq
}\\
246 \helpref{Index
}{wxstringindex
}\\
247 \helpref{IsAscii
}{wxstringisascii
}\\
248 \helpref{IsNull
}{wxstringisnull
}\\
249 \helpref{IsNumber
}{wxstringisnumber
}\\
250 \helpref{IsWord
}{wxstringisword
}\\
251 \helpref{Last
}{wxstringlast
}\\
252 \helpref{Length
}{wxstringlength
}\\
253 \helpref{LowerCase
}{wxstringlowercase
}\\
254 \helpref{Remove
}{wxstringremove
}\\
255 \helpref{Strip
}{wxstringstrip
}\\
256 \helpref{SubString
}{wxstringsubstring
}\\
257 \helpref{UpperCase
}{wxstringuppercase
}
260 \membersection{std::string compatibility functions
}\label{wxstringat
}
262 The supported functions are only listed here, please see any STL reference for
266 // take nLen chars starting at nPos
267 wxString(const wxString& str, size_t nPos, size_t nLen);
268 // take all characters from pStart to pEnd (poor man's iterators)
269 wxString(const void *pStart, const void *pEnd);
271 // lib.string.capacity
272 // return the length of the string
274 // return the length of the string
275 size_t length() const;
276 // return the maximum size of the string
277 size_t max_size() const;
278 // resize the string, filling the space with c if c !=
0
279 void resize(size_t nSize, char ch = '
\0');
280 // delete the contents of the string
282 // returns true if the string is empty
286 // return the character at position n
287 char at(size_t n) const;
288 // returns the writable character at position n
291 // lib.string.modifiers
293 wxString& append(const wxString& str);
294 // append elements str
[pos
], ..., str
[pos+n
]
295 wxString& append(const wxString& str, size_t pos, size_t n);
296 // append first n (or all if n == npos) characters of sz
297 wxString& append(const char *sz, size_t n = npos);
299 // append n copies of ch
300 wxString& append(size_t n, char ch);
302 // same as `this_string = str'
303 wxString& assign(const wxString& str);
304 // same as ` = str
[pos..pos + n
]
305 wxString& assign(const wxString& str, size_t pos, size_t n);
306 // same as `= first n (or all if n == npos) characters of sz'
307 wxString& assign(const char *sz, size_t n = npos);
308 // same as `= n copies of ch'
309 wxString& assign(size_t n, char ch);
311 // insert another string
312 wxString& insert(size_t nPos, const wxString& str);
313 // insert n chars of str starting at nStart (in str)
314 wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n);
316 // insert first n (or all if n == npos) characters of sz
317 wxString& insert(size_t nPos, const char *sz, size_t n = npos);
318 // insert n copies of ch
319 wxString& insert(size_t nPos, size_t n, char ch);
321 // delete characters from nStart to nStart + nLen
322 wxString& erase(size_t nStart =
0, size_t nLen = npos);
324 // replaces the substring of length nLen starting at nStart
325 wxString& replace(size_t nStart, size_t nLen, const char* sz);
326 // replaces the substring with nCount copies of ch
327 wxString& replace(size_t nStart, size_t nLen, size_t nCount, char ch);
328 // replaces a substring with another substring
329 wxString& replace(size_t nStart, size_t nLen,
330 const wxString& str, size_t nStart2, size_t nLen2);
331 // replaces the substring with first nCount chars of sz
332 wxString& replace(size_t nStart, size_t nLen,
333 const char* sz, size_t nCount);
336 void swap(wxString& str);
338 // All find() functions take the nStart argument which specifies the
339 // position to start the search on, the default value is
0. All functions
340 // return npos if there were no match.
343 size_t find(const wxString& str, size_t nStart =
0) const;
345 // find first n characters of sz
346 size_t find(const char* sz, size_t nStart =
0, size_t n = npos) const;
348 // find the first occurrence of character ch after nStart
349 size_t find(char ch, size_t nStart =
0) const;
351 // rfind() family is exactly like find() but works right to left
353 // as find, but from the end
354 size_t rfind(const wxString& str, size_t nStart = npos) const;
356 // as find, but from the end
357 size_t rfind(const char* sz, size_t nStart = npos,
358 size_t n = npos) const;
359 // as find, but from the end
360 size_t rfind(char ch, size_t nStart = npos) const;
362 // find first/last occurrence of any character in the set
365 size_t find_first_of(const wxString& str, size_t nStart =
0) const;
367 size_t find_first_of(const char* sz, size_t nStart =
0) const;
368 // same as find(char, size_t)
369 size_t find_first_of(char c, size_t nStart =
0) const;
371 size_t find_last_of (const wxString& str, size_t nStart = npos) const;
373 size_t find_last_of (const char* s, size_t nStart = npos) const;
374 // same as rfind(char, size_t)
375 size_t find_last_of (char c, size_t nStart = npos) const;
377 // find first/last occurrence of any character not in the set
380 size_t find_first_not_of(const wxString& str, size_t nStart =
0) const;
382 size_t find_first_not_of(const char* s, size_t nStart =
0) const;
384 size_t find_first_not_of(char ch, size_t nStart =
0) const;
386 size_t find_last_not_of(const wxString& str, size_t nStart=npos) const;
388 size_t find_last_not_of(const char* s, size_t nStart = npos) const;
390 size_t find_last_not_of(char ch, size_t nStart = npos) const;
392 // All compare functions return a negative, zero or positive value
393 // if the
[sub
]string is less, equal or greater than the compare() argument.
395 // just like strcmp()
396 int compare(const wxString& str) const;
397 // comparison with a substring
398 int compare(size_t nStart, size_t nLen, const wxString& str) const;
399 // comparison of
2 substrings
400 int compare(size_t nStart, size_t nLen,
401 const wxString& str, size_t nStart2, size_t nLen2) const;
402 // just like strcmp()
403 int compare(const char* sz) const;
404 // substring comparison with first nCount characters of sz
405 int compare(size_t nStart, size_t nLen,
406 const char* sz, size_t nCount = npos) const;
408 // substring extraction
409 wxString substr(size_t nStart =
0, size_t nLen = npos) const;
412 %%%%% MEMBERS HERE %%%%%
413 \helponly{\insertatlevel{2}{
420 \membersection{wxString::wxString
}\label{wxstringconstruct
}
422 \func{}{wxString
}{\void}
424 Default constructor. Initializes the string to
{\tt ""
} (empty string).
426 \func{}{wxString
}{\param{const wxString\&
}{ x
}}
430 \func{}{wxString
}{\param{wxChar
}{ ch
},
\param{size
\_t}{ n =
1}}
432 Constructs a string of
{\it n
} copies of character
{\it ch
}.
434 \func{}{wxString
}{\param{const wxChar*
}{ psz
},
\param{size
\_t}{ nLength = wxSTRING
\_MAXLEN}}
436 Takes first
{\it nLength
} characters from the C string
{\it psz
}.
437 The default value of
{\tt wxSTRING
\_MAXLEN} means to take all the string.
439 Note that this constructor may be used even if
{\it psz
} points to a buffer
440 with binary data (i.e. containing
{\tt NUL
} characters) as long as you provide
441 the correct value for
{\it nLength
}. However, the default form of it works
442 only with strings without intermediate
{\tt NUL
}s because it uses
443 {\tt strlen()
} to calculate the effective length and it would not give correct
446 \func{}{wxString
}{\param{const unsigned char*
}{ psz
},
\param{size
\_t}{ nLength = wxSTRING
\_MAXLEN}}
448 For compilers using unsigned char: takes first
{\it nLength
} characters from the C string
{\it psz
}.
449 The default value of
{\tt wxSTRING
\_MAXLEN} means take all the string.
450 For ANSI builds only (note the use of
{\tt char
} instead of
{\tt wxChar
}).
452 \wxheading{Constructors with conversion
}
454 The following constructors allow you to construct wxString from a wide string
455 in ANSI build or from a C string in Unicode build.
457 \func{}{wxString
}{\param{const wchar
\_t*
}{ psz
},
\param{wxMBConv\&
}{ conv
},
\param{size
\_t}{ nLength = wxSTRING
\_MAXLEN}}
459 Initializes the string from first
\arg{nLength
} characters of wide string.
460 The default value of
{\tt wxSTRING
\_MAXLEN} means take all the string.
461 In ANSI build,
\arg{conv
}'s
462 \helpref{WC2MB
}{wxmbconvwc2mb
} method is called to
463 convert
\arg{psz
} to wide string. It is ignored in Unicode build.
465 \func{}{wxString
}{\param{const char*
}{ psz
},
\param{wxMBConv\&
}{ conv = wxConvLibc
},
\param{size
\_t}{ nLength = wxSTRING
\_MAXLEN}}
467 Initializes the string from first
\arg{nLength
} characters of C string.
468 The default value of
{\tt wxSTRING
\_MAXLEN} means take all the string.
469 In Unicode build,
\arg{conv
}'s
470 \helpref{MB2WC
}{wxmbconvmb2wc
} method is called to
471 convert
\arg{psz
} to wide string (the default converter uses current locale's
472 charset). It is ignored in ANSI build.
476 \helpref{wxMBConv classes
}{mbconvclasses
},
\helpref{mb
\_str}{wxstringmbstr
},
477 \helpref{wc
\_str}{wxstringwcstr
}
480 \membersection{wxString::
\destruct{wxString
}}\label{wxstringdestruct
}
482 \func{}{\destruct{wxString
}}{\void}
484 String destructor. Note that this is not virtual, so wxString must not be inherited from.
487 \membersection{wxString::Alloc
}\label{wxstringalloc
}
489 \func{void
}{Alloc
}{\param{size
\_t}{ nLen
}}
491 Preallocate enough space for wxString to store
{\it nLen
} characters. This function
492 may be used to increase speed when the string is constructed by repeated
497 // delete all vowels from the string
498 wxString DeleteAllVowels(const wxString& original)
502 size_t len = original.length();
506 for ( size_t n =
0; n < len; n++ )
508 if ( strchr("aeuio", tolower(original
[n
])) == NULL )
509 result += original
[n
];
517 because it will avoid the need to reallocate string memory many times (in case
518 of long strings). Note that it does not set the maximal length of a string - it
519 will still expand if more than
{\it nLen
} characters are stored in it. Also, it
520 does not truncate the existing string (use
521 \helpref{Truncate()
}{wxstringtruncate
} for this) even if its current length is
522 greater than
{\it nLen
}
525 \membersection{wxString::Append
}\label{wxstringappend
}
527 \func{wxString\&
}{Append
}{\param{const wxChar*
}{ psz
}}
529 Concatenates
{\it psz
} to this string, returning a reference to it.
531 \func{wxString\&
}{Append
}{\param{wxChar
}{ ch
},
\param{int
}{ count =
1}}
533 Concatenates character
{\it ch
} to this string,
{\it count
} times, returning a reference
537 \membersection{wxString::AfterFirst
}\label{wxstringafterfirst
}
539 \constfunc{wxString
}{AfterFirst
}{\param{wxChar
}{ ch
}}
541 Gets all the characters after the first occurrence of
{\it ch
}.
542 Returns the empty string if
{\it ch
} is not found.
545 \membersection{wxString::AfterLast
}\label{wxstringafterlast
}
547 \constfunc{wxString
}{AfterLast
}{\param{wxChar
}{ ch
}}
549 Gets all the characters after the last occurrence of
{\it ch
}.
550 Returns the whole string if
{\it ch
} is not found.
553 \membersection{wxString::BeforeFirst
}\label{wxstringbeforefirst
}
555 \constfunc{wxString
}{BeforeFirst
}{\param{wxChar
}{ ch
}}
557 Gets all characters before the first occurrence of
{\it ch
}.
558 Returns the whole string if
{\it ch
} is not found.
561 \membersection{wxString::BeforeLast
}\label{wxstringbeforelast
}
563 \constfunc{wxString
}{BeforeLast
}{\param{wxChar
}{ ch
}}
565 Gets all characters before the last occurrence of
{\it ch
}.
566 Returns the empty string if
{\it ch
} is not found.
569 \membersection{wxString::c
\_str}\label{wxstringcstr
}
571 \constfunc{const wxChar *
}{c
\_str}{\void}
573 Returns a pointer to the string data (
{\tt const char*
} in ANSI build,
574 {\tt const wchar
\_t*
} in Unicode build).
576 Note that the returned value is not convertible to
{\tt char*
} or
577 {\tt wchar
\_t*
}, use
\helpref{char
\_str}{wxstringcharstr
} or
578 \helpref{wchar
\_string}{wxstringwcharstr
} if you need to pass string value
579 to a function expecting non-const pointer.
583 \helpref{mb
\_str}{wxstringmbstr
},
\helpref{wc
\_str}{wxstringwcstr
},
584 \helpref{fn
\_str}{wxstringfnstr
},
\helpref{char
\_str}{wxstringcharstr
},
585 \helpref{wchar
\_string}{wxstringwcharstr
}
587 \membersection{wxString::char
\_str}\label{wxstringcharstr
}
589 \constfunc{wxWritableCharBuffer
}{char
\_str}{\param{wxMBConv\&
}{ conv = wxConvLibc
}}
591 Returns an object with string data that is implicitly convertible to
592 {\tt char*
} pointer. Note that any change to the returned buffer is lost and so
593 this function is only usable for passing strings to legacy libraries that
594 don't have const-correct API. Use
\helpref{wxStringBuffer
}{wxstringbuffer
} if
595 you want to modify the string.
599 \helpref{mb
\_str}{wxstringmbstr
},
\helpref{wc
\_str}{wxstringwcstr
},
600 \helpref{fn
\_str}{wxstringfnstr
},
\helpref{c
\_str}{wxstringcstr
},
601 \helpref{wchar
\_str}{wxstringwcharstr
}
604 \membersection{wxString::Clear
}\label{wxstringclear
}
606 \func{void
}{Clear
}{\void}
608 Empties the string and frees memory occupied by it.
610 See also:
\helpref{Empty
}{wxstringempty
}
613 \membersection{wxString::Cmp
}\label{wxstringcmp
}
615 \constfunc{int
}{Cmp
}{\param{const wxString\&
}{ s
}}
617 \constfunc{int
}{Cmp
}{\param{const wxChar*
}{ psz
}}
619 Case-sensitive comparison.
621 Returns a positive value if the string is greater than the argument, zero if
622 it is equal to it or a negative value if it is less than the argument (same semantics
623 as the standard
{\it strcmp()
} function).
625 See also
\helpref{CmpNoCase
}{wxstringcmpnocase
},
\helpref{IsSameAs
}{wxstringissameas
}.
628 \membersection{wxString::CmpNoCase
}\label{wxstringcmpnocase
}
630 \constfunc{int
}{CmpNoCase
}{\param{const wxString\&
}{ s
}}
632 \constfunc{int
}{CmpNoCase
}{\param{const wxChar*
}{ psz
}}
634 Case-insensitive comparison.
636 Returns a positive value if the string is greater than the argument, zero if
637 it is equal to it or a negative value if it is less than the argument (same semantics
638 as the standard
{\it strcmp()
} function).
640 See also
\helpref{Cmp
}{wxstringcmp
},
\helpref{IsSameAs
}{wxstringissameas
}.
643 \membersection{wxString::CompareTo
}\label{wxstringcompareto
}
646 enum wxString::caseCompare
{exact, ignoreCase
};
649 \constfunc{int
}{CompareTo
}{\param{const wxChar*
}{ psz
},
\param{caseCompare
}{ cmp = exact
}}
651 Case-sensitive comparison. Returns
0 if equal,
1 if greater or -
1 if less.
653 This is a wxWidgets
1.xx compatibility function; use
\helpref{Cmp
}{wxstringcmp
} instead.
656 \membersection{wxString::Contains
}\label{wxstringcontains
}
658 \constfunc{bool
}{Contains
}{\param{const wxString\&
}{ str
}}
660 Returns
\true if target appears anywhere in wxString; else
\false.
662 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
665 \membersection{wxString::Empty
}\label{wxstringempty
}
667 \func{void
}{Empty
}{\void}
669 Makes the string empty, but doesn't free memory occupied by the string.
671 See also:
\helpref{Clear()
}{wxstringclear
}.
674 \membersection{wxString::Find
}\label{wxstringfind
}
676 \constfunc{int
}{Find
}{\param{wxUniChar
}{ ch
},
\param{bool
}{ fromEnd = false
}}
678 Searches for the given character. Returns the starting index, or
{\tt wxNOT
\_FOUND} if not found.
680 \constfunc{int
}{Find
}{\param{const wxString\&
}{ sub
}}
682 Searches for the given string. Returns the starting index, or
{\tt wxNOT
\_FOUND} if not found.
685 \membersection{wxString::First
}\label{wxstringfirst
}
687 \func{int
}{First
}{\param{wxChar
}{ c
}}
689 \constfunc{int
}{First
}{\param{const wxChar*
}{ psz
}}
691 \constfunc{int
}{First
}{\param{const wxString\&
}{ str
}}
693 Same as
\helpref{Find
}{wxstringfind
}.
695 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
698 \membersection{wxString::fn
\_str}\label{wxstringfnstr
}
700 \constfunc{const wchar
\_t*
}{fn
\_str}{\void}
702 \constfunc{const char*
}{fn
\_str}{\void}
704 \constfunc{const wxCharBuffer
}{fn
\_str}{\void}
706 Returns string representation suitable for passing to OS' functions for
707 file handling. In ANSI build, this is same as
\helpref{c
\_str}{wxstringcstr
}.
708 In Unicode build, returned value can be either wide character string
709 or C string in charset matching the
{\tt wxConvFileName
} object, depending on
714 \helpref{wxMBConv
}{wxmbconv
},
715 \helpref{wc
\_str}{wxstringwcstr
},
\helpref{mb
\_str}{wxstringwcstr
}
718 \membersection{wxString::Format
}\label{wxstringformat
}
720 \func{static wxString
}{Format
}{\param{const wxChar
}{*format
},
\param{}{...
}}
722 This static function returns the string containing the result of calling
723 \helpref{Printf
}{wxstringprintf
} with the passed parameters on it.
727 \helpref{FormatV
}{wxstringformatv
},
\helpref{Printf
}{wxstringprintf
}
730 \membersection{wxString::FormatV
}\label{wxstringformatv
}
732 \func{static wxString
}{FormatV
}{\param{const wxChar
}{*format
},
\param{va
\_list }{argptr
}}
734 This static function returns the string containing the result of calling
735 \helpref{PrintfV
}{wxstringprintfv
} with the passed parameters on it.
739 \helpref{Format
}{wxstringformat
},
\helpref{PrintfV
}{wxstringprintfv
}
742 \membersection{wxString::Freq
}\label{wxstringfreq
}
744 \constfunc{int
}{Freq
}{\param{wxChar
}{ch
}}
746 Returns the number of occurrences of
{\it ch
} in the string.
748 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
750 \membersection{wxString::From8BitData
}\label{wxstringfrom8bitdata
}
752 \func{static wxString
}{From8BitData
}{\param{const char*
}{ buf
},
\param{size
\_t}{len
}}
754 \func{static wxString
}{From8BitData
}{\param{const char*
}{ buf
}}
756 Converts given buffer of binary data from
8-bit string to wxString. In Unicode
757 build, the string is interpreted as being in ISO-
8859-
1 encoding. The version
758 without
\arg{len
} parameter takes NUL-terminated data.
760 This is a convenience method useful when storing binary data in wxString.
766 \helpref{To8BitData
}{wxstringto8bitdata
}
769 \membersection{wxString::FromAscii
}\label{wxstringfromascii
}
771 \func{static wxString
}{FromAscii
}{\param{const char*
}{ s
}}
773 \func{static wxString
}{FromAscii
}{\param{const char
}{ c
}}
775 Converts the string or character from an ASCII,
7-bit form
776 to the native wxString representation. Most useful when using
777 a Unicode build of wxWidgets (note the use of
{\tt char
} instead of
{\tt wxChar
}).
778 Use
\helpref{wxString constructors
}{wxstringconstruct
} if you
779 need to convert from another charset.
782 \membersection{wxString::GetChar
}\label{wxstringgetchar
}
784 \constfunc{wxChar
}{GetChar
}{\param{size
\_t}{ n
}}
786 Returns the character at position
{\it n
} (read-only).
789 \membersection{wxString::GetData
}\label{wxstringgetdata
}
791 \constfunc{const wxChar*
}{GetData
}{\void}
793 wxWidgets compatibility conversion. Returns a constant pointer to the data in the string.
796 \membersection{wxString::GetWritableChar
}\label{wxstringgetwritablechar
}
798 \func{wxChar\&
}{GetWritableChar
}{\param{size
\_t}{ n
}}
800 Returns a reference to the character at position
{\it n
}.
803 \membersection{wxString::GetWriteBuf
}\label{wxstringgetwritebuf
}
805 \func{wxChar*
}{GetWriteBuf
}{\param{size
\_t}{ len
}}
807 Returns a writable buffer of at least
{\it len
} bytes.
808 It returns a pointer to a new memory block, and the
809 existing data will not be copied.
811 Call
\helpref{wxString::UngetWriteBuf
}{wxstringungetwritebuf
} as soon as
812 possible to put the string back into a reasonable state.
814 This method is deprecated, please use
815 \helpref{wxStringBuffer
}{wxstringbuffer
} or
816 \helpref{wxStringBufferLength
}{wxstringbufferlength
} instead.
819 \membersection{wxString::Index
}\label{wxstringindex
}
821 \constfunc{size
\_t}{Index
}{\param{wxChar
}{ ch
}}
823 \constfunc{size
\_t}{Index
}{\param{const wxChar*
}{ sz
}}
825 Same as
\helpref{wxString::Find
}{wxstringfind
}.
827 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
830 \membersection{wxString::IsAscii
}\label{wxstringisascii
}
832 \constfunc{bool
}{IsAscii
}{\void}
834 Returns
\true if the string contains only ASCII characters.
836 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
839 \membersection{wxString::IsEmpty
}\label{wxstringisempty
}
841 \constfunc{bool
}{IsEmpty
}{\void}
843 Returns
\true if the string is empty.
846 \membersection{wxString::IsNull
}\label{wxstringisnull
}
848 \constfunc{bool
}{IsNull
}{\void}
850 Returns
\true if the string is empty (same as
\helpref{IsEmpty
}{wxstringisempty
}).
852 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
855 \membersection{wxString::IsNumber
}\label{wxstringisnumber
}
857 \constfunc{bool
}{IsNumber
}{\void}
859 Returns
\true if the string is an integer (with possible sign).
861 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
864 \membersection{wxString::IsSameAs
}\label{wxstringissameas
}
866 \constfunc{bool
}{IsSameAs
}{\param{const wxChar*
}{ psz
},
\param{bool
}{ caseSensitive = true
}}
868 Test for string equality, case-sensitive (default) or not.
870 caseSensitive is
\true by default (case matters).
872 Returns
\true if strings are equal,
\false otherwise.
874 See also
\helpref{Cmp
}{wxstringcmp
},
\helpref{CmpNoCase
}{wxstringcmpnocase
}
876 \constfunc{bool
}{IsSameAs
}{\param{wxChar
}{ c
},
\param{bool
}{ caseSensitive = true
}}
878 Test whether the string is equal to the single character
{\it c
}. The test is
879 case-sensitive if
{\it caseSensitive
} is
\true (default) or not if it is
\false.
881 Returns
\true if the string is equal to the character,
\false otherwise.
883 See also
\helpref{Cmp
}{wxstringcmp
},
\helpref{CmpNoCase
}{wxstringcmpnocase
}
886 \membersection{wxString::IsWord
}\label{wxstringisword
}
888 \constfunc{bool
}{IsWord
}{\void}
890 Returns
\true if the string is a word.
892 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
895 \membersection{wxString::Last
}\label{wxstringlast
}
897 \constfunc{wxChar
}{Last
}{\void}
899 Returns the last character.
901 \func{wxChar\&
}{Last
}{\void}
903 Returns a reference to the last character (writable).
905 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
908 \membersection{wxString::Left
}\label{wxstringleft
}
910 \constfunc{wxString
}{Left
}{\param{size
\_t}{ count
}}
912 Returns the first
{\it count
} characters of the string.
915 \membersection{wxString::Len
}\label{wxstringlen
}
917 \constfunc{size
\_t}{Len
}{\void}
919 Returns the length of the string.
922 \membersection{wxString::Length
}\label{wxstringlength
}
924 \constfunc{size
\_t}{Length
}{\void}
926 Returns the length of the string (same as Len).
928 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
931 \membersection{wxString::Lower
}\label{wxstringlower
}
933 \constfunc{wxString
}{Lower
}{\void}
935 Returns this string converted to the lower case.
938 \membersection{wxString::LowerCase
}\label{wxstringlowercase
}
940 \func{void
}{LowerCase
}{\void}
944 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
947 \membersection{wxString::MakeLower
}\label{wxstringmakelower
}
949 \func{wxString\&
}{MakeLower
}{\void}
951 Converts all characters to lower case and returns the result.
954 \membersection{wxString::MakeUpper
}\label{wxstringmakeupper
}
956 \func{wxString\&
}{MakeUpper
}{\void}
958 Converts all characters to upper case and returns the result.
961 \membersection{wxString::Matches
}\label{wxstringmatches
}
963 \constfunc{bool
}{Matches
}{\param{const wxString\&
}{ mask
}}
965 Returns
\true if the string contents matches a mask containing '*' and '?'.
968 \membersection{wxString::mb
\_str}\label{wxstringmbstr
}
970 \constfunc{const char*
}{mb
\_str}{\param{wxMBConv\&
}{ conv = wxConvLibc
}}
972 \constfunc{const wxCharBuffer
}{mb
\_str}{\param{wxMBConv\&
}{ conv = wxConvLibc
}}
974 Returns multibyte (C string) representation of the string.
975 In Unicode build, converts using
\arg{conv
}'s
\helpref{cWC2MB
}{wxmbconvcwc2mb
}
976 method and returns wxCharBuffer. In ANSI build, this function is same
977 as
\helpref{c
\_str}{wxstringcstr
}.
978 The macro wxWX2MBbuf is defined as the correct return type (without const).
982 \helpref{wxMBConv
}{wxmbconv
},
983 \helpref{c
\_str}{wxstringcstr
},
\helpref{wc
\_str}{wxstringwcstr
},
984 \helpref{fn
\_str}{wxstringfnstr
},
\helpref{char
\_str}{wxstringcharstr
}
987 \membersection{wxString::Mid
}\label{wxstringmid
}
989 \constfunc{wxString
}{Mid
}{\param{size
\_t}{ first
},
\param{size
\_t}{ count = wxSTRING
\_MAXLEN}}
991 Returns a substring starting at
{\it first
}, with length
{\it count
}, or the rest of
992 the string if
{\it count
} is the default value.
995 \membersection{wxString::Pad
}\label{wxstringpad
}
997 \func{wxString\&
}{Pad
}{\param{size
\_t}{ count
},
\param{wxChar
}{ pad = ' '
},
\param{bool
}{ fromRight = true
}}
999 Adds
{\it count
} copies of
{\it pad
} to the beginning, or to the end of the string (the default).
1001 Removes spaces from the left or from the right (default).
1004 \membersection{wxString::Prepend
}\label{wxstringprepend
}
1006 \func{wxString\&
}{Prepend
}{\param{const wxString\&
}{ str
}}
1008 Prepends
{\it str
} to this string, returning a reference to this string.
1011 \membersection{wxString::Printf
}\label{wxstringprintf
}
1013 \func{int
}{Printf
}{\param{const wxChar*
}{pszFormat
},
\param{}{...
}}
1015 Similar to the standard function
{\it sprintf()
}. Returns the number of
1016 characters written, or an integer less than zero on error.
1018 Note that if
{\tt wxUSE
\_PRINTF\_POS\_PARAMS} is set to
1, then this function supports
1019 Unix98-style positional parameters:
1024 str.Printf(wxT("
%d %d %d"), 1, 2, 3);
1025 // str now contains "
1 2 3"
1027 str.Printf(wxT("
%2$d %3$d %1$d"), 1, 2, 3);
1028 // str now contains "
2 3 1"
1031 {\bf NB:
} This function will use a safe version of
{\it vsprintf()
} (usually called
1032 {\it vsnprintf()
}) whenever available to always allocate the buffer of correct
1033 size. Unfortunately, this function is not available on all platforms and the
1034 dangerous
{\it vsprintf()
} will be used then which may lead to buffer overflows.
1037 \membersection{wxString::PrintfV
}\label{wxstringprintfv
}
1039 \func{int
}{PrintfV
}{\param{const wxChar*
}{pszFormat
},
\param{va
\_list}{ argPtr
}}
1041 Similar to vprintf. Returns the number of characters written, or an integer less than zero
1045 \membersection{wxString::Remove
}\label{wxstringremove
}
1047 \func{wxString\&
}{Remove
}{\param{size
\_t}{ pos
}}
1049 Same as Truncate. Removes the portion from
{\it pos
} to the end of the string.
1051 \func{wxString\&
}{Remove
}{\param{size
\_t}{ pos
},
\param{size
\_t}{ len
}}
1053 Removes
{\it len
} characters from the string, starting at
{\it pos
}.
1055 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
1058 \membersection{wxString::RemoveLast
}\label{wxstringremovelast
}
1060 \func{wxString\&
}{RemoveLast
}{\void}
1062 Removes the last character.
1065 \membersection{wxString::Replace
}\label{wxstringreplace
}
1067 \func{size
\_t}{Replace
}{\param{const wxString\&
}{ strOld
},
\param{const wxString\&
}{ strNew
},
\param{bool
}{ replaceAll = true
}}
1069 Replace first (or all) occurrences of substring with another one.
1071 {\it replaceAll
}: global replace (default), or only the first occurrence.
1073 Returns the number of replacements made.
1076 \membersection{wxString::Right
}\label{wxstringright
}
1078 \constfunc{wxString
}{Right
}{\param{size
\_t}{ count
}}
1080 Returns the last
{\it count
} characters.
1083 \membersection{wxString::SetChar
}\label{wxstringsetchar
}
1085 \func{void
}{SetChar
}{\param{size
\_t}{ n
},
\param{wxChar
}{ch
}}
1087 Sets the character at position
{\it n
}.
1090 \membersection{wxString::Shrink
}\label{wxstringshrink
}
1092 \func{void
}{Shrink
}{\void}
1094 Minimizes the string's memory. This can be useful after a call to
1095 \helpref{Alloc()
}{wxstringalloc
} if too much memory were preallocated.
1098 \membersection{wxString::StartsWith
}\label{wxstringstartswith
}
1100 \constfunc{bool
}{StartsWith
}{\param{const wxChar
}{*prefix
},
\param{wxString
}{*rest = NULL
}}
1102 This function can be used to test if the string starts with the specified
1103 {\it prefix
}. If it does, the function will return
\true and put the rest
1104 of the string (i.e. after the prefix) into
{\it rest
} string if it is not
1105 {\tt NULL
}. Otherwise, the function returns
\false and doesn't modify the
1109 \membersection{wxString::EndsWith
}\label{wxstringendswith
}
1111 \constfunc{bool
}{EndsWith
}{\param{const wxChar
}{*suffix
},
\param{wxString
}{*rest = NULL
}}
1113 This function can be used to test if the string ends with the specified
1114 {\it suffix
}. If it does, the function will return
\true and put the
1115 beginning of the string before the suffix into
{\it rest
} string if it is not
1116 {\tt NULL
}. Otherwise, the function returns
\false and doesn't
1117 modify the
{\it rest
}.
1120 \membersection{wxString::Strip
}\label{wxstringstrip
}
1123 enum wxString::stripType
{leading =
0x1, trailing =
0x2, both =
0x3};
1126 \constfunc{wxString
}{Strip
}{\param{stripType
}{ s = trailing
}}
1128 Strip characters at the front and/or end. The same as Trim except that it
1129 doesn't change this string.
1131 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
1134 \membersection{wxString::SubString
}\label{wxstringsubstring
}
1136 \constfunc{wxString
}{SubString
}{\param{size
\_t}{ from
},
\param{size
\_t}{ to
}}
1138 Returns the part of the string between the indices
{\it from
} and
{\it to
}
1141 This is a wxWidgets
1.xx compatibility function, use
\helpref{Mid
}{wxstringmid
}
1142 instead (but note that parameters have different meaning).
1145 \membersection{wxString::To8BitData
}\label{wxstringto8bitdata
}
1147 \constfunc{const char*
}{To8BitData
}{\void}
1149 Converts the string to an
8-bit string (ANSI builds only).
1151 \constfunc{const wxCharBuffer
}{To8BitData
}{\void}
1153 Converts the string to an
8-bit string in ISO-
8859-
1 encoding in the form of
1154 a wxCharBuffer (Unicode builds only).
1156 This is a convenience method useful when storing binary data in wxString.
1160 \wxheading{See also
}
1162 \helpref{From8BitData
}{wxstringfrom8bitdata
}
1165 \membersection{wxString::ToAscii
}\label{wxstringtoascii
}
1167 \constfunc{const char*
}{ToAscii
}{\void}
1169 Converts the string to an ASCII,
7-bit string (ANSI builds only).
1171 \constfunc{const wxCharBuffer
}{ToAscii
}{\void}
1173 Converts the string to an ASCII,
7-bit string in the form of
1174 a wxCharBuffer (Unicode builds only).
1176 Note that this conversion only works if the string contains only ASCII
1177 characters. The
\helpref{mb
\_str}{wxstringmbstr
} method provides more
1178 powerful means of converting wxString to C string.
1181 \membersection{wxString::ToDouble
}\label{wxstringtodouble
}
1183 \constfunc{bool
}{ToDouble
}{\param{double
}{ *val
}}
1185 Attempts to convert the string to a floating point number. Returns
\true on
1186 success (the number is stored in the location pointed to by
{\it val
}) or
\false
1187 if the string does not represent such number.
1189 \wxheading{See also
}
1191 \helpref{wxString::ToLong
}{wxstringtolong
},\\
1192 \helpref{wxString::ToULong
}{wxstringtoulong
}
1195 \membersection{wxString::ToLong
}\label{wxstringtolong
}
1197 \constfunc{bool
}{ToLong
}{\param{long
}{ *val
},
\param{int
}{base = $
10$
}}
1199 Attempts to convert the string to a signed integer in base
{\it base
}. Returns
1200 \true on success in which case the number is stored in the location
1201 pointed to by
{\it val
} or
\false if the string does not represent a
1202 valid number in the given base.
1204 The value of
{\it base
} must be comprised between $
2$ and $
36$, inclusive, or
1205 be a special value $
0$ which means that the usual rules of
{\tt C
} numbers are
1206 applied: if the number starts with
{\tt 0x
} it is considered to be in base
1207 $
16$, if it starts with
{\tt 0} - in base $
8$ and in base $
10$ otherwise. Note
1208 that you may not want to specify the base $
0$ if you are parsing the numbers
1209 which may have leading zeroes as they can yield unexpected (to the user not
1210 familiar with C) results.
1212 \wxheading{See also
}
1214 \helpref{wxString::ToDouble
}{wxstringtodouble
},\\
1215 \helpref{wxString::ToULong
}{wxstringtoulong
}
1218 \membersection{wxString::ToLongLong
}\label{wxstringtolonglong
}
1220 \constfunc{bool
}{ToLongLong
}{\param{wxLongLong
\_t}{ *val
},
\param{int
}{base = $
10$
}}
1222 This is exactly the same as
\helpref{ToLong
}{wxstringtolong
} but works with
64
1223 bit integer numbers.
1225 Notice that currently it doesn't work (always returns
\false) if parsing of
64
1226 bit numbers is not supported by the underlying C run-time library. Compilers
1227 with C99 support and Microsoft Visual C++ version
7 and higher do support this.
1229 \wxheading{See also
}
1231 \helpref{wxString::ToLong
}{wxstringtolong
},\\
1232 \helpref{wxString::ToULongLong
}{wxstringtoulonglong
}
1235 \membersection{wxString::ToULong
}\label{wxstringtoulong
}
1237 \constfunc{bool
}{ToULong
}{\param{unsigned long
}{ *val
},
\param{int
}{base = $
10$
}}
1239 Attempts to convert the string to an unsigned integer in base
{\it base
}.
1240 Returns
\true on success in which case the number is stored in the
1241 location pointed to by
{\it val
} or
\false if the string does not
1242 represent a valid number in the given base. Please notice that this function
1243 behaves in the same way as the standard
\texttt{strtoul()
} and so it simply
1244 converts negative numbers to unsigned representation instead of rejecting them
1245 (e.g. $-
1$ is returned as
\texttt{ULONG
\_MAX}).
1247 See
\helpref{wxString::ToLong
}{wxstringtolong
} for the more detailed
1248 description of the
{\it base
} parameter.
1250 \wxheading{See also
}
1252 \helpref{wxString::ToDouble
}{wxstringtodouble
},\\
1253 \helpref{wxString::ToLong
}{wxstringtolong
}
1256 \membersection{wxString::ToULongLong
}\label{wxstringtoulonglong
}
1258 \constfunc{bool
}{ToULongLong
}{\param{wxULongLong
\_t}{ *val
},
\param{int
}{base = $
10$
}}
1260 This is exactly the same as
\helpref{ToULong
}{wxstringtoulong
} but works with
64
1261 bit integer numbers.
1263 Please see
\helpref{ToLongLong
}{wxstringtolonglong
} for additional remarks.
1266 \membersection{wxString::Trim
}\label{wxstringtrim
}
1268 \func{wxString\&
}{Trim
}{\param{bool
}{ fromRight = true
}}
1270 Removes white-space (space, tabs, form feed, newline and carriage return) from
1271 the left or from the right end of the string (right is default).
1274 \membersection{wxString::Truncate
}\label{wxstringtruncate
}
1276 \func{wxString\&
}{Truncate
}{\param{size
\_t}{ len
}}
1278 Truncate the string to the given length.
1281 \membersection{wxString::UngetWriteBuf
}\label{wxstringungetwritebuf
}
1283 \func{void
}{UngetWriteBuf
}{\void}
1285 \func{void
}{UngetWriteBuf
}{\param{size
\_t }{len
}}
1287 Puts the string back into a reasonable state (in which it can be used
1289 \rtfsp\helpref{wxString::GetWriteBuf
}{wxstringgetwritebuf
} was called.
1291 The version of the function without the
{\it len
} parameter will calculate the
1292 new string length itself assuming that the string is terminated by the first
1293 {\tt NUL
} character in it while the second one will use the specified length
1294 and thus is the only version which should be used with the strings with
1295 embedded
{\tt NUL
}s (it is also slightly more efficient as
{\tt strlen()
}
1296 doesn't have to be called).
1298 This method is deprecated, please use
1299 \helpref{wxStringBuffer
}{wxstringbuffer
} or
1300 \helpref{wxStringBufferLength
}{wxstringbufferlength
} instead.
1303 \membersection{wxString::Upper
}\label{wxstringupper
}
1305 \constfunc{wxString
}{Upper
}{\void}
1307 Returns this string converted to upper case.
1310 \membersection{wxString::UpperCase
}\label{wxstringuppercase
}
1312 \func{void
}{UpperCase
}{\void}
1314 The same as MakeUpper.
1316 This is a wxWidgets
1.xx compatibility function; you should not use it in new code.
1319 \membersection{wxString::wc
\_str}\label{wxstringwcstr
}
1321 \constfunc{const wchar
\_t*
}{wc
\_str}{\param{wxMBConv\&
}{ conv
}}
1323 \constfunc{const wxWCharBuffer
}{wc
\_str}{\param{wxMBConv\&
}{ conv
}}
1325 Returns wide character representation of the string.
1326 In ANSI build, converts using
\arg{conv
}'s
\helpref{cMB2WC
}{wxmbconvcmb2wc
}
1327 method and returns wxWCharBuffer. In Unicode build, this function is same
1328 as
\helpref{c
\_str}{wxstringcstr
}.
1329 The macro wxWX2WCbuf is defined as the correct return type (without const).
1331 \wxheading{See also
}
1333 \helpref{wxMBConv
}{wxmbconv
},
1334 \helpref{c
\_str}{wxstringcstr
},
\helpref{mb
\_str}{wxstringwcstr
},
1335 \helpref{fn
\_str}{wxstringfnstr
},
\helpref{wchar
\_str}{wxstringwcharstr
}
1337 \membersection{wxString::wchar
\_str}\label{wxstringwcharstr
}
1339 \constfunc{wxWritableWCharBuffer
}{wchar
\_str}{\void}
1341 Returns an object with string data that is implicitly convertible to
1342 {\tt char*
} pointer. Note that any change to the returned buffer is lost and so
1343 this function is only usable for passing strings to legacy libraries that
1344 don't have const-correct API. Use
\helpref{wxStringBuffer
}{wxstringbuffer
} if
1345 you want to modify the string.
1347 \wxheading{See also
}
1349 \helpref{mb
\_str}{wxstringmbstr
},
\helpref{wc
\_str}{wxstringwcstr
},
1350 \helpref{fn
\_str}{wxstringfnstr
},
\helpref{c
\_str}{wxstringcstr
},
1351 \helpref{char
\_str}{wxstringcharstr
}
1354 \membersection{wxString::operator!
}\label{wxstringoperatornot
}
1356 \constfunc{bool
}{operator!
}{\void}
1358 Empty string is
\false, so !string will only return
\true if the string is empty.
1359 This allows the tests for NULLness of a
{\it const wxChar *
} pointer and emptiness
1360 of the string to look the same in the code and makes it easier to port old code
1363 See also
\helpref{IsEmpty()
}{wxstringisempty
}.
1366 \membersection{wxString::operator $=$
}\label{wxstringoperatorassign
}
1368 \func{wxString\&
}{operator $=$
}{\param{const wxString\&
}{ str
}}
1370 \func{wxString\&
}{operator $=$
}{\param{const wxChar*
}{ psz
}}
1372 \func{wxString\&
}{operator $=$
}{\param{wxChar
}{ c
}}
1374 Assignment: the effect of each operation is the same as for the corresponding
1375 constructor (see
\helpref{wxString constructors
}{wxstringconstruct
}).
1378 \membersection{wxString::operator $+$
}\label{wxstringoperatorplus
}
1380 Concatenation: all these operators return a new string equal to the
1381 concatenation of the operands.
1383 \func{wxString
}{operator $+$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1385 \func{wxString
}{operator $+$
}{\param{const wxString\&
}{ x
},
\param{const wxChar*
}{ y
}}
1387 \func{wxString
}{operator $+$
}{\param{const wxString\&
}{ x
},
\param{wxChar
}{ y
}}
1389 \func{wxString
}{operator $+$
}{\param{const wxChar*
}{ x
},
\param{const wxString\&
}{ y
}}
1392 \membersection{wxString::operator $+=$
}\label{wxstringplusequal
}
1394 \func{void
}{operator $+=$
}{\param{const wxString\&
}{ str
}}
1396 \func{void
}{operator $+=$
}{\param{const wxChar*
}{ psz
}}
1398 \func{void
}{operator $+=$
}{\param{wxChar
}{ c
}}
1400 Concatenation in place: the argument is appended to the string.
1403 \membersection{wxString::operator
[]}\label{wxstringoperatorbracket
}
1405 \func{wxChar\&
}{operator
[]}{\param{size
\_t}{ i
}}
1407 \constfunc{wxChar
}{operator
[]}{\param{size
\_t}{ i
}}
1409 \func{wxChar\&
}{operator
[]}{\param{int
}{ i
}}
1411 \constfunc{wxChar
}{operator
[]}{\param{int
}{ i
}}
1416 \membersection{wxString::operator ()
}\label{wxstringoperatorparenth
}
1418 \func{wxString
}{operator ()
}{\param{size
\_t}{ start
},
\param{size
\_t}{ len
}}
1420 Same as Mid (substring extraction).
1423 \membersection{wxString::operator
\cinsert}\label{wxstringoperatorout
}
1425 \func{wxString\&
}{operator
\cinsert}{\param{const wxString\&
}{ str
}}
1427 \func{wxString\&
}{operator
\cinsert}{\param{const wxChar*
}{ psz
}}
1429 \func{wxString\&
}{operator
\cinsert}{\param{wxChar
}{ch
}}
1433 \func{wxString\&
}{operator
\cinsert}{\param{int
}{ i
}}
1435 \func{wxString\&
}{operator
\cinsert}{\param{float
}{ f
}}
1437 \func{wxString\&
}{operator
\cinsert}{\param{double
}{ d
}}
1439 These functions work as C++ stream insertion operators: they insert the given
1440 value into the string. Precision or format cannot be set using them, you can use
1441 \helpref{Printf
}{wxstringprintf
} for this.
1444 \membersection{wxString::operator
\cextract}\label{wxstringoperatorin
}
1446 \func{friend istream\&
}{operator
\cextract}{\param{istream\&
}{ is
},
\param{wxString\&
}{ str
}}
1448 Extraction from a stream.
1451 \membersection{wxString::operator const wxChar*
}\label{wxstringoperatorconstcharpt
}
1453 \constfunc{}{operator const wxChar*
}{\void}
1455 Implicit conversion to a C string.
1458 \membersection{Comparison operators
}\label{wxstringcomparison
}
1460 \func{bool
}{operator $==$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1462 \func{bool
}{operator $==$
}{\param{const wxString\&
}{ x
},
\param{const wxChar*
}{ t
}}
1464 \func{bool
}{operator $!=$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1466 \func{bool
}{operator $!=$
}{\param{const wxString\&
}{ x
},
\param{const wxChar*
}{ t
}}
1468 \func{bool
}{operator $>$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1470 \func{bool
}{operator $>$
}{\param{const wxString\&
}{ x
},
\param{const wxChar*
}{ t
}}
1472 \func{bool
}{operator $>=$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1474 \func{bool
}{operator $>=$
}{\param{const wxString\&
}{ x
},
\param{const wxChar*
}{ t
}}
1476 \func{bool
}{operator $<$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1478 \func{bool
}{operator $<$
}{\param{const wxString\&
}{ x
},
\param{const wxChar*
}{ t
}}
1480 \func{bool
}{operator $<=$
}{\param{const wxString\&
}{ x
},
\param{const wxString\&
}{ y
}}
1482 \func{bool
}{operator $<=$
}{\param{const wxString\&
}{ x
},
\param{const wxChar*
}{ t
}}
1486 These comparisons are case-sensitive.
1489 \section{\class{wxStringBuffer
}}\label{wxstringbuffer
}
1491 This tiny class allows to conveniently access the
\helpref{wxString
}{wxstring
}
1492 internal buffer as a writable pointer without any risk of forgetting to restore
1493 the string to the usable state later.
1495 For example, assuming you have a low-level OS function called
1496 {\tt GetMeaningOfLifeAsString(char *)
} returning the value in the provided
1497 buffer (which must be writable, of course) you might call it like this:
1501 GetMeaningOfLifeAsString(wxStringBuffer(theAnswer,
1024));
1502 if ( theAnswer != "
42" )
1504 wxLogError("Something is very wrong!");
1508 Note that the exact usage of this depends on whether on not wxUSE
\_STL is enabled. If
1509 wxUSE
\_STL is enabled, wxStringBuffer creates a separate empty character buffer, and
1510 if wxUSE
\_STL is disabled, it uses GetWriteBuf() from wxString, keeping the same buffer
1511 wxString uses intact. In other words, relying on wxStringBuffer containing the old
1512 wxString data is probably not a good idea if you want to build your program in both
1513 with and without wxUSE
\_STL.
1515 \wxheading{Derived from
}
1519 \wxheading{Include files
}
1523 \latexignore{\rtfignore{\wxheading{Members
}}}
1526 \membersection{wxStringBuffer::wxStringBuffer
}\label{wxstringbufferctor
}
1528 \func{}{wxStringBuffer
}{\param{const wxString\&
}{str
},
\param{size
\_t }{len
}}
1530 Constructs a writable string buffer object associated with the given string
1531 and containing enough space for at least
{\it len
} characters. Basically, this
1532 is equivalent to calling
\helpref{GetWriteBuf
}{wxstringgetwritebuf
} and
1536 \membersection{wxStringBuffer::
\destruct{wxStringBuffer
}}\label{wxstringbufferdtor
}
1538 \func{}{\destruct{wxStringBuffer
}}{\void}
1540 Restores the string passed to the constructor to the usable state by calling
1541 \helpref{UngetWriteBuf
}{wxstringungetwritebuf
} on it.
1544 \membersection{wxStringBuffer::operator wxChar *
}\label{wxstringbufferwxchar
}
1546 \func{wxChar *
}{operator wxChar *
}{\void}
1548 Returns the writable pointer to a buffer of the size at least equal to the
1549 length specified in the constructor.
1553 \section{\class{wxStringBufferLength
}}\label{wxstringbufferlength
}
1555 This tiny class allows to conveniently access the
\helpref{wxString
}{wxstring
}
1556 internal buffer as a writable pointer without any risk of forgetting to restore
1557 the string to the usable state later, and allows the user to set the internal
1558 length of the string.
1560 For example, assuming you have a low-level OS function called
1561 {\tt int GetMeaningOfLifeAsString(char *)
} copying the value in the provided
1562 buffer (which must be writable, of course), and returning the actual length
1563 of the string, you might call it like this:
1567 wxStringBuffer theAnswerBuffer(theAnswer,
1024);
1568 int nLength = GetMeaningOfLifeAsString(theAnswerBuffer);
1569 theAnswerBuffer.SetLength(nLength);
1570 if ( theAnswer != "
42" )
1572 wxLogError("Something is very wrong!");
1576 Note that the exact usage of this depends on whether on not wxUSE
\_STL is enabled. If
1577 wxUSE
\_STL is enabled, wxStringBuffer creates a separate empty character buffer, and
1578 if wxUSE
\_STL is disabled, it uses GetWriteBuf() from wxString, keeping the same buffer
1579 wxString uses intact. In other words, relying on wxStringBuffer containing the old
1580 wxString data is probably not a good idea if you want to build your program in both
1581 with and without wxUSE
\_STL.
1583 Note that SetLength
{\tt must
} be called before wxStringBufferLength destructs.
1585 \wxheading{Derived from
}
1589 \wxheading{Include files
}
1593 \latexignore{\rtfignore{\wxheading{Members
}}}
1596 \membersection{wxStringBufferLength::wxStringBufferLength
}\label{wxstringbufferlengthctor
}
1598 \func{}{wxStringBufferLength
}{\param{const wxString\&
}{str
},
\param{size
\_t }{len
}}
1600 Constructs a writable string buffer object associated with the given string
1601 and containing enough space for at least
{\it len
} characters. Basically, this
1602 is equivalent to calling
\helpref{GetWriteBuf
}{wxstringgetwritebuf
} and
1606 \membersection{wxStringBufferLength::
\destruct{wxStringBufferLength
}}\label{wxstringbufferlengthdtor
}
1608 \func{}{\destruct{wxStringBufferLength
}}{\void}
1610 Restores the string passed to the constructor to the usable state by calling
1611 \helpref{UngetWriteBuf
}{wxstringungetwritebuf
} on it.
1614 \membersection{wxStringBufferLength::SetLength
}\label{wxstringbufferlengthsetlength
}
1616 \func{void
}{SetLength
}{\param{size
\_t }{nLength
}}
1618 Sets the internal length of the string referred to by wxStringBufferLength to
1619 {\it nLength
} characters.
1621 Must be called before wxStringBufferLength destructs.
1624 \membersection{wxStringBufferLength::operator wxChar *
}\label{wxstringbufferlengthwxchar
}
1626 \func{wxChar *
}{operator wxChar *
}{\void}
1628 Returns the writable pointer to a buffer of the size at least equal to the
1629 length specified in the constructor.