We're always interested in getting feedback. E-mail us if you like this guide, if you think that important material is omitted, if you encounter errors in the code examples or in the documentation, if you find any typos, or generally just if you feel like e-mailing. Send your email to Frank Brokken.Please state the document version you're referring to, as found in the title (in this document: 5.2.0a) and please state the paragraph you're referring to.
All mail received is seriously considered, and new (sub)releases of the Annotations will normally reflect your suggestions for improvements. Except for the incidental case I will not otherwise acknowledge the receipt of suggestions for improvements. Please don't misinterpret this for lack of appreciation.
C++ offers a large number of facilities to implement solutions for common problems. Most of these facilities are part of the Standard Template Library or they are implemented as generic algorithms (see chapter 17).
Among the facilities C++ programmers have developed over and over again
(as reflected in the Annotations) are those for manipulating chunks of text,
commonly called strings. The C programming language offers
rudimentary string support: the
ASCII-Z
terminated series of characters is the foundation on which a large amount of
code has been built (We define an
ASCII-Z string as a series of ASCII-characters terminated by the
ASCII-character zero (hence -Z), which has the value zero, and should not be
confused with character
'0'
, which usually has the value
0x30
).
Standard C++ now offers a
string
type of its own. In order to use
string
-type objects, the header file string
must be included in
sources.
Actually, string
objects are class type variables, and the class
is introduced for the first time in chapter 6. However, in order to
use a string, it is not necessary to know what a class is. In this section the
operators that are available for strings and some other operations are
discussed. The operations that can be performed on strings take the form
stringVariable.operation(argumentList)
For example, if string1
and string2
are variables of type string
,
then
string1.compare(string2)
compare()
, which is part of the string
-class is called a
member function. The string
class offers a large number of these
member functions, as well as extensions of some well-known operators, like the
assignment (=
) and the comparison operator (==
). These operators and
functions are discussed in the following sections.
string::npos
is returned. This value is a (symbolic) value
of type
string::size_type
, which is (for all practical purposes) an
int
.
Note that in all operations with strings
both string
objects
and char const *
values and variables can be used.
Some string
-member functions use iterators. Iterators will be
covered in section 17.2. The member functions that use iterators are
listed in the next section (4.2), they are not further
illustrated below.
The following operations can be performed on strings:
ASCII-Z
string, another
string
object, or an implicit initialization can be used. In the example,
note that the implicit initialization does not have an argument, and may not
use an argument list. Not even empty.
#include <string> using namespace std; int main() { string stringOne("Hello World"), // using plain ascii-Z stringTwo(stringOne), // using another string object stringThree; // implicit initialization to "". Do // not use the form `stringThree()' return 0; }
=
operator) can be
used, which accepts both a string
object and a C-style characterstring
as its right-hand argument:
#include <string> int main() { string stringOne("Hello World"), stringTwo; stringTwo = stringOne; // assign stringOne to stringTwo stringTwo = "Hello world"; // assign a C-string to StringTwo return 0; }
string
-object. The reverse conversion (converting a
string
object to a standard C-string) is not performed
automatically. In order to obtain the C
-string that is stored within the
string
object itself, the member function c_str()
, which returns a
char const *
, can be used:
#include <string> int main() { string stringOne("Hello World"); char const *Cstring = stringOne.c_str(); cout << Cstring << endl; return 0; }
[]
) is available, but there is no
string pointer dereferencing operator (*
). The subscript operator
does not perform range-checking.
String range
checkingis done by the
string::at()
member function:
#include <string> int main() { string stringOne("Hello World"); stringOne[6] = 'w'; // now "Hello world" if (stringOne[0] == 'H') stringOne[0] = 'h'; // now "hello world" // *stringOne = 'H'; // THIS WON'T COMPILE stringOne = "Hello World"; // Now using the at() // member function: stringOne.at(6) = stringOne.at(0); // now "Hello Horld" if (stringOne.at(0) == 'H') stringOne.at(0) = 'W'; // now "Wello Horld" return 0; }When an illegal index is passed to the
at()
member function, the
program aborts.
==, !=, <, <=, >
and >=
operators
or the
string::compare()
member function. The compare()
member
function comes in several flavors (see section 4.2.4 for
details), e.g.:
int string::compare(string const &other)
: this variant offers
a bit more information than the comparison-operators do. The return value of
the string::compare()
member function may be used for
lexicographical ordering: a negative value is returned if the string
stored in the string object using the compare()
member function (in the
example: stringOne
) is located earlier in the
ASCII collating sequence than the string stored in the string
object passed as argument.
#include <iostream> #include <string> using namespace std; int main() { string stringOne("Hello World"), stringTwo; if (stringOne != stringTwo) stringTwo = stringOne; if (stringOne == stringTwo) stringTwo = "Something else"; if (stringOne.compare(stringTwo) > 0) cout << "stringOne after stringTwo in the alphabet\n"; else if (stringOne.compare(stringTwo) < 0) cout << "stringOne before stringTwo in the alphabet\n"; else cout << "Both strings are the same\n"; // Alternatively: if (stringOne > stringTwo) cout << "stringOne after stringTwo in the alphabet\n"; else if (stringOne < stringTwo) cout << "stringOne before stringTwo in the alphabet\n"; else cout << "Both strings are the same\n"; return 0; }Note that there is no member function to perform a case insensitive comparison of strings.
int string::compare(string const &other, string::size_type pos,
unsigned n)
: the third argument indicates the number of characters that
should be compared. If its value exceeds the number of available characters,
only the available characters are compared.
string::compare()
are available. As stated,
refer to section 4.2.4 for details.
string
can be appended to
another string. For this the +=
operator can be used, as well as the
string &string::append()
member function.
Like the compare()
function, the append()
member function may have
extra arguments. The first argument is the string to be appended, the
second argument specifies the index position of the first character that will
be appended. The third argument specifies the number of characters that will
be appended. If the first argument is of type char const *
, only a second
argument may be specified. In that case, the second argument specifies the
number of characters of the first argument that are appended to the string
object. Furthermore, the +
operator can be used to append two strings
within an expression:
#include <iostream> #include <string> using namespace std; int main() { string stringOne("Hello"), stringTwo("World"); stringOne += " " + stringTwo; stringOne = "hello"; stringOne.append(" world"); // append 5 characters: stringOne.append(" ok. >This is not used<", 5); cout << stringOne << endl; string stringThree("Hello"); // append " World": stringThree.append(stringOne, 5, 6); cout << stringThree << endl; }The
+
operator can be used in cases where at least one term of the
+
operator is a string
object (the other term can be a string, char
const *
or char
).
When neither operand of the +
operator is a string
, at least one
operand must be converted to a string
object first. An easy way
to do this is to use an
anonymous string object:
string("hello") + " world";
string &string::insert()
member
function to insert (parts of) a string
has at least two, and at most four
arguments:
string
object
where another string should be inserted.
string
-argument that will be inserted.
char const *
, the fourth argument is
not available. In that case, the third argument indicates the number of
characters of the provided char const *
value that will be inserted.
#include <string> int main() { string stringOne("Hell ok."); // Insert "o " at position 4 stringOne.insert(4, "o "); string world("The World of C++"); // insert "World" into stringOne stringOne.insert(6, world, 4, 5); cout << "Guess what ? It is: " << stringOne << endl; }Several variants of
string::insert()
are available. See section
4.2 for details.
string
objects must be replaced by other information. To replace parts of
the contents of a string
object by another string the member function
string &string::
replace()
can be used.
The member function has at least three and possibly five arguments, having
the following meanings
(see section 4.2 for overloaded versions of
replace()
, using different types of arguments):
string
or char const *
).
string
-argument that will be inserted.
char const *
, the fifth argument is
not available. In that case, the fourth argument indicates the number of
characters of the provided char const *
value that will be inserted.
The following example shows a very simple filechanger: it reads lines from
cin
, and replaces occurrences of a `searchstring' by a
`replacestring'. Simple tests for the correct number of arguments and the
contents of the provided strings (they should be unequal) are implemented
using the
assert()
macro.
#include <string> #include <cassert> int main(int argc, char **argv) { assert(argc == 3 && "Usage: <searchstring> <replacestring> to process stdin"); string line, search(argv[1]), replace(argv[2]); assert(search != replace); while (getline(cin, line)) { while (true) { string::size_type idx; idx = line.find(search); if (idx == string::npos) break; line.replace(idx, search.size(), replace); } cout << line << endl; } return 0; }
string &string::swap(string &other)
swaps the contents
of two string
-objects. For example:
#include <string> int main() { string stringOne("Hello"), stringTwo("World"); cout << "Before: stringOne: " << stringOne << ", stringTwo: " << stringTwo << endl; stringOne.swap(stringTwo); cout << "After: stringOne: " << stringOne << ", stringTwo: " << stringTwo << endl; return 0; }
string
&string::erase()
removes characters from a string
. The standard form has
two optional arguments:
string()
or string("")
).
erase()
. An
example of the use of erase()
is given below:
#include <string> int main() { string stringOne("Hello Cruel World"); stringOne.erase(5, 6); cout << stringOne << endl; stringOne.erase(); cout << "'" << stringOne << "'\n"; return (0); }
string
the member function string::size_type
string::find()
can be
used. This function looks for the string that is provided as its first
argument in the string
object calling find()
and returns the index of
the first character of the substring if found. If the string is not found
string::npos
is returned. The member function rfind()
looks for the
substring from the end of the string
object back to its beginning. An
example using find()
was given earlier.
string
object,
the member function string string::substr()
is available. The returned
string
object contains a copy of the substring in the string
-object
calling substr()
The substr()
member function has two optional
arguments:
string
itself is returned.
#include <string> int main() { string stringOne("Hello World"); cout << stringOne.substr(0, 5) << endl << stringOne.substr(6) << endl << stringOne.substr() << endl; }
find()
is used to find a
substring, the functions find_first_of(), find_first_not_of(),
find_last_of()
and find_last_not_of()
can be used to find sets of
characters (Unfortunately, regular expressions are not supported here). The
following program reads a line of text from the standard input stream, and
displays the substrings starting at the first vowel, starting at the last
vowel, and not starting at the first digit:
#include <iostream> #include <string> int main() { string line; getline(cin, line); string::size_type pos; cout << "Line: " << line << endl << "Starting at the first vowel:\n" << "'" << ( (pos = line.find_first_of("aeiouAEIOU")) != string::npos ? line.substr(pos) : "*** not found ***" ) << "'\n" << "Starting at the last vowel:\n" << "'" << ( (pos = line.find_last_of("aeiouAEIOU")) != string::npos ? line.substr(pos) : "*** not found ***" ) << "'\n" << "Not starting at the first digit:\n" << "'" << ( (pos = line.find_first_not_of("1234567890")) != string::npos ? line.substr(pos) : "*** not found ***" ) << "'\n"; }
size()
member function, which, like
the standard C function
strlen()
does not include the terminating
ASCII-Z character. For example:
#include <string> int main() { string stringOne("Hello World"); cout << "The length of the stringOne string is " << stringOne.size() << " characters\n"; return 0; }
size()
member function
can be used to determine whether a string holds no characters. Alternatively,
the
string::empty()
member function can be used:
#include <string> int main() { string stringOne; cout << "The length of the stringOne string is " << stringOne.size() << " characters\n" "It is " << (stringOne.empty() ? "" : " not ") << "empty\n"; stringOne = ""; cout << "After assigning a \"\"-string to a string-object\n" "it is " << (stringOne.empty() ? "also" : " not") << " empty\n"; return 0; }
void
string::resize()
can be used to make it longer or shorter. Note that
operators like +=
automatically resize a string
when needed.
istream &getline(istream &instream, string &target, char delimiter)may be used to read a line of text (up to the first delimiter or the end of the stream) from
instream
.
The delimiter has a default value '\n'
. It is removed from instream
,
but it is not stored in target
. Istream::fail()
may be called to
determine whether the delimiter was found. If it returns true
the
delimiter was not found (see chapter 5 for details about
istream
objects). The function getline()
was used in several earlier
examples (e.g., with the replace() member function).
string
-initializers, the string
-iterators, the
string
-operators and the string
-member functions.
The member functions are ordered alphabetically by the name of the
operation. Below, object
is a string
-object, and argument
is
either a string
or a char const *
, unless overloaded versions tailored
to string
and char const *
parameters are explicitly
mentioned. Object
is used in cases where a string
object is
initialized or given a new value. Argument
remains unchanged.
With member functions the types of the parameters are given in a function-prototypical way. With several member functions iterators are used. At this point in the Annotations it's a bit premature to discuss iterators, but for referential purposes they have to be mentioned nevertheless. So, a forward reference is used here: see section 17.2 for a more detailed discussion of iterators.
Finally, note that all string
-member functions returning indices in
object
return the predefined constant
string::npos
if no
suitable index could be found.
string
constructors
are
available:
string object
:
Initializes object
to an empty string.
string object(string::size_type n, char c)
:
Initializesobject
withn
charactersc
.
string object(string argument)
:
Initializesobject
withargument
.
string object(string argument, string::size_type idx,
string::size_type n = pos)
:
Initializesobject
withargument
, usingn
characters ofargument
, starting at indexidx
.
string object(InputIterator begin, InputIterator end)
:
Initializesobject
with the range of characters implied by the providedInputIterators
.
object = argument
.
Assignment ofargument
toobject
. May also be used for initializingstring
objects.
object = c
.
Assignment ofchar c
toobject
. May not be used for initializingstring
objects.
object += argument
.
Appendsargument
toobject
.Argument
may also be achar
value.
argument1 + argument2
.
Within expressions,strings
may be added. At least one term of the expression (the left-hand term or the right-hand term) should be astring
object. The other term may be astring
, achar const *
value or achar
value, as illustrated by the following example:
void fun() { char const *asciiz = "hello"; string first = "first", second; // all expressions compile ok: second = first + asciiz; second = asciiz + first; second = first + 'a'; second = 'a' + first; }
object[string::size_type pos]
.
The subscript-operator may be used to assign individual characters ofobject
or to retrieve these characters. There is no range-checking. If range checking is required, use theat()
member function, summarized earlier.
argument1 == argument2
.
The equality operator (operator==()
) may be used to compare astring
object to anotherstring
orchar const *
value. Theoperator!=()
is available as well. The return value for both is abool
. For two identical stringsoperator==()
returnstrue
, andoperator!=()
returnsfalse
.
argument1 < argument2
.
The less-than operator may be used to compare the ordering within the Ascii-character set ofargument1
andargument2
. The operators<=, >
and>=
are available as well.
ostream stream; stream << argument
.
The insertion-operator may be used with string
objects.
istream stream; stream >> object
.
The extraction-operator may be used withstring
objects. It operates analogously to the extraction of characters into a character array, butobject
is automatically resized to the required number of characters.
string
-class is given first. Then the full prototype and a
description are given. Values of the type
string::size_type
represent
index positions within a string
. For all practical purposes, these values
may be interpreted as int
. The special value
string::npos
is defined
to represent a non-existing index.
In the following overview, `size_type
' should always be read as
`
string::size_type
'.
char &string::at(size_type pos)
:
The character (reference) at the indicated position is returned (it may be reassigned). The member function performs range-checking, aborting the program if an invalid index is passed.
string &string::append(InputIterator begin, InputIterator end)
:
Using this member function the range of characters implied by thebegin
andend InputIterators
are appended to thestring
object.
string &string::append(string argument, size_type pos, size_type
n)
:
argument
is given, it is appended to the
string
object.
pos
is specified as well, argument
is appended from
index position pos
until the end of argument
.
n
characters of
argument
, starting at index position pos
are appended to the
string
object.
argument
is of type char const *
, parameter pos
cannot be specified. So, with char const *
arguments, either all
characters or an initial subset of the characters of the provided char
const *
argument are appended to the string
object. Of course, if pos
and n
are specified in this case, append()
can still be used: an
implicit conversion from char const *
to string const &
will silently
take place for the first argument of apend()
.
string &string::append(size_type n, char c)
:
Using this member function,n
charactersc
can be appended to thestring
object.
string &string::assign(string argument, size_type pos, size_type n)
:
If
- If only
argument
is given, it is assigned to thestring
object.- If
pos
is specified as well, thestring
object is assigned from index positionpos
until the end ofargument
.- If all three arguments are provided,
n
characters ofargument
, starting at index positionpos
are assigned to thestring
object.argument
is of typechar const *
, no parameterpos
is available. So, withchar const *
arguments, either all characters or an initial subset of the characters of the providedchar const *
argument are assigned to thestring
object.
string &string::assign(size_type n, char c)
: Using this member function,n
charactersc
can be assigned to thestring
object.
size_type string::capacity()
:
returns the number of characters that can currently be
stored inside the string
object.
int string::compare(string argument)
:
This member function can be used to compare (according to the ASCII-character set) the text stored in thestring
object and inargument
. Theargument
may also be a (non-0)char const *
. 0 is returned if the characters in thestring
object and inargument
are the same; a negative value is returned if the text instring
is lexicographically before the text inargument
; a positive value is returned if the text instring
is lexicographically beyond the text inargument
.
int string::compare(size_type idx, size_type len, string
argument)
:
This member function can be used to compare a substring of the text stored in thestring
object with the text stored inargument
. At mostlen
characters, starting at offsetidx
, are compared with the text inargument
. Ifidx
is or exceeds the number of characters in thestring
object, anout_of_range
exception is thrown (see chapter 8). Theargument
may also be a (non-0)char const *
.
int string::compare(size_type idx, size_type len, string
argument, size_type arg_idx, size_type arg_len)
:
This member function can be used to compare a substring of the text stored in thestring
object with a substring of the text stored inargument
. At mostlen
characters of thestring
object, starting at offsetidx
, are compared with at mostarg_len
characters ofargument
, starting at offsetarg_idx
. Ifidx
orarg_idx
is or exceeds the number of characters in their respectivestring
objects, anout_of_range
exception is thrown. Note thatargument
must also be astring
object.
int string::compare(size_type idx, size_type len, char const
*argument, size_type arg_len)
:
This member function can be used to compare a substring of the text stored in thestring
object with a substring of the text stored inargument
. At mostlen
characters of thestring
object, starting at offsetidx
, are compared with at mostarg_len
characters ofargument
. Ifidx
is or exceeds the number of characters in the tt (string) object, anout_of_range
exception is thrown.Argument
must have at leastarg_len
characters. However, the characters may have arbitrary values: the ASCII-Z value has no special meaning.
size_type string::copy(char *argument, size_type n, size_type pos)
:
If the third argument is omitted, the firstn
characters of thestring
object are copied toargument
. If the third argument is given, copying starts from elementpos
of thestring
object. Following the copying, noASCII-Z
is appended to the copied string. Ifn
exceeds thestring
object'slength()
, at mostlength()
characters are copied. The actual number of characters that were copied is returned. By usingstring::npos
with thecopy()
member, all characters of thestring
object can be copied. A final ASCII-Z character can be appended to the copied text as follows:buffer[s.copy(buffer, string::npos)] = 0;
char const *string::c_str()
:
the member function returns the contents of thestring
object as anASCII-Z
C-string.
char const *string::data()
:
returns the raw text stored in the string
object.
bool string::empty()
:
returnstrue
if thestring
object contains no data.
string &string::erase(size_type pos; size_type n)
:
This member function can be used to erase (a sub)string of thestring
object. The basic form erases thestring
object completely. The working of other forms oferase()
depend on the specification of extra arguments:
- If
pos
is specified, the contents of thestring
object are erased from index positionpos
until the end of thestring
object.- If
pos
andn
are provided,n
characters of thestring
object, starting at index positionpos
are erased.
iterator string::erase(iterator p)
:
The contents of thestring
object are erased until (iterator) positionp
. The iteratorp
is returned.
iterator string::erase(iterator f, iterator l)
:
The range of characters of thestring
object, implied by theiterators f
andl
are erased. The iteratorf
is returned.
size_type string::find(string argument, size_type pos)
:
Returns the index in thestring
object whereargument
is found. Ifpos
is omitted, the search starts at the beginning of thestring
object. Ifpos
is provided, it refers to the index in thestring
object where the search forargument
should start.
size_type string::find(char const *argument, size_type pos, size_type n)
:
Returns the index in thestring
object whereargument
is found. The parametern
indicates the number of characters ofargument
that should be used in the search: it defines a partial string starting at the beginning ofargument
. If omitted, all characters inargument
are used. The parameterpos
refers to the index in thestring
object where the search forargument
should start. If the parameterpos
is omitted as well, thestring
object is scanned completely.
size_type string::find(char c, size_type pos)
:
Returns the index in thestring
object wherec
is found. If the argumentpos
is omitted, the search starts at the beginning of thestring
object. If provided, it refers to the index in thestring
object where the search for thestring
object should start.
size_type string::find_first_of(string argument, size_type pos)
:
Returns the index in thestring
object where any character inargument
is found. If the argumentpos
is omitted, the search starts at the beginning of thestring
object. If provided, it refers to the index in thestring
object where the search forargument
should start.
size_type string::find_first_of(char const* argument, size_type pos, size_type n)
:
Returns the index in thestring
object where a character ofargument
is found, no matter which character. The parametern
indicates the number of characters of thestring
object that should be used in the search: it defines a partial string starting at the beginning of thestring
object. If omitted, all characters in thestring
object are used. The parameterpos
refers to the index in thestring
object where the search forargument
should start. If the parameterpos
is omitted as well, thestring
object is scanned completely.
size_type string::find_first_of(char c, size_type pos)
:
Returns the index in thestring
object where characterc
is found. If the argumentpos
is omitted, the search starts at the beginning of thestring
object. If provided, it refers to the index in thestring
object where the search forc
should start.
size_type string::find_first_not_of(string argument, size_type pos)
:
Returns the index in thestring
object where a character not appearing inargument
is found. If the argumentpos
is omitted, the search starts at the beginning of thestring
object. If provided, it refers to the index in thestring
object where the search forargument
should start.
size_type string::find_first_not_of(char const *argument, size_type pos, size_type n)
:
Returns the index in thestring
object where any character not appearing inargument
is found. The parametern
indicates the number of characters of thestring
object that should be used in the search: it defines a partial string starting at the beginning of thestring
object. If omitted, all characters in thestring
object are used. The parameterpos
refers to the index in thestring
object where the search forargument
should start. If the parameterpos
is omitted as well, thestring
object is scanned completely.
size_type string::find_first_not_of(char c, size_type pos)
:
Returns the index in thestring
object where another character thanc
is found. If the argumentpos
is omitted, the search starts at the beginning of thestring
object. If provided, it refers to the index in thestring
object where the search forc
should start.
size_type string::find_last_of(string argument, size_type pos)
:
Returns the last index in thestring
object where a character inargument
is found. If the argumentpos
is omitted, the search starts at the beginning of thestring
object. If provided, it refers to the index in thestring
object where the search forargument
should start.
size_type string::find_last_of(char const* argument, size_type pos, size_type n)
:
Returns the last index in thestring
object where a character ofargument
is found. The parametern
indicates the number of characters of thestring
object that should be used in the search: it defines a partial string starting at the beginning of thestring
object. If omitted, all characters in thestring
object are used. The parameterpos
refers to the index in thestring
object where the search forargument
should start. If the parameterpos
is omitted as well, thestring
object is scanned completely.
size_type string::find_last_of(char c, size_type pos)
:
Returns the last index in thestring
object where characterc
is found. If the argumentpos
is omitted, the search starts at the beginning of thestring
object. If provided, it refers to the index in thestring
object where the search forc
should start.
size_type string::find_last_not_of(string argument, size_type pos)
:
Returns the last index in thestring
object where any character not appearing inargument
is found. If the argumentpos
is omitted, the search starts at the beginning of thestring
object. If provided, it refers to the index in thestring
object where the search forargument
should start.
size_type string::find_last_not_of(char const *argument, size_type pos, size_type n)
:
Returns the last index in thestring
object where any character not appearing inargument
is found. The parametern
indicates the number of characters of thestring
object that should be used in the search: it defines a partial string starting at the beginning of thestring
object. If omitted, all characters in thestring
object are used. The parameterpos
refers to the index in thestring
object where the search forargument
should start. If the parameterpos
is omitted as well, all of thestring
object is scanned.
size_type string::find_last_not_of(char c, size_type pos)
:
Returns the last index in thestring
object where another character thanc
is found. If the argumentpos
is omitted, the search starts at the beginning of thestring
object. If provided, it refers to the index in thestring
object where the search forc
should start.
istream &getline(istream instream, string object, char
delimiter)
:
This member function can be used to read a line of text (up to the first delimiter or the end of the stream) frominstream
. The delimiter has a default value'\n'
. It is removed frominstream
, but it is not stored in thestring
object.
string &string::insert(size_type t_pos, string argument, size_type pos; size_type n)
:
This member function can be used to insert (a sub)string ofargument
into thestring
object, at thestring
object's index positiont_pos
. The basic form insertsargument
completely at indext_pos
. The way other forms ofinsert()
work depend on the specification of extra arguments:If
- If
pos
is specified,argument
is inserted from index positionpos
until the end ofargument
.- If
pos
andn
are provided,n
characters ofargument
, starting at index positionpos
are inserted into thestring
object.argument
is of typechar const *
, no parameterpos
is available. So, withchar const *
arguments, either all characters or an initial subset of the characters of the providedchar const *
argument are inserted into thestring
object.
string &string::insert(size_type t_pos, size_type n, char c)
: Using this member function,n
charactersc
can be inserted to thestring
object.
iterator string::insert(iterator p, char c)
:
The characterc
is inserted at the (iterator) positionp
in thestring
object. The iteratorp
is returned.
iterator string::insert(iterator p, size_type n, char c)
:
N
charactersc
are inserted at the (iterator) positionp
in thestring
object. The iteratorp
is returned.
iterator string::insert(iterator p, InputIterator first,
InputIterator last)
:
The range of characters implied by theInputIterators first
andlast
are inserted at the (iterator) positionp
in thestring
object. The iteratorp
is returned.
size_type string::length()
:
returns the number of characters stored in the string
object.
size_type string::max_size()
:
returns the maximum number of characters that can be stored
in the string
object.
string& string::replace(size_type pos1, size_type n1, const string argument, size_type pos2, size_type n2)
:
The substring ofn1
characters of thestring
object, starting at positionpos1
is replaced byargument
. Ifn1
is set to 0, the member function insertsargument
into thestring
object.
The basic form usesargument
completely. The way other forms ofreplace()
work depends on the specification of extra arguments:If
- If
pos2
is specified,argument
is inserted from index positionpos2
until the end ofargument
.- If
pos2
andn2
are provided,n2
characters ofargument
, starting at index positionpos2
are inserted into thestring
object.argument
is of typechar const *
, no parameterpos2
is available. So, withchar const *
arguments, either all characters or an initial subset of the characters of the providedchar const *
argument are replaced in thestring
object.
string &string::replace(size_type pos, size_type n1, size_type n2, char c)
:
This member function can be used to replacen1
characters of thestring
object, starting at index positionpos
, byn2 c
-characters. The argumentn2
may be omitted, in which case the string to be replaced is replaced by just one characterc
.
string& string::replace (iterator i1, iterator i2, string
argument)
:
Here, the string implied by the iteratorsi1
andi2
are replaced by the stringstr
. Ifargument
is achar const *
, an extra argumentn
may be used, specifying the number of characters ofargument
that are used in the replacement.
iterator string::replace(iterator f, iterator l, string argument)
:
The range of characters of thestring
object, implied by theiterators f
andl
are replaced byargument
. Ifargument
is achar const *
, an extra argumentn
may be used, specifying the number of characters ofargument
that are used in the replacement. The string thestring
object is returned.
iterator string::replace(iterator f, iterator l, size_type
n, char c)
:
The range of characters of thestring
object, implied by theiterators f
andl
are replaced byn c
-characters. The iteratorf
is returned.
string string::replace(iterator i1, iterator i2, InputIterator j1,
InputIterator j2)
:
Here the range of characters implied by the iteratorsi1
andi2
is replaced by the range of characters implied by theInputIterators j1
andj2
.
void string::resize(size_type n, char c)
:
The string stored in thestring
object is resized ton
characters. The second argument is optional. If provided and the string is enlarged, the extra characters are initialized toc
.
size_type string::rfind(string argument, size_type pos)
:
Returns the index in thestring
object whereargument
is found. Searching proceeds either from the end of thestring
object or from offsetpos
back to the beginning. If the argumentpos
is omitted, searching starts at the end of thestring
object. Ifpos
is provided, it refers to the index in thestring
object where the search forargument
should start.
size_type string::rfind(char const *argument, size_type pos, size_type n)
:
Returns the index in thestring
object whereargument
is found. Searching proceeds either from the end of thestring
object or from offsetpos
back to the beginning. The parametern
indicates the number of characters ofargument
that should be used in the search: it defines a partial string starting at the beginning ofargument
. If omitted, all characters inargument
are used. If the argumentpos
is omitted as well, searching starts at the end of thestring
object. Ifpos
is provided, it refers to the index in thestring
object where the search for (a substring of)argument
should start.
size_type string::rfind(char c, size_type pos)
:
Returns the index in thestring
object wherec
is found. Searching proceeds either from the end of thestring
object or from offsetpos
back to the beginning.
size_type string::size()
:
returns the number of characters stored in the string
object.
string string::substr(size_type pos, size_type n)
:
Returns a substring of thestring
object. The parametern
may be used to specify the number of characters ofargument
that are returned. The parameterpos
may be used to specify the index of the first character ofargument
that is returned. Eithern
or both arguments may be omitted.
size_type string::swap(string argument)
:
swaps the contents of thestring
object andargument
. In this case,argument
must be astring
and cannot be achar const *
.