8a540c887c
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@45249 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
1594 lines
52 KiB
TeX
1594 lines
52 KiB
TeX
\section{\class{wxString}}\label{wxstring}
|
|
|
|
wxString is a class representing a character string. Please see the
|
|
\helpref{wxString overview}{wxstringoverview} for more information about it.
|
|
|
|
As explained there, wxString implements most of the methods of the std::string
|
|
class.
|
|
These standard functions are not documented in this manual, please see the
|
|
\urlref{STL documentation}{http://www.cppreference.com/cppstl.html}).
|
|
The behaviour of all these functions is identical to the behaviour described
|
|
there.
|
|
|
|
You may notice that wxString sometimes has many functions which do the same
|
|
thing like, for example, \helpref{Length()}{wxstringlength},
|
|
\helpref{Len()}{wxstringlen} and {\tt length()} which all return the string
|
|
length. In all cases of such duplication the {\tt std::string}-compatible
|
|
method ({\tt length()} in this case, always the lowercase version) should be
|
|
used as it will ensure smoother transition to {\tt std::string} when wxWidgets
|
|
starts using it instead of wxString.
|
|
|
|
\wxheading{Derived from}
|
|
|
|
None
|
|
|
|
\wxheading{Include files}
|
|
|
|
<wx/string.h>
|
|
|
|
\wxheading{Predefined objects}
|
|
|
|
Objects:
|
|
|
|
{\bf wxEmptyString}
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxString overview}{wxstringoverview}, \helpref{Unicode overview}{unicode}
|
|
|
|
\latexignore{\rtfignore{\wxheading{Function groups}}}
|
|
|
|
|
|
\membersection{Constructors and assignment operators}\label{constructorsinwxstring}
|
|
|
|
A string may be constructed either from a C string, (some number of copies of)
|
|
a single character or a wide (UNICODE) string. For all constructors (except the
|
|
default which creates an empty string) there is also a corresponding assignment
|
|
operator.
|
|
|
|
\helpref{wxString}{wxstringconstruct}\\
|
|
\helpref{operator $=$}{wxstringoperatorassign}\\
|
|
\helpref{\destruct{wxString}}{wxstringdestruct}
|
|
|
|
|
|
\membersection{String length}\label{lengthfunctionsinwxstring}
|
|
|
|
These functions return the string length and check whether the string is empty
|
|
or empty it.
|
|
|
|
\helpref{Len}{wxstringlen}\\
|
|
\helpref{IsEmpty}{wxstringisempty}\\
|
|
\helpref{operator!}{wxstringoperatornot}\\
|
|
\helpref{Empty}{wxstringempty}\\
|
|
\helpref{Clear}{wxstringclear}
|
|
|
|
|
|
\membersection{Character access}\label{characteraccessinwxstring}
|
|
|
|
Many functions in this section take a character index in the string. As with C
|
|
strings and/or arrays, the indices start from $0$, so the first character of a
|
|
string is string[$0$]. Attempt to access a character beyond the end of the
|
|
string (which may be even $0$ if the string is empty) will provoke an assert
|
|
failure in \helpref{debug build}{debuggingoverview}, but no checks are done in
|
|
release builds.
|
|
|
|
This section also contains both implicit and explicit conversions to C style
|
|
strings. Although implicit conversion is quite convenient, it is advised to use
|
|
explicit \helpref{c\_str()}{wxstringcstr} method for the sake of clarity. Also
|
|
see \helpref{overview}{wxstringadvices} for the cases where it is necessary to
|
|
use it.
|
|
|
|
\helpref{GetChar}{wxstringgetchar}\\
|
|
\helpref{GetWritableChar}{wxstringgetwritablechar}\\
|
|
\helpref{SetChar}{wxstringsetchar}\\
|
|
\helpref{Last}{wxstringlast}\\
|
|
\helpref{operator []}{wxstringoperatorbracket}\\
|
|
\helpref{c\_str}{wxstringcstr}\\
|
|
\helpref{mb\_str}{wxstringmbstr}\\
|
|
\helpref{wc\_str}{wxstringwcstr}\\
|
|
\helpref{fn\_str}{wxstringfnstr}\\
|
|
\helpref{operator const char*}{wxstringoperatorconstcharpt}
|
|
|
|
|
|
\membersection{Concatenation}\label{concatenationinwxstring}
|
|
|
|
Anything may be concatenated (appended to) with a string. However, you can't
|
|
append something to a C string (including literal constants), so to do this it
|
|
should be converted to a wxString first.
|
|
|
|
\helpref{operator \cinsert}{wxstringoperatorout}\\
|
|
\helpref{operator $+=$}{wxstringplusequal}\\
|
|
\helpref{operator $+$}{wxstringoperatorplus}\\
|
|
\helpref{Append}{wxstringappend}\\
|
|
\helpref{Prepend}{wxstringprepend}
|
|
|
|
|
|
\membersection{Comparison}\label{comparisoninwxstring}
|
|
|
|
The default comparison function \helpref{Cmp}{wxstringcmp} is case-sensitive and
|
|
so is the default version of \helpref{IsSameAs}{wxstringissameas}. For case
|
|
insensitive comparisons you should use \helpref{CmpNoCase}{wxstringcmpnocase} or
|
|
give a second parameter to IsSameAs. This last function is may be more
|
|
convenient if only equality of the strings matters because it returns a boolean
|
|
\true value if the strings are the same and not 0 (which is usually false in C)
|
|
as {\tt Cmp()} does.
|
|
|
|
\helpref{Matches}{wxstringmatches} is a poor man's regular expression matcher:
|
|
it only understands '*' and '?' metacharacters in the sense of DOS command line
|
|
interpreter.
|
|
|
|
\helpref{StartsWith}{wxstringstartswith} is helpful when parsing a line of
|
|
text which should start with some predefined prefix and is more efficient than
|
|
doing direct string comparison as you would also have to precalculate the
|
|
length of the prefix then.
|
|
|
|
\helpref{Cmp}{wxstringcmp}\\
|
|
\helpref{CmpNoCase}{wxstringcmpnocase}\\
|
|
\helpref{IsSameAs}{wxstringissameas}\\
|
|
\helpref{Matches}{wxstringmatches}\\
|
|
\helpref{StartsWith}{wxstringstartswith}\\
|
|
\helpref{EndsWith}{wxstringendswith}
|
|
|
|
|
|
\membersection{Substring extraction}\label{substringextractioninwxstring}
|
|
|
|
These functions allow to extract substring from this string. All of them don't
|
|
modify the original string and return a new string containing the extracted
|
|
substring.
|
|
|
|
\helpref{Mid}{wxstringmid}\\
|
|
\helpref{operator()}{wxstringoperatorparenth}\\
|
|
\helpref{Left}{wxstringleft}\\
|
|
\helpref{Right}{wxstringright}\\
|
|
\helpref{BeforeFirst}{wxstringbeforefirst}\\
|
|
\helpref{BeforeLast}{wxstringbeforelast}\\
|
|
\helpref{AfterFirst}{wxstringafterfirst}\\
|
|
\helpref{AfterLast}{wxstringafterlast}\\
|
|
\helpref{StartsWith}{wxstringstartswith}\\
|
|
\helpref{EndsWith}{wxstringendswith}
|
|
|
|
|
|
|
|
\membersection{Case conversion}\label{caseconversioninwxstring}
|
|
|
|
The MakeXXX() variants modify the string in place, while the other functions
|
|
return a new string which contains the original text converted to the upper or
|
|
lower case and leave the original string unchanged.
|
|
|
|
\helpref{MakeUpper}{wxstringmakeupper}\\
|
|
\helpref{Upper}{wxstringupper}\\
|
|
\helpref{MakeLower}{wxstringmakelower}\\
|
|
\helpref{Lower}{wxstringlower}
|
|
|
|
|
|
\membersection{Searching and replacing}\label{searchingandreplacinginwxstring}
|
|
|
|
These functions replace the standard {\it strchr()} and {\it strstr()}
|
|
functions.
|
|
|
|
\helpref{Find}{wxstringfind}\\
|
|
\helpref{Replace}{wxstringreplace}
|
|
|
|
|
|
\membersection{Conversion to numbers}\label{conversiontonumbersinwxstring}
|
|
|
|
The string provides functions for conversion to signed and unsigned integer and
|
|
floating point numbers. All three functions take a pointer to the variable to
|
|
put the numeric value in and return \true if the {\bf entire} string could be
|
|
converted to a number.
|
|
|
|
\helpref{ToLong}{wxstringtolong}\\
|
|
\helpref{ToLongLong}{wxstringtolonglong}\\
|
|
\helpref{ToULong}{wxstringtoulong}\\
|
|
\helpref{ToULongLong}{wxstringtoulonglong}\\
|
|
\helpref{ToDouble}{wxstringtodouble}
|
|
|
|
|
|
\membersection{Writing values into the string}\label{writingintostringinwxstring}
|
|
|
|
Both formatted versions (\helpref{Printf}{wxstringprintf}) and stream-like
|
|
insertion operators exist (for basic types only). Additionally, the
|
|
\helpref{Format}{wxstringformat} function allows to use simply append
|
|
formatted value to a string:
|
|
|
|
\begin{verbatim}
|
|
// the following 2 snippets are equivalent
|
|
|
|
wxString s = "...";
|
|
s += wxString::Format("%d", n);
|
|
|
|
wxString s;
|
|
s.Printf("...%d", n);
|
|
\end{verbatim}
|
|
|
|
\helpref{Format}{wxstringformat}\\
|
|
\helpref{FormatV}{wxstringformatv}\\
|
|
\helpref{Printf}{wxstringprintf}\\
|
|
\helpref{PrintfV}{wxstringprintfv}\\
|
|
\helpref{operator \cinsert}{wxstringoperatorout}
|
|
|
|
|
|
\membersection{Memory management}\label{memoryinwxstring}
|
|
|
|
These are "advanced" functions and they will be needed quite rarely.
|
|
\helpref{Alloc}{wxstringalloc} and \helpref{Shrink}{wxstringshrink} are only
|
|
interesting for optimization purposes.
|
|
\helpref{wxStringBuffer}{wxstringbuffer}
|
|
and \helpref{wxStringBufferLength}{wxstringbufferlength} classes may be very
|
|
useful when working with some external API which requires the caller to provide
|
|
a writable buffer.
|
|
|
|
\helpref{Alloc}{wxstringalloc}\\
|
|
\helpref{Shrink}{wxstringshrink}\\
|
|
\helpref{wxStringBuffer}{wxstringbuffer}\\
|
|
\helpref{wxStringBufferLength}{wxstringbufferlength}
|
|
|
|
|
|
\membersection{Miscellaneous}\label{miscellaneousinwxstring}
|
|
|
|
Other string functions.
|
|
|
|
\helpref{Trim}{wxstringtrim}\\
|
|
\helpref{Truncate}{wxstringtruncate}\\
|
|
\helpref{Pad}{wxstringpad}
|
|
|
|
|
|
\membersection{wxWidgets 1.xx compatibility functions}\label{backwardcompatibilityinwxstring}
|
|
|
|
These functions are deprecated, please consider using new wxWidgets 2.0
|
|
functions instead of them (or, even better, std::string compatible variants).
|
|
|
|
% keep ordered alphabetically
|
|
\helpref{CompareTo}{wxstringcompareto}\\
|
|
\helpref{Contains}{wxstringcontains}\\
|
|
\helpref{First}{wxstringfirst}\\
|
|
\helpref{Freq}{wxstringfreq}\\
|
|
\helpref{Index}{wxstringindex}\\
|
|
\helpref{IsAscii}{wxstringisascii}\\
|
|
\helpref{IsNull}{wxstringisnull}\\
|
|
\helpref{IsNumber}{wxstringisnumber}\\
|
|
\helpref{IsWord}{wxstringisword}\\
|
|
\helpref{Last}{wxstringlast}\\
|
|
\helpref{Length}{wxstringlength}\\
|
|
\helpref{LowerCase}{wxstringlowercase}\\
|
|
\helpref{Remove}{wxstringremove}\\
|
|
\helpref{Strip}{wxstringstrip}\\
|
|
\helpref{SubString}{wxstringsubstring}\\
|
|
\helpref{UpperCase}{wxstringuppercase}
|
|
|
|
|
|
\membersection{std::string compatibility functions}\label{wxstringat}
|
|
|
|
The supported functions are only listed here, please see any STL reference for
|
|
their documentation.
|
|
|
|
\begin{verbatim}
|
|
// take nLen chars starting at nPos
|
|
wxString(const wxString& str, size_t nPos, size_t nLen);
|
|
// take all characters from pStart to pEnd (poor man's iterators)
|
|
wxString(const void *pStart, const void *pEnd);
|
|
|
|
// lib.string.capacity
|
|
// return the length of the string
|
|
size_t size() const;
|
|
// return the length of the string
|
|
size_t length() const;
|
|
// return the maximum size of the string
|
|
size_t max_size() const;
|
|
// resize the string, filling the space with c if c != 0
|
|
void resize(size_t nSize, char ch = '\0');
|
|
// delete the contents of the string
|
|
void clear();
|
|
// returns true if the string is empty
|
|
bool empty() const;
|
|
|
|
// lib.string.access
|
|
// return the character at position n
|
|
char at(size_t n) const;
|
|
// returns the writable character at position n
|
|
char& at(size_t n);
|
|
|
|
// lib.string.modifiers
|
|
// append a string
|
|
wxString& append(const wxString& str);
|
|
// append elements str[pos], ..., str[pos+n]
|
|
wxString& append(const wxString& str, size_t pos, size_t n);
|
|
// append first n (or all if n == npos) characters of sz
|
|
wxString& append(const char *sz, size_t n = npos);
|
|
|
|
// append n copies of ch
|
|
wxString& append(size_t n, char ch);
|
|
|
|
// same as `this_string = str'
|
|
wxString& assign(const wxString& str);
|
|
// same as ` = str[pos..pos + n]
|
|
wxString& assign(const wxString& str, size_t pos, size_t n);
|
|
// same as `= first n (or all if n == npos) characters of sz'
|
|
wxString& assign(const char *sz, size_t n = npos);
|
|
// same as `= n copies of ch'
|
|
wxString& assign(size_t n, char ch);
|
|
|
|
// insert another string
|
|
wxString& insert(size_t nPos, const wxString& str);
|
|
// insert n chars of str starting at nStart (in str)
|
|
wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n);
|
|
|
|
// insert first n (or all if n == npos) characters of sz
|
|
wxString& insert(size_t nPos, const char *sz, size_t n = npos);
|
|
// insert n copies of ch
|
|
wxString& insert(size_t nPos, size_t n, char ch);
|
|
|
|
// delete characters from nStart to nStart + nLen
|
|
wxString& erase(size_t nStart = 0, size_t nLen = npos);
|
|
|
|
// replaces the substring of length nLen starting at nStart
|
|
wxString& replace(size_t nStart, size_t nLen, const char* sz);
|
|
// replaces the substring with nCount copies of ch
|
|
wxString& replace(size_t nStart, size_t nLen, size_t nCount, char ch);
|
|
// replaces a substring with another substring
|
|
wxString& replace(size_t nStart, size_t nLen,
|
|
const wxString& str, size_t nStart2, size_t nLen2);
|
|
// replaces the substring with first nCount chars of sz
|
|
wxString& replace(size_t nStart, size_t nLen,
|
|
const char* sz, size_t nCount);
|
|
|
|
// swap two strings
|
|
void swap(wxString& str);
|
|
|
|
// All find() functions take the nStart argument which specifies the
|
|
// position to start the search on, the default value is 0. All functions
|
|
// return npos if there were no match.
|
|
|
|
// find a substring
|
|
size_t find(const wxString& str, size_t nStart = 0) const;
|
|
|
|
// find first n characters of sz
|
|
size_t find(const char* sz, size_t nStart = 0, size_t n = npos) const;
|
|
|
|
// find the first occurrence of character ch after nStart
|
|
size_t find(char ch, size_t nStart = 0) const;
|
|
|
|
// rfind() family is exactly like find() but works right to left
|
|
|
|
// as find, but from the end
|
|
size_t rfind(const wxString& str, size_t nStart = npos) const;
|
|
|
|
// as find, but from the end
|
|
size_t rfind(const char* sz, size_t nStart = npos,
|
|
size_t n = npos) const;
|
|
// as find, but from the end
|
|
size_t rfind(char ch, size_t nStart = npos) const;
|
|
|
|
// find first/last occurrence of any character in the set
|
|
|
|
//
|
|
size_t find_first_of(const wxString& str, size_t nStart = 0) const;
|
|
//
|
|
size_t find_first_of(const char* sz, size_t nStart = 0) const;
|
|
// same as find(char, size_t)
|
|
size_t find_first_of(char c, size_t nStart = 0) const;
|
|
//
|
|
size_t find_last_of (const wxString& str, size_t nStart = npos) const;
|
|
//
|
|
size_t find_last_of (const char* s, size_t nStart = npos) const;
|
|
// same as rfind(char, size_t)
|
|
size_t find_last_of (char c, size_t nStart = npos) const;
|
|
|
|
// find first/last occurrence of any character not in the set
|
|
|
|
//
|
|
size_t find_first_not_of(const wxString& str, size_t nStart = 0) const;
|
|
//
|
|
size_t find_first_not_of(const char* s, size_t nStart = 0) const;
|
|
//
|
|
size_t find_first_not_of(char ch, size_t nStart = 0) const;
|
|
//
|
|
size_t find_last_not_of(const wxString& str, size_t nStart=npos) const;
|
|
//
|
|
size_t find_last_not_of(const char* s, size_t nStart = npos) const;
|
|
//
|
|
size_t find_last_not_of(char ch, size_t nStart = npos) const;
|
|
|
|
// All compare functions return a negative, zero or positive value
|
|
// if the [sub]string is less, equal or greater than the compare() argument.
|
|
|
|
// just like strcmp()
|
|
int compare(const wxString& str) const;
|
|
// comparison with a substring
|
|
int compare(size_t nStart, size_t nLen, const wxString& str) const;
|
|
// comparison of 2 substrings
|
|
int compare(size_t nStart, size_t nLen,
|
|
const wxString& str, size_t nStart2, size_t nLen2) const;
|
|
// just like strcmp()
|
|
int compare(const char* sz) const;
|
|
// substring comparison with first nCount characters of sz
|
|
int compare(size_t nStart, size_t nLen,
|
|
const char* sz, size_t nCount = npos) const;
|
|
|
|
// substring extraction
|
|
wxString substr(size_t nStart = 0, size_t nLen = npos) const;
|
|
\end{verbatim}
|
|
|
|
%%%%% MEMBERS HERE %%%%%
|
|
\helponly{\insertatlevel{2}{
|
|
|
|
\wxheading{Members}
|
|
|
|
}}
|
|
|
|
|
|
\membersection{wxString::wxString}\label{wxstringconstruct}
|
|
|
|
\func{}{wxString}{\void}
|
|
|
|
Default constructor. Initializes the string to {\tt ""} (empty string).
|
|
|
|
\func{}{wxString}{\param{const wxString\&}{ x}}
|
|
|
|
Copy constructor.
|
|
|
|
\func{}{wxString}{\param{wxChar}{ ch}, \param{size\_t}{ n = 1}}
|
|
|
|
Constructs a string of {\it n} copies of character {\it ch}.
|
|
|
|
\func{}{wxString}{\param{const wxChar*}{ psz}, \param{size\_t}{ nLength = wxSTRING\_MAXLEN}}
|
|
|
|
Takes first {\it nLength} characters from the C string {\it psz}.
|
|
The default value of {\tt wxSTRING\_MAXLEN} means to take all the string.
|
|
|
|
Note that this constructor may be used even if {\it psz} points to a buffer
|
|
with binary data (i.e. containing {\tt NUL} characters) as long as you provide
|
|
the correct value for {\it nLength}. However, the default form of it works
|
|
only with strings without intermediate {\tt NUL}s because it uses
|
|
{\tt strlen()} to calculate the effective length and it would not give correct
|
|
results otherwise.
|
|
|
|
\func{}{wxString}{\param{const unsigned char*}{ psz}, \param{size\_t}{ nLength = wxSTRING\_MAXLEN}}
|
|
|
|
For compilers using unsigned char: takes first {\it nLength} characters from the C string {\it psz}.
|
|
The default value of {\tt wxSTRING\_MAXLEN} means take all the string.
|
|
For ANSI builds only (note the use of {\tt char} instead of {\tt wxChar}).
|
|
|
|
\wxheading{Constructors with conversion}
|
|
|
|
The following constructors allow you to construct wxString from a wide string
|
|
in ANSI build or from a C string in Unicode build.
|
|
|
|
\func{}{wxString}{\param{const wchar\_t*}{ psz}, \param{wxMBConv\&}{ conv}, \param{size\_t}{ nLength = wxSTRING\_MAXLEN}}
|
|
|
|
Initializes the string from first \arg{nLength} characters of wide string.
|
|
The default value of {\tt wxSTRING\_MAXLEN} means take all the string.
|
|
In ANSI build, \arg{conv}'s
|
|
\helpref{WC2MB}{wxmbconvwc2mb} method is called to
|
|
convert \arg{psz} to wide string. It is ignored in Unicode build.
|
|
|
|
\func{}{wxString}{\param{const char*}{ psz}, \param{wxMBConv\&}{ conv = wxConvLibc}, \param{size\_t}{ nLength = wxSTRING\_MAXLEN}}
|
|
|
|
Initializes the string from first \arg{nLength} characters of C string.
|
|
The default value of {\tt wxSTRING\_MAXLEN} means take all the string.
|
|
In Unicode build, \arg{conv}'s
|
|
\helpref{MB2WC}{wxmbconvmb2wc} method is called to
|
|
convert \arg{psz} to wide string (the default converter uses current locale's
|
|
charset). It is ignored in ANSI build.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxMBConv classes}{mbconvclasses}, \helpref{mb\_str}{wxstringmbstr},
|
|
\helpref{wc\_str}{wxstringwcstr}
|
|
|
|
|
|
\membersection{wxString::\destruct{wxString}}\label{wxstringdestruct}
|
|
|
|
\func{}{\destruct{wxString}}{\void}
|
|
|
|
String destructor. Note that this is not virtual, so wxString must not be inherited from.
|
|
|
|
|
|
\membersection{wxString::Alloc}\label{wxstringalloc}
|
|
|
|
\func{void}{Alloc}{\param{size\_t}{ nLen}}
|
|
|
|
Preallocate enough space for wxString to store {\it nLen} characters. This function
|
|
may be used to increase speed when the string is constructed by repeated
|
|
concatenation as in
|
|
|
|
\begin{verbatim}
|
|
|
|
// delete all vowels from the string
|
|
wxString DeleteAllVowels(const wxString& original)
|
|
{
|
|
wxString result;
|
|
|
|
size_t len = original.length();
|
|
|
|
result.Alloc(len);
|
|
|
|
for ( size_t n = 0; n < len; n++ )
|
|
{
|
|
if ( strchr("aeuio", tolower(original[n])) == NULL )
|
|
result += original[n];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
\end{verbatim}
|
|
|
|
because it will avoid the need to reallocate string memory many times (in case
|
|
of long strings). Note that it does not set the maximal length of a string - it
|
|
will still expand if more than {\it nLen} characters are stored in it. Also, it
|
|
does not truncate the existing string (use
|
|
\helpref{Truncate()}{wxstringtruncate} for this) even if its current length is
|
|
greater than {\it nLen}
|
|
|
|
|
|
\membersection{wxString::Append}\label{wxstringappend}
|
|
|
|
\func{wxString\&}{Append}{\param{const wxChar*}{ psz}}
|
|
|
|
Concatenates {\it psz} to this string, returning a reference to it.
|
|
|
|
\func{wxString\&}{Append}{\param{wxChar}{ ch}, \param{int}{ count = 1}}
|
|
|
|
Concatenates character {\it ch} to this string, {\it count} times, returning a reference
|
|
to it.
|
|
|
|
|
|
\membersection{wxString::AfterFirst}\label{wxstringafterfirst}
|
|
|
|
\constfunc{wxString}{AfterFirst}{\param{wxChar}{ ch}}
|
|
|
|
Gets all the characters after the first occurrence of {\it ch}.
|
|
Returns the empty string if {\it ch} is not found.
|
|
|
|
|
|
\membersection{wxString::AfterLast}\label{wxstringafterlast}
|
|
|
|
\constfunc{wxString}{AfterLast}{\param{wxChar}{ ch}}
|
|
|
|
Gets all the characters after the last occurrence of {\it ch}.
|
|
Returns the whole string if {\it ch} is not found.
|
|
|
|
|
|
\membersection{wxString::BeforeFirst}\label{wxstringbeforefirst}
|
|
|
|
\constfunc{wxString}{BeforeFirst}{\param{wxChar}{ ch}}
|
|
|
|
Gets all characters before the first occurrence of {\it ch}.
|
|
Returns the whole string if {\it ch} is not found.
|
|
|
|
|
|
\membersection{wxString::BeforeLast}\label{wxstringbeforelast}
|
|
|
|
\constfunc{wxString}{BeforeLast}{\param{wxChar}{ ch}}
|
|
|
|
Gets all characters before the last occurrence of {\it ch}.
|
|
Returns the empty string if {\it ch} is not found.
|
|
|
|
|
|
\membersection{wxString::c\_str}\label{wxstringcstr}
|
|
|
|
\constfunc{const wxChar *}{c\_str}{\void}
|
|
|
|
Returns a pointer to the string data ({\tt const char*} in ANSI build,
|
|
{\tt const wchar\_t*} in Unicode build).
|
|
|
|
Note that the returned value is not convertible to {\tt char*} or
|
|
{\tt wchar\_t*}, use \helpref{char\_str}{wxstringcharstr} or
|
|
\helpref{wchar\_string}{wxstringwcharstr} if you need to pass string value
|
|
to a function expecting non-const pointer.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{mb\_str}{wxstringmbstr}, \helpref{wc\_str}{wxstringwcstr},
|
|
\helpref{fn\_str}{wxstringfnstr}, \helpref{char\_str}{wxstringcharstr},
|
|
\helpref{wchar\_string}{wxstringwcharstr}
|
|
|
|
\membersection{wxString::char\_str}\label{wxstringcharstr}
|
|
|
|
\constfunc{wxWritableCharBuffer}{char\_str}{\void}
|
|
|
|
Returns an object with string data that is implicitly convertible to
|
|
{\tt char*} pointer. Note that any change to the returned buffer is lost and so
|
|
this function is only usable for passing strings to legacy libraries that
|
|
don't have const-correct API. Use \helpref{wxStringBuffer}{wxstringbuffer} if
|
|
you want to modify the string.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{mb\_str}{wxstringmbstr}, \helpref{wc\_str}{wxstringwcstr},
|
|
\helpref{fn\_str}{wxstringfnstr}, \helpref{c\_str}{wxstringcstr},
|
|
\helpref{wchar\_str}{wxstringwcharstr}
|
|
|
|
|
|
\membersection{wxString::Clear}\label{wxstringclear}
|
|
|
|
\func{void}{Clear}{\void}
|
|
|
|
Empties the string and frees memory occupied by it.
|
|
|
|
See also: \helpref{Empty}{wxstringempty}
|
|
|
|
|
|
\membersection{wxString::Cmp}\label{wxstringcmp}
|
|
|
|
\constfunc{int}{Cmp}{\param{const wxString\&}{ s}}
|
|
|
|
\constfunc{int}{Cmp}{\param{const wxChar*}{ psz}}
|
|
|
|
Case-sensitive comparison.
|
|
|
|
Returns a positive value if the string is greater than the argument, zero if
|
|
it is equal to it or a negative value if it is less than the argument (same semantics
|
|
as the standard {\it strcmp()} function).
|
|
|
|
See also \helpref{CmpNoCase}{wxstringcmpnocase}, \helpref{IsSameAs}{wxstringissameas}.
|
|
|
|
|
|
\membersection{wxString::CmpNoCase}\label{wxstringcmpnocase}
|
|
|
|
\constfunc{int}{CmpNoCase}{\param{const wxString\&}{ s}}
|
|
|
|
\constfunc{int}{CmpNoCase}{\param{const wxChar*}{ psz}}
|
|
|
|
Case-insensitive comparison.
|
|
|
|
Returns a positive value if the string is greater than the argument, zero if
|
|
it is equal to it or a negative value if it is less than the argument (same semantics
|
|
as the standard {\it strcmp()} function).
|
|
|
|
See also \helpref{Cmp}{wxstringcmp}, \helpref{IsSameAs}{wxstringissameas}.
|
|
|
|
|
|
\membersection{wxString::CompareTo}\label{wxstringcompareto}
|
|
|
|
\begin{verbatim}
|
|
enum wxString::caseCompare {exact, ignoreCase};
|
|
\end{verbatim}
|
|
|
|
\constfunc{int}{CompareTo}{\param{const wxChar*}{ psz}, \param{caseCompare}{ cmp = exact}}
|
|
|
|
Case-sensitive comparison. Returns 0 if equal, 1 if greater or -1 if less.
|
|
|
|
This is a wxWidgets 1.xx compatibility function; use \helpref{Cmp}{wxstringcmp} instead.
|
|
|
|
|
|
\membersection{wxString::Contains}\label{wxstringcontains}
|
|
|
|
\constfunc{bool}{Contains}{\param{const wxString\&}{ str}}
|
|
|
|
Returns \true if target appears anywhere in wxString; else \false.
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::Empty}\label{wxstringempty}
|
|
|
|
\func{void}{Empty}{\void}
|
|
|
|
Makes the string empty, but doesn't free memory occupied by the string.
|
|
|
|
See also: \helpref{Clear()}{wxstringclear}.
|
|
|
|
|
|
\membersection{wxString::Find}\label{wxstringfind}
|
|
|
|
\constfunc{int}{Find}{\param{wxUniChar}{ ch}, \param{bool}{ fromEnd = false}}
|
|
|
|
Searches for the given character. Returns the starting index, or {\tt wxNOT\_FOUND} if not found.
|
|
|
|
\constfunc{int}{Find}{\param{const wxString\&}{ sub}}
|
|
|
|
Searches for the given string. Returns the starting index, or {\tt wxNOT\_FOUND} if not found.
|
|
|
|
|
|
\membersection{wxString::First}\label{wxstringfirst}
|
|
|
|
\func{int}{First}{\param{wxChar}{ c}}
|
|
|
|
\constfunc{int}{First}{\param{const wxChar*}{ psz}}
|
|
|
|
\constfunc{int}{First}{\param{const wxString\&}{ str}}
|
|
|
|
Same as \helpref{Find}{wxstringfind}.
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::fn\_str}\label{wxstringfnstr}
|
|
|
|
\constfunc{const wchar\_t*}{fn\_str}{\void}
|
|
|
|
\constfunc{const char*}{fn\_str}{\void}
|
|
|
|
\constfunc{const wxCharBuffer}{fn\_str}{\void}
|
|
|
|
Returns string representation suitable for passing to OS' functions for
|
|
file handling. In ANSI build, this is same as \helpref{c\_str}{wxstringcstr}.
|
|
In Unicode build, returned value can be either wide character string
|
|
or C string in charset matching the {\tt wxConvFileName} object, depending on
|
|
the OS.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxMBConv}{wxmbconv},
|
|
\helpref{wc\_str}{wxstringwcstr}, \helpref{mb\_str}{wxstringwcstr}
|
|
|
|
|
|
\membersection{wxString::Format}\label{wxstringformat}
|
|
|
|
\func{static wxString}{Format}{\param{const wxChar }{*format}, \param{}{...}}
|
|
|
|
This static function returns the string containing the result of calling
|
|
\helpref{Printf}{wxstringprintf} with the passed parameters on it.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{FormatV}{wxstringformatv}, \helpref{Printf}{wxstringprintf}
|
|
|
|
|
|
\membersection{wxString::FormatV}\label{wxstringformatv}
|
|
|
|
\func{static wxString}{FormatV}{\param{const wxChar }{*format}, \param{va\_list }{argptr}}
|
|
|
|
This static function returns the string containing the result of calling
|
|
\helpref{PrintfV}{wxstringprintfv} with the passed parameters on it.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{Format}{wxstringformat}, \helpref{PrintfV}{wxstringprintfv}
|
|
|
|
|
|
\membersection{wxString::Freq}\label{wxstringfreq}
|
|
|
|
\constfunc{int}{Freq}{\param{wxChar }{ch}}
|
|
|
|
Returns the number of occurrences of {\it ch} in the string.
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::FromAscii}\label{wxstringfromascii}
|
|
|
|
\func{static wxString }{FromAscii}{\param{const char*}{ s}}
|
|
|
|
\func{static wxString }{FromAscii}{\param{const char}{ c}}
|
|
|
|
Converts the string or character from an ASCII, 7-bit form
|
|
to the native wxString representation. Most useful when using
|
|
a Unicode build of wxWidgets (note the use of {\tt char} instead of {\tt wxChar}).
|
|
Use \helpref{wxString constructors}{wxstringconstruct} if you
|
|
need to convert from another charset.
|
|
|
|
|
|
\membersection{wxString::GetChar}\label{wxstringgetchar}
|
|
|
|
\constfunc{wxChar}{GetChar}{\param{size\_t}{ n}}
|
|
|
|
Returns the character at position {\it n} (read-only).
|
|
|
|
|
|
\membersection{wxString::GetData}\label{wxstringgetdata}
|
|
|
|
\constfunc{const wxChar*}{GetData}{\void}
|
|
|
|
wxWidgets compatibility conversion. Returns a constant pointer to the data in the string.
|
|
|
|
|
|
\membersection{wxString::GetWritableChar}\label{wxstringgetwritablechar}
|
|
|
|
\func{wxChar\&}{GetWritableChar}{\param{size\_t}{ n}}
|
|
|
|
Returns a reference to the character at position {\it n}.
|
|
|
|
|
|
\membersection{wxString::GetWriteBuf}\label{wxstringgetwritebuf}
|
|
|
|
\func{wxChar*}{GetWriteBuf}{\param{size\_t}{ len}}
|
|
|
|
Returns a writable buffer of at least {\it len} bytes.
|
|
It returns a pointer to a new memory block, and the
|
|
existing data will not be copied.
|
|
|
|
Call \helpref{wxString::UngetWriteBuf}{wxstringungetwritebuf} as soon as
|
|
possible to put the string back into a reasonable state.
|
|
|
|
This method is deprecated, please use
|
|
\helpref{wxStringBuffer}{wxstringbuffer} or
|
|
\helpref{wxStringBufferLength}{wxstringbufferlength} instead.
|
|
|
|
|
|
\membersection{wxString::Index}\label{wxstringindex}
|
|
|
|
\constfunc{size\_t}{Index}{\param{wxChar}{ ch}}
|
|
|
|
\constfunc{size\_t}{Index}{\param{const wxChar*}{ sz}}
|
|
|
|
Same as \helpref{wxString::Find}{wxstringfind}.
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::IsAscii}\label{wxstringisascii}
|
|
|
|
\constfunc{bool}{IsAscii}{\void}
|
|
|
|
Returns \true if the string contains only ASCII characters.
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::IsEmpty}\label{wxstringisempty}
|
|
|
|
\constfunc{bool}{IsEmpty}{\void}
|
|
|
|
Returns \true if the string is empty.
|
|
|
|
|
|
\membersection{wxString::IsNull}\label{wxstringisnull}
|
|
|
|
\constfunc{bool}{IsNull}{\void}
|
|
|
|
Returns \true if the string is empty (same as \helpref{IsEmpty}{wxstringisempty}).
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::IsNumber}\label{wxstringisnumber}
|
|
|
|
\constfunc{bool}{IsNumber}{\void}
|
|
|
|
Returns \true if the string is an integer (with possible sign).
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::IsSameAs}\label{wxstringissameas}
|
|
|
|
\constfunc{bool}{IsSameAs}{\param{const wxChar*}{ psz}, \param{bool}{ caseSensitive = true}}
|
|
|
|
Test for string equality, case-sensitive (default) or not.
|
|
|
|
caseSensitive is \true by default (case matters).
|
|
|
|
Returns \true if strings are equal, \false otherwise.
|
|
|
|
See also \helpref{Cmp}{wxstringcmp}, \helpref{CmpNoCase}{wxstringcmpnocase}
|
|
|
|
\constfunc{bool}{IsSameAs}{\param{wxChar}{ c}, \param{bool}{ caseSensitive = true}}
|
|
|
|
Test whether the string is equal to the single character {\it c}. The test is
|
|
case-sensitive if {\it caseSensitive} is \true (default) or not if it is \false.
|
|
|
|
Returns \true if the string is equal to the character, \false otherwise.
|
|
|
|
See also \helpref{Cmp}{wxstringcmp}, \helpref{CmpNoCase}{wxstringcmpnocase}
|
|
|
|
|
|
\membersection{wxString::IsWord}\label{wxstringisword}
|
|
|
|
\constfunc{bool}{IsWord}{\void}
|
|
|
|
Returns \true if the string is a word.
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::Last}\label{wxstringlast}
|
|
|
|
\constfunc{wxChar}{Last}{\void}
|
|
|
|
Returns the last character.
|
|
|
|
\func{wxChar\&}{Last}{\void}
|
|
|
|
Returns a reference to the last character (writable).
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::Left}\label{wxstringleft}
|
|
|
|
\constfunc{wxString}{Left}{\param{size\_t}{ count}}
|
|
|
|
Returns the first {\it count} characters of the string.
|
|
|
|
|
|
\membersection{wxString::Len}\label{wxstringlen}
|
|
|
|
\constfunc{size\_t}{Len}{\void}
|
|
|
|
Returns the length of the string.
|
|
|
|
|
|
\membersection{wxString::Length}\label{wxstringlength}
|
|
|
|
\constfunc{size\_t}{Length}{\void}
|
|
|
|
Returns the length of the string (same as Len).
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::Lower}\label{wxstringlower}
|
|
|
|
\constfunc{wxString}{Lower}{\void}
|
|
|
|
Returns this string converted to the lower case.
|
|
|
|
|
|
\membersection{wxString::LowerCase}\label{wxstringlowercase}
|
|
|
|
\func{void}{LowerCase}{\void}
|
|
|
|
Same as MakeLower.
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::MakeLower}\label{wxstringmakelower}
|
|
|
|
\func{wxString\&}{MakeLower}{\void}
|
|
|
|
Converts all characters to lower case and returns the result.
|
|
|
|
|
|
\membersection{wxString::MakeUpper}\label{wxstringmakeupper}
|
|
|
|
\func{wxString\&}{MakeUpper}{\void}
|
|
|
|
Converts all characters to upper case and returns the result.
|
|
|
|
|
|
\membersection{wxString::Matches}\label{wxstringmatches}
|
|
|
|
\constfunc{bool}{Matches}{\param{const wxString\&}{ mask}}
|
|
|
|
Returns \true if the string contents matches a mask containing '*' and '?'.
|
|
|
|
|
|
\membersection{wxString::mb\_str}\label{wxstringmbstr}
|
|
|
|
\constfunc{const char*}{mb\_str}{\param{wxMBConv\&}{ conv = wxConvLibc}}
|
|
|
|
\constfunc{const wxCharBuffer}{mb\_str}{\param{wxMBConv\&}{ conv = wxConvLibc}}
|
|
|
|
Returns multibyte (C string) representation of the string.
|
|
In Unicode build, converts using \arg{conv}'s \helpref{cWC2MB}{wxmbconvcwc2mb}
|
|
method and returns wxCharBuffer. In ANSI build, this function is same
|
|
as \helpref{c\_str}{wxstringcstr}.
|
|
The macro wxWX2MBbuf is defined as the correct return type (without const).
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxMBConv}{wxmbconv},
|
|
\helpref{c\_str}{wxstringcstr}, \helpref{wc\_str}{wxstringwcstr},
|
|
\helpref{fn\_str}{wxstringfnstr}, \helpref{char\_str}{wxstringcharstr}
|
|
|
|
|
|
\membersection{wxString::Mid}\label{wxstringmid}
|
|
|
|
\constfunc{wxString}{Mid}{\param{size\_t}{ first}, \param{size\_t}{ count = wxSTRING\_MAXLEN}}
|
|
|
|
Returns a substring starting at {\it first}, with length {\it count}, or the rest of
|
|
the string if {\it count} is the default value.
|
|
|
|
|
|
\membersection{wxString::Pad}\label{wxstringpad}
|
|
|
|
\func{wxString\&}{Pad}{\param{size\_t}{ count}, \param{wxChar}{ pad = ' '}, \param{bool}{ fromRight = true}}
|
|
|
|
Adds {\it count} copies of {\it pad} to the beginning, or to the end of the string (the default).
|
|
|
|
Removes spaces from the left or from the right (default).
|
|
|
|
|
|
\membersection{wxString::Prepend}\label{wxstringprepend}
|
|
|
|
\func{wxString\&}{Prepend}{\param{const wxString\&}{ str}}
|
|
|
|
Prepends {\it str} to this string, returning a reference to this string.
|
|
|
|
|
|
\membersection{wxString::Printf}\label{wxstringprintf}
|
|
|
|
\func{int}{Printf}{\param{const wxChar* }{pszFormat}, \param{}{...}}
|
|
|
|
Similar to the standard function {\it sprintf()}. Returns the number of
|
|
characters written, or an integer less than zero on error.
|
|
|
|
Note that if {\tt wxUSE\_PRINTF\_POS\_PARAMS} is set to 1, then this function supports
|
|
Unix98-style positional parameters:
|
|
|
|
\begin{verbatim}
|
|
wxString str;
|
|
|
|
str.Printf(wxT("%d %d %d"), 1, 2, 3);
|
|
// str now contains "1 2 3"
|
|
|
|
str.Printf(wxT("%2$d %3$d %1$d"), 1, 2, 3);
|
|
// str now contains "2 3 1"
|
|
\end{verbatim}
|
|
|
|
{\bf NB:} This function will use a safe version of {\it vsprintf()} (usually called
|
|
{\it vsnprintf()}) whenever available to always allocate the buffer of correct
|
|
size. Unfortunately, this function is not available on all platforms and the
|
|
dangerous {\it vsprintf()} will be used then which may lead to buffer overflows.
|
|
|
|
|
|
\membersection{wxString::PrintfV}\label{wxstringprintfv}
|
|
|
|
\func{int}{PrintfV}{\param{const wxChar* }{pszFormat}, \param{va\_list}{ argPtr}}
|
|
|
|
Similar to vprintf. Returns the number of characters written, or an integer less than zero
|
|
on error.
|
|
|
|
|
|
\membersection{wxString::Remove}\label{wxstringremove}
|
|
|
|
\func{wxString\&}{Remove}{\param{size\_t}{ pos}}
|
|
|
|
Same as Truncate. Removes the portion from {\it pos} to the end of the string.
|
|
|
|
\func{wxString\&}{Remove}{\param{size\_t}{ pos}, \param{size\_t}{ len}}
|
|
|
|
Removes {\it len} characters from the string, starting at {\it pos}.
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::RemoveLast}\label{wxstringremovelast}
|
|
|
|
\func{wxString\&}{RemoveLast}{\void}
|
|
|
|
Removes the last character.
|
|
|
|
|
|
\membersection{wxString::Replace}\label{wxstringreplace}
|
|
|
|
\func{size\_t}{Replace}{\param{const wxString\&}{ strOld}, \param{const wxString\&}{ strNew}, \param{bool}{ replaceAll = true}}
|
|
|
|
Replace first (or all) occurrences of substring with another one.
|
|
|
|
{\it replaceAll}: global replace (default), or only the first occurrence.
|
|
|
|
Returns the number of replacements made.
|
|
|
|
|
|
\membersection{wxString::Right}\label{wxstringright}
|
|
|
|
\constfunc{wxString}{Right}{\param{size\_t}{ count}}
|
|
|
|
Returns the last {\it count} characters.
|
|
|
|
|
|
\membersection{wxString::SetChar}\label{wxstringsetchar}
|
|
|
|
\func{void}{SetChar}{\param{size\_t}{ n}, \param{wxChar}{ch}}
|
|
|
|
Sets the character at position {\it n}.
|
|
|
|
|
|
\membersection{wxString::Shrink}\label{wxstringshrink}
|
|
|
|
\func{void}{Shrink}{\void}
|
|
|
|
Minimizes the string's memory. This can be useful after a call to
|
|
\helpref{Alloc()}{wxstringalloc} if too much memory were preallocated.
|
|
|
|
|
|
\membersection{wxString::StartsWith}\label{wxstringstartswith}
|
|
|
|
\constfunc{bool}{StartsWith}{\param{const wxChar }{*prefix}, \param{wxString }{*rest = NULL}}
|
|
|
|
This function can be used to test if the string starts with the specified
|
|
{\it prefix}. If it does, the function will return \true and put the rest
|
|
of the string (i.e. after the prefix) into {\it rest} string if it is not
|
|
{\tt NULL}. Otherwise, the function returns \false and doesn't modify the
|
|
{\it rest}.
|
|
|
|
|
|
\membersection{wxString::EndsWith}\label{wxstringendswith}
|
|
|
|
\constfunc{bool}{EndsWith}{\param{const wxChar }{*suffix}, \param{wxString }{*rest = NULL}}
|
|
|
|
This function can be used to test if the string ends with the specified
|
|
{\it suffix}. If it does, the function will return \true and put the
|
|
beginning of the string before the suffix into {\it rest} string if it is not
|
|
{\tt NULL}. Otherwise, the function returns \false and doesn't
|
|
modify the {\it rest}.
|
|
|
|
|
|
\membersection{wxString::Strip}\label{wxstringstrip}
|
|
|
|
\begin{verbatim}
|
|
enum wxString::stripType {leading = 0x1, trailing = 0x2, both = 0x3};
|
|
\end{verbatim}
|
|
|
|
\constfunc{wxString}{Strip}{\param{stripType}{ s = trailing}}
|
|
|
|
Strip characters at the front and/or end. The same as Trim except that it
|
|
doesn't change this string.
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::SubString}\label{wxstringsubstring}
|
|
|
|
\constfunc{wxString}{SubString}{\param{size\_t}{ from}, \param{size\_t}{ to}}
|
|
|
|
Returns the part of the string between the indices {\it from} and {\it to}
|
|
inclusive.
|
|
|
|
This is a wxWidgets 1.xx compatibility function, use \helpref{Mid}{wxstringmid}
|
|
instead (but note that parameters have different meaning).
|
|
|
|
|
|
\membersection{wxString::ToAscii}\label{wxstringtoascii}
|
|
|
|
\constfunc{const char*}{ToAscii}{\void}
|
|
|
|
Converts the string to an ASCII, 7-bit string (ANSI builds only).
|
|
|
|
\constfunc{const wxCharBuffer}{ToAscii}{\void}
|
|
|
|
Converts the string to an ASCII, 7-bit string in the form of
|
|
a wxCharBuffer (Unicode builds only).
|
|
|
|
Note that this conversion only works if the string contains only ASCII
|
|
characters. The \helpref{mb\_str}{wxstringmbstr} method provides more
|
|
powerful means of converting wxString to C string.
|
|
|
|
|
|
\membersection{wxString::ToDouble}\label{wxstringtodouble}
|
|
|
|
\constfunc{bool}{ToDouble}{\param{double}{ *val}}
|
|
|
|
Attempts to convert the string to a floating point number. Returns \true on
|
|
success (the number is stored in the location pointed to by {\it val}) or \false
|
|
if the string does not represent such number.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxString::ToLong}{wxstringtolong},\\
|
|
\helpref{wxString::ToULong}{wxstringtoulong}
|
|
|
|
|
|
\membersection{wxString::ToLong}\label{wxstringtolong}
|
|
|
|
\constfunc{bool}{ToLong}{\param{long}{ *val}, \param{int }{base = $10$}}
|
|
|
|
Attempts to convert the string to a signed integer in base {\it base}. Returns
|
|
\true on success in which case the number is stored in the location
|
|
pointed to by {\it val} or \false if the string does not represent a
|
|
valid number in the given base.
|
|
|
|
The value of {\it base} must be comprised between $2$ and $36$, inclusive, or
|
|
be a special value $0$ which means that the usual rules of {\tt C} numbers are
|
|
applied: if the number starts with {\tt 0x} it is considered to be in base
|
|
$16$, if it starts with {\tt 0} - in base $8$ and in base $10$ otherwise. Note
|
|
that you may not want to specify the base $0$ if you are parsing the numbers
|
|
which may have leading zeroes as they can yield unexpected (to the user not
|
|
familiar with C) results.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxString::ToDouble}{wxstringtodouble},\\
|
|
\helpref{wxString::ToULong}{wxstringtoulong}
|
|
|
|
|
|
\membersection{wxString::ToLongLong}\label{wxstringtolonglong}
|
|
|
|
\constfunc{bool}{ToLongLong}{\param{wxLongLong\_t}{ *val}, \param{int }{base = $10$}}
|
|
|
|
This is exactly the same as \helpref{ToLong}{wxstringtolong} but works with 64
|
|
bit integer numbers.
|
|
|
|
Notice that currently it doesn't work (always returns \false) if parsing of 64
|
|
bit numbers is not supported by the underlying C run-time library. Compilers
|
|
with C99 support and Microsoft Visual C++ version 7 and higher do support this.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxString::ToLong}{wxstringtolong},\\
|
|
\helpref{wxString::ToULongLong}{wxstringtoulonglong}
|
|
|
|
|
|
\membersection{wxString::ToULong}\label{wxstringtoulong}
|
|
|
|
\constfunc{bool}{ToULong}{\param{unsigned long}{ *val}, \param{int }{base = $10$}}
|
|
|
|
Attempts to convert the string to an unsigned integer in base {\it base}.
|
|
Returns \true on success in which case the number is stored in the
|
|
location pointed to by {\it val} or \false if the string does not
|
|
represent a valid number in the given base. Please notice that this function
|
|
behaves in the same way as the standard \texttt{strtoul()} and so it simply
|
|
converts negative numbers to unsigned representation instead of rejecting them
|
|
(e.g. $-1$ is returned as \texttt{ULONG\_MAX}).
|
|
|
|
See \helpref{wxString::ToLong}{wxstringtolong} for the more detailed
|
|
description of the {\it base} parameter.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxString::ToDouble}{wxstringtodouble},\\
|
|
\helpref{wxString::ToLong}{wxstringtolong}
|
|
|
|
|
|
\membersection{wxString::ToULongLong}\label{wxstringtoulonglong}
|
|
|
|
\constfunc{bool}{ToULongLong}{\param{wxULongLong\_t}{ *val}, \param{int }{base = $10$}}
|
|
|
|
This is exactly the same as \helpref{ToULong}{wxstringtoulong} but works with 64
|
|
bit integer numbers.
|
|
|
|
Please see \helpref{ToLongLong}{wxstringtolonglong} for additional remarks.
|
|
|
|
|
|
\membersection{wxString::Trim}\label{wxstringtrim}
|
|
|
|
\func{wxString\&}{Trim}{\param{bool}{ fromRight = true}}
|
|
|
|
Removes white-space (space, tabs, form feed, newline and carriage return) from
|
|
the left or from the right end of the string (right is default).
|
|
|
|
|
|
\membersection{wxString::Truncate}\label{wxstringtruncate}
|
|
|
|
\func{wxString\&}{Truncate}{\param{size\_t}{ len}}
|
|
|
|
Truncate the string to the given length.
|
|
|
|
|
|
\membersection{wxString::UngetWriteBuf}\label{wxstringungetwritebuf}
|
|
|
|
\func{void}{UngetWriteBuf}{\void}
|
|
|
|
\func{void}{UngetWriteBuf}{\param{size\_t }{len}}
|
|
|
|
Puts the string back into a reasonable state (in which it can be used
|
|
normally), after
|
|
\rtfsp\helpref{wxString::GetWriteBuf}{wxstringgetwritebuf} was called.
|
|
|
|
The version of the function without the {\it len} parameter will calculate the
|
|
new string length itself assuming that the string is terminated by the first
|
|
{\tt NUL} character in it while the second one will use the specified length
|
|
and thus is the only version which should be used with the strings with
|
|
embedded {\tt NUL}s (it is also slightly more efficient as {\tt strlen()}
|
|
doesn't have to be called).
|
|
|
|
This method is deprecated, please use
|
|
\helpref{wxStringBuffer}{wxstringbuffer} or
|
|
\helpref{wxStringBufferLength}{wxstringbufferlength} instead.
|
|
|
|
|
|
\membersection{wxString::Upper}\label{wxstringupper}
|
|
|
|
\constfunc{wxString}{Upper}{\void}
|
|
|
|
Returns this string converted to upper case.
|
|
|
|
|
|
\membersection{wxString::UpperCase}\label{wxstringuppercase}
|
|
|
|
\func{void}{UpperCase}{\void}
|
|
|
|
The same as MakeUpper.
|
|
|
|
This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
|
|
|
|
|
|
\membersection{wxString::wc\_str}\label{wxstringwcstr}
|
|
|
|
\constfunc{const wchar\_t*}{wc\_str}{\param{wxMBConv\&}{ conv}}
|
|
|
|
\constfunc{const wxWCharBuffer}{wc\_str}{\param{wxMBConv\&}{ conv}}
|
|
|
|
Returns wide character representation of the string.
|
|
In ANSI build, converts using \arg{conv}'s \helpref{cMB2WC}{wxmbconvcmb2wc}
|
|
method and returns wxWCharBuffer. In Unicode build, this function is same
|
|
as \helpref{c\_str}{wxstringcstr}.
|
|
The macro wxWX2WCbuf is defined as the correct return type (without const).
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{wxMBConv}{wxmbconv},
|
|
\helpref{c\_str}{wxstringcstr}, \helpref{mb\_str}{wxstringwcstr},
|
|
\helpref{fn\_str}{wxstringfnstr}, \helpref{wchar\_str}{wxstringwcharstr}
|
|
|
|
\membersection{wxString::wchar\_str}\label{wxstringwcharstr}
|
|
|
|
\constfunc{wxWritableWCharBuffer}{wchar\_str}{\void}
|
|
|
|
Returns an object with string data that is implicitly convertible to
|
|
{\tt char*} pointer. Note that any change to the returned buffer is lost and so
|
|
this function is only usable for passing strings to legacy libraries that
|
|
don't have const-correct API. Use \helpref{wxStringBuffer}{wxstringbuffer} if
|
|
you want to modify the string.
|
|
|
|
\wxheading{See also}
|
|
|
|
\helpref{mb\_str}{wxstringmbstr}, \helpref{wc\_str}{wxstringwcstr},
|
|
\helpref{fn\_str}{wxstringfnstr}, \helpref{c\_str}{wxstringcstr},
|
|
\helpref{char\_str}{wxstringcharstr}
|
|
|
|
|
|
\membersection{wxString::operator!}\label{wxstringoperatornot}
|
|
|
|
\constfunc{bool}{operator!}{\void}
|
|
|
|
Empty string is \false, so !string will only return \true if the string is empty.
|
|
This allows the tests for NULLness of a {\it const wxChar *} pointer and emptiness
|
|
of the string to look the same in the code and makes it easier to port old code
|
|
to wxString.
|
|
|
|
See also \helpref{IsEmpty()}{wxstringisempty}.
|
|
|
|
|
|
\membersection{wxString::operator $=$}\label{wxstringoperatorassign}
|
|
|
|
\func{wxString\&}{operator $=$}{\param{const wxString\&}{ str}}
|
|
|
|
\func{wxString\&}{operator $=$}{\param{const wxChar*}{ psz}}
|
|
|
|
\func{wxString\&}{operator $=$}{\param{wxChar}{ c}}
|
|
|
|
Assignment: the effect of each operation is the same as for the corresponding
|
|
constructor (see \helpref{wxString constructors}{wxstringconstruct}).
|
|
|
|
|
|
\membersection{wxString::operator $+$}\label{wxstringoperatorplus}
|
|
|
|
Concatenation: all these operators return a new string equal to the
|
|
concatenation of the operands.
|
|
|
|
\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
|
|
|
|
\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ y}}
|
|
|
|
\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{wxChar}{ y}}
|
|
|
|
\func{wxString}{operator $+$}{\param{const wxChar*}{ x}, \param{const wxString\&}{ y}}
|
|
|
|
|
|
\membersection{wxString::operator $+=$}\label{wxstringplusequal}
|
|
|
|
\func{void}{operator $+=$}{\param{const wxString\&}{ str}}
|
|
|
|
\func{void}{operator $+=$}{\param{const wxChar*}{ psz}}
|
|
|
|
\func{void}{operator $+=$}{\param{wxChar}{ c}}
|
|
|
|
Concatenation in place: the argument is appended to the string.
|
|
|
|
|
|
\membersection{wxString::operator []}\label{wxstringoperatorbracket}
|
|
|
|
\func{wxChar\&}{operator []}{\param{size\_t}{ i}}
|
|
|
|
\constfunc{wxChar}{operator []}{\param{size\_t}{ i}}
|
|
|
|
\func{wxChar\&}{operator []}{\param{int}{ i}}
|
|
|
|
\constfunc{wxChar}{operator []}{\param{int}{ i}}
|
|
|
|
Element extraction.
|
|
|
|
|
|
\membersection{wxString::operator ()}\label{wxstringoperatorparenth}
|
|
|
|
\func{wxString}{operator ()}{\param{size\_t}{ start}, \param{size\_t}{ len}}
|
|
|
|
Same as Mid (substring extraction).
|
|
|
|
|
|
\membersection{wxString::operator \cinsert}\label{wxstringoperatorout}
|
|
|
|
\func{wxString\&}{operator \cinsert}{\param{const wxString\&}{ str}}
|
|
|
|
\func{wxString\&}{operator \cinsert}{\param{const wxChar*}{ psz}}
|
|
|
|
\func{wxString\&}{operator \cinsert}{\param{wxChar }{ch}}
|
|
|
|
Same as $+=$.
|
|
|
|
\func{wxString\&}{operator \cinsert}{\param{int}{ i}}
|
|
|
|
\func{wxString\&}{operator \cinsert}{\param{float}{ f}}
|
|
|
|
\func{wxString\&}{operator \cinsert}{\param{double}{ d}}
|
|
|
|
These functions work as C++ stream insertion operators: they insert the given
|
|
value into the string. Precision or format cannot be set using them, you can use
|
|
\helpref{Printf}{wxstringprintf} for this.
|
|
|
|
|
|
\membersection{wxString::operator \cextract}\label{wxstringoperatorin}
|
|
|
|
\func{friend istream\&}{operator \cextract}{\param{istream\&}{ is}, \param{wxString\&}{ str}}
|
|
|
|
Extraction from a stream.
|
|
|
|
|
|
\membersection{wxString::operator const wxChar*}\label{wxstringoperatorconstcharpt}
|
|
|
|
\constfunc{}{operator const wxChar*}{\void}
|
|
|
|
Implicit conversion to a C string.
|
|
|
|
|
|
\membersection{Comparison operators}\label{wxstringcomparison}
|
|
|
|
\func{bool}{operator $==$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
|
|
|
|
\func{bool}{operator $==$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
|
|
|
|
\func{bool}{operator $!=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
|
|
|
|
\func{bool}{operator $!=$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
|
|
|
|
\func{bool}{operator $>$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
|
|
|
|
\func{bool}{operator $>$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
|
|
|
|
\func{bool}{operator $>=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
|
|
|
|
\func{bool}{operator $>=$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
|
|
|
|
\func{bool}{operator $<$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
|
|
|
|
\func{bool}{operator $<$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
|
|
|
|
\func{bool}{operator $<=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
|
|
|
|
\func{bool}{operator $<=$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
|
|
|
|
\wxheading{Remarks}
|
|
|
|
These comparisons are case-sensitive.
|
|
|
|
|
|
\section{\class{wxStringBuffer}}\label{wxstringbuffer}
|
|
|
|
This tiny class allows to conveniently access the \helpref{wxString}{wxstring}
|
|
internal buffer as a writable pointer without any risk of forgetting to restore
|
|
the string to the usable state later.
|
|
|
|
For example, assuming you have a low-level OS function called
|
|
{\tt GetMeaningOfLifeAsString(char *)} returning the value in the provided
|
|
buffer (which must be writable, of course) you might call it like this:
|
|
|
|
\begin{verbatim}
|
|
wxString theAnswer;
|
|
GetMeaningOfLifeAsString(wxStringBuffer(theAnswer, 1024));
|
|
if ( theAnswer != "42" )
|
|
{
|
|
wxLogError("Something is very wrong!");
|
|
}
|
|
\end{verbatim}
|
|
|
|
Note that the exact usage of this depends on whether on not wxUSE\_STL is enabled. If
|
|
wxUSE\_STL is enabled, wxStringBuffer creates a separate empty character buffer, and
|
|
if wxUSE\_STL is disabled, it uses GetWriteBuf() from wxString, keeping the same buffer
|
|
wxString uses intact. In other words, relying on wxStringBuffer containing the old
|
|
wxString data is probably not a good idea if you want to build your program in both
|
|
with and without wxUSE\_STL.
|
|
|
|
\wxheading{Derived from}
|
|
|
|
None
|
|
|
|
\wxheading{Include files}
|
|
|
|
<wx/string.h>
|
|
|
|
\latexignore{\rtfignore{\wxheading{Members}}}
|
|
|
|
|
|
\membersection{wxStringBuffer::wxStringBuffer}\label{wxstringbufferctor}
|
|
|
|
\func{}{wxStringBuffer}{\param{const wxString\& }{str}, \param{size\_t }{len}}
|
|
|
|
Constructs a writable string buffer object associated with the given string
|
|
and containing enough space for at least {\it len} characters. Basically, this
|
|
is equivalent to calling \helpref{GetWriteBuf}{wxstringgetwritebuf} and
|
|
saving the result.
|
|
|
|
|
|
\membersection{wxStringBuffer::\destruct{wxStringBuffer}}\label{wxstringbufferdtor}
|
|
|
|
\func{}{\destruct{wxStringBuffer}}{\void}
|
|
|
|
Restores the string passed to the constructor to the usable state by calling
|
|
\helpref{UngetWriteBuf}{wxstringungetwritebuf} on it.
|
|
|
|
|
|
\membersection{wxStringBuffer::operator wxChar *}\label{wxstringbufferwxchar}
|
|
|
|
\func{wxChar *}{operator wxChar *}{\void}
|
|
|
|
Returns the writable pointer to a buffer of the size at least equal to the
|
|
length specified in the constructor.
|
|
|
|
|
|
|
|
\section{\class{wxStringBufferLength}}\label{wxstringbufferlength}
|
|
|
|
This tiny class allows to conveniently access the \helpref{wxString}{wxstring}
|
|
internal buffer as a writable pointer without any risk of forgetting to restore
|
|
the string to the usable state later, and allows the user to set the internal
|
|
length of the string.
|
|
|
|
For example, assuming you have a low-level OS function called
|
|
{\tt int GetMeaningOfLifeAsString(char *)} copying the value in the provided
|
|
buffer (which must be writable, of course), and returning the actual length
|
|
of the string, you might call it like this:
|
|
|
|
\begin{verbatim}
|
|
wxString theAnswer;
|
|
wxStringBuffer theAnswerBuffer(theAnswer, 1024);
|
|
int nLength = GetMeaningOfLifeAsString(theAnswerBuffer);
|
|
theAnswerBuffer.SetLength(nLength);
|
|
if ( theAnswer != "42" )
|
|
{
|
|
wxLogError("Something is very wrong!");
|
|
}
|
|
\end{verbatim}
|
|
|
|
Note that the exact usage of this depends on whether on not wxUSE\_STL is enabled. If
|
|
wxUSE\_STL is enabled, wxStringBuffer creates a separate empty character buffer, and
|
|
if wxUSE\_STL is disabled, it uses GetWriteBuf() from wxString, keeping the same buffer
|
|
wxString uses intact. In other words, relying on wxStringBuffer containing the old
|
|
wxString data is probably not a good idea if you want to build your program in both
|
|
with and without wxUSE\_STL.
|
|
|
|
Note that SetLength {\tt must} be called before wxStringBufferLength destructs.
|
|
|
|
\wxheading{Derived from}
|
|
|
|
None
|
|
|
|
\wxheading{Include files}
|
|
|
|
<wx/string.h>
|
|
|
|
\latexignore{\rtfignore{\wxheading{Members}}}
|
|
|
|
|
|
\membersection{wxStringBufferLength::wxStringBufferLength}\label{wxstringbufferlengthctor}
|
|
|
|
\func{}{wxStringBufferLength}{\param{const wxString\& }{str}, \param{size\_t }{len}}
|
|
|
|
Constructs a writable string buffer object associated with the given string
|
|
and containing enough space for at least {\it len} characters. Basically, this
|
|
is equivalent to calling \helpref{GetWriteBuf}{wxstringgetwritebuf} and
|
|
saving the result.
|
|
|
|
|
|
\membersection{wxStringBufferLength::\destruct{wxStringBufferLength}}\label{wxstringbufferlengthdtor}
|
|
|
|
\func{}{\destruct{wxStringBufferLength}}{\void}
|
|
|
|
Restores the string passed to the constructor to the usable state by calling
|
|
\helpref{UngetWriteBuf}{wxstringungetwritebuf} on it.
|
|
|
|
|
|
\membersection{wxStringBufferLength::SetLength}\label{wxstringbufferlengthsetlength}
|
|
|
|
\func{void}{SetLength}{\param{size\_t }{nLength}}
|
|
|
|
Sets the internal length of the string referred to by wxStringBufferLength to
|
|
{\it nLength} characters.
|
|
|
|
Must be called before wxStringBufferLength destructs.
|
|
|
|
|
|
\membersection{wxStringBufferLength::operator wxChar *}\label{wxstringbufferlengthwxchar}
|
|
|
|
\func{wxChar *}{operator wxChar *}{\void}
|
|
|
|
Returns the writable pointer to a buffer of the size at least equal to the
|
|
length specified in the constructor.
|
|
|
|
|