Chapter 4: The `string' data type

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: 4.4.2).

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 11).

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.

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 5. 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)

can be used to compare both strings. A function like 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.

4.1: Operations on strings

Some of the operations that can be performed on strings return indices within the strings. Whenever such an operation fails to find an appropriate index, the value 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 where string objects can be used as arguments, char const * values and variables can be used as well.

Some string-member functions use iterators. Iterators will be covered in section 11.1. 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:

String objects can be initialized. For the initialization a plain 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 does not use the function argumentlist notation.

    #include <string>
    
    int main()
    {
        string
            stringOne("Hello World"),   // using plain ascii-Z
            stringTwo(stringOne),       // using another string object
            stringThree;                // implicit initialization to ""
                                        // do not use: stringThree();    
        return (0);
    }

String objects can be assigned to each other. For this the assignment operator (i.e., the = 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);
    }

In the previous example a standard C-string (an ascii-Z string) was implicitly converted to a 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 <iostream>
    #include <string>
    
    int main()
    {
        string
            stringOne("Hello World");
        char const
            *Cstring = stringOne.c_str();

        cout << Cstring << endl;

        return (0);
    }
```

The individual elements of a string object can be reached for reading or writing. For this operation the subscript-operator ([]) is available, but not the pointer dereferencing operator (*). The subscript operator does not perform range-checking. If range-checking is required, the at() member function can be used instead of the subscript-operator:

    #include <string>
    
    int main()
    {
        string
            stringOne("Hello World");

        stringOne[6] = 'w';         // now "Hello world"
        if (stringOne[0] == 'H')
            stringOne[0] = 'h';     // now "hello world"

        // THIS WON'T COMPILE:
        //  *stringOne = 'H';        

        // Now using the at() memberfunction:

        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.

Two strings can be compared for (in)equality or ordering, using the ==, !=, <, <=, > and >= operators or the compare() member function can be used. The compare() member function comes in different flavors, the plain one (having another string object as argument) offers a bit more information than the operators do. The returnvalue of the 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 alphabet (based on the standard ascii-characterset) than the string stored in the string object passed as argument to the compare() member function.

    #include <iostream>
    #include <string>
    
    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";

        // 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";

        return (0);
    }

There is no member function to perform a case insensitive comparison of strings.

Overloaded forms of the compare() member function have one or two extra arguments.

If the compare() member function is used with two arguments, then the second argument is an index position in the current string-object. It indicates the index position in the current string object where the comparison should start.
If the compare() member function is used with three arguments, then the third argument indicates the number of characters that should be compared.

See the following example for further details about the compare() function.

    #include <iostream>
    #include <string>
    
    int main()
    {
        string
            stringOne("Hello World");

        // comparing from a certain offset in stringOne

        if (!stringOne.compare("ello World", 1))
            cout << "comparing 'Hello world' from index 1"
                    " to 'ello World': ok\n";

        // comparing from a certain offset in stringOne over a certain 
        // number of characters in "World and more"

        if (!stringOne.compare("World and more", 6, 5))
            cout << "comparing 'Hello World' from index 6 over 5 positions"
                    " to 'World and more': ok\n";

        // The same, but this fails, as all of the chars in stringOne 
        // starting at index 6 are compared, not just 3 chars.
        // number of characters in "World and more"

        if (!stringOne.compare("World and more", 6, 3))
            cout << "comparing 'Hello World' from index 6 over 3 positions"
                    " to 'World and more': ok\n";
        else
            cout << "Unequal (sub)strings\n";


        return (0);
    }

A string can be appended to another string. For this the += operator can be used, as well as the append() member function. Like the compare() function, the append() member function may have two 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>
    
    int main()
    {
        string
            stringOne("Hello"),
            stringTwo("World");

        stringOne += " " + stringTwo;
        
        stringOne = "hello";
        stringOne.append(" world");

        // append only 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;

        return (0);
    }
```
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";
So, the append() member function is used to append characters at the end of a string. It is also possible to insert characters somewhere within a string. For this the member function insert() is available.
The insert() member function to insert (parts of) a string has at least two, and at most four arguments:
- The first argument is the offset in the current string object where another string should be inserted.
- The second argument is the string to be inserted.
- The third argument specifies the index position of the first character in the provided string-argument that will be inserted.
- The fourth argument specifies the number of characters that will be inserted.
If the first argument is of type 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 <iostream>
    #include <string>
    
    int main()
    {
        string
            stringOne("Hell ok.");

        stringOne.insert(4, "o ");   // Insert "o " at position 4

        string
            world("The World of C++");

                                    // insert "World" into stringOne
        stringOne.insert(6, world, 4, 5);   

        cout << "Guess what ? It is: " << stringOne << endl;

        return (0);
    }
```
Several other variants of insert() are available. See section 4.2 for details.
At times, the contents of string objects must be replaced by other information. To replace parts of the contents of a string object by another string the member function 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):
- The first argument indicates the position of the first character that must be replaced
- The second argument gives the number of characters that must be replaced.
- The third argument defines the replacement text (a string or char const *).
- The fourth argument specifies the index position of the first character in the provided string-argument that will be inserted.
- The fifth argument can be used to specify the number of characters that will be inserted.
If the third argument is of type 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 <iostream>
    #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);
    }
```

A particular form of replacement is swapping: the member function swap() swaps the contents of two string-objects. For example:

    #include <iostream>
    #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);
    }

Another form of replacement is to remove characters from the string. For this the member function erase() is available. The standard form has two optional arguments:
- If no arguments are specified, the stored string is erased completely: it becomes the empty string (string() or string("")).
- The first argument may be used to specify the offset of the first character that must be erased.
- The second argument may be used to specify the number of characters that are to be erased.
See section 4.2 for overloaded versions of 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);
    }
```
To find substrings in a string the member function 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.
To extract a substring from a string object, the member function substr() is available. The returned string object contains a copy of the substring in the string-object calling substr() The member function has two optional arguments:
- Without arguments, a copy of the string itself is returned.
- The first argument may be used to specify the offset of the first character to be returned.
- The second argument may be used to specify the number of characters that are to be returned.
For example:
```
    #include <string>
    
    int main()
    {
        string
            stringOne("Hello World");

        cout << stringOne.substr(0, 5)  << endl
             << stringOne.substr(6)     << endl
             << stringOne.substr()      << endl;

        return (0);
    }
```

Whereas 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 <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";
        return (0);
    }

The number of characters that are stored in a string are obtained by the size() member function, which, like the standard C function strlen() does not include the terminating ascii-Z character. For example:

    #include <iostream>
    #include <string>
    
    int main()
    {
        string
            stringOne("Hello World");

        cout << "The length of the stringOne string is " 
            << stringOne.size() << " characters\n";

        return (0);
    }

If the size of a string is not enough (or if it is too large), the member function resize() can be used to make it longer or shorter. Note that operators like + automatically resize the string when needed.

The size() member function can be used to determine whether a string holds no characters as well. Alternatively, the empty() member function can be used:

    #include <iostream>
    #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);
    }

The istream &getline(istream instream, string target, char delimiter) member function 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. The function getline() was used in several earlier examples (e.g., with the replace() member function).

4.2: Overview of operations on strings

In this section the available operations on strings are summarized. There are four subparts here: the 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 11.1 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.

4.2.1: The string-initializers

string object:
Initializes object to an empty string.
string object(string::size_type n, char c):
Initializes object with n characters c.
string object(string argument):
Initializes object with argument.
string object(string argument, string::size_type idx, string::size_type n = pos):
Initializes object with argument, using n characters of argument, starting at index idx.
string object(InputIterator begin, InputIterator end):
Initializes object with the range of characters implied by the provided InputIterators.

4.2.2: The `string`-iterators

See section 11.1 for details about iterators.

Forward iterators:
- begin()
- end()
Reverse iterators:
- rbegin()
- rend()

4.2.3: The `string`-operators

object = argument.
Assignment of argument to object. May also be used for initializing string objects.
object = c.
Assignment of char c to object. May not be used for initializing string objects.
object += argument.
Appends argument to object. Argument may also be a char 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 a string object. The other term may be a string, a char const * value or a char 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 of object or to retrieve these characters. There is no range-checking. If range checking is required, use the at() member function, summarized earlier.
argument1 == argument2.
The equality operator may be used to compare a string object to another string or char const * value. The operator != is available as well. The returnvalue is a bool, which is true if the two strings are equal (i.e., contain the same characters). != returns false in that case.
argument1 < argument2.
The less-than operator may be used to compare the ordering within the Ascii-character set of argument1 and argument2. 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 with string objects. It operates analogously to the extraction of characters into a character array, but object is automatically resized to the required number of characters.

4.2.4: The string member functions

char &object.at(string::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 &object.append(InputIterator begin, InputIterator end):
Using this member function the range of characters implied by the begin and end InputIterators are appended to object.
string &object.append(string argument, string::size_type pos = 0; string::size_type n = string::npos):
- If only argument is given, it is appended to object.
- If pos is specified as well, argument is appended from index position pos until the end of argument.
- If all three arguments are provided, n characters of argument, starting at index position pos are appended to object.
If argument is of type char const *, parameter pos is not available. So, with char const * arguments, either all characters or an initial subset of the characters of the provided char const * argument are appended to object.
- string &object.append(string::size_type n, char c): Using this member function, n characters c can be appended to object.
string &object.assign(string argument, string::size_type pos = 0; string::size_type n = string::npos):
- If only argument is given, it is assigned to object.
- If pos is specified as well, object is assigned from index position pos until the end of argument.
- If all three arguments are provided, n characters of argument, starting at index position pos are assigned to object.
If argument is of type char const *, no parameter pos is available. So, with char const * arguments, either all characters or an initial subset of the characters of the provided char const * argument are assigned to object.
- string &object.assign(string::size_type n, char c): Using this member function, n characters c can be assigned to object.
string::size_type object.capacity():
returns the number of characters that can currently be stored inside object.
int object.compare(string argument, string::size_type pos, string::size_type n):
This member function may be used to compare (according to the ascii-character set) the strings stored in object and argument. The parameter n may be used to specify the number of characters in argument that are used in the comparison, the parameter pos may be used to specify the initial character in object that is used in the comparison.
string::size_type object.copy(char const *argument, string::size_type n, string::size_type pos):
If the third argument is omitted, the first n characters of object are copied to argument. If the thirst argument is given, copying starts from &object[pos]. Following the copying, no ascii-Z is appended to the copied string. If n exceeds object.length(), at most object.length() characters are copied. The actual number of characters that were copied is returned.
char const *object.c_str:
the member function returns the contents of object as an ascii-Z C-string.
char const *object.data():
returns the raw text stored in object.
bool object.empty():
returns true if object contains no data.
string &object.erase(string::size_type pos; string::size_type n):
This member function can be used to erase (a sub)string of object. The basic form erases object completely. The working of other forms of erase() depend on the specification of extra arguments:
- If pos is specified, the contents of object are erased from index position pos until the end of object.
- If pos and n are provided, n characters of object, starting at index position pos are erased.
iterator object.erase(iterator p):
The contents of object are erased until (iterator) position p. The iterator p is returned.
iterator object.erase(iterator f, iterator l):
The range of characters of object, implied by the iterators f and l are erased. The iterator f is returned.
string::string::size_type object.find(string argument, string::size_type pos):
Returns the index in object where argument is found. If pos is omitted, the search starts at the beginning of object. If pos is provided, it refers to the index in object where the search for argument should start.
string::size_type object.find(char const *argument, string::size_type pos, string::size_type n):
Returns the index in object where argument is found. The parameter n indicates the number of characters of argument that should be used in the search: it defines a partial string starting at the beginning of argument. If omitted, all characters in argument are used. The parameter pos refers to the index in object where the search for argument should start. If the parameter pos is omitted as well, object is scanned completely.
string::size_type object.find(char c, string::size_type pos):
Returns the index in object where c is found. If the argument pos is omitted, the search starts at the beginning of object. If provided, it refers to the index in object where the search for object should start.
string::size_type object.find_first_of(string argument, string::size_type pos):
Returns the index in object where any character in argument is found. If the argument pos is omitted, the search starts at the beginning of object. If provided, it refers to the index in object where the search for argument should start.
string::size_type object.find_first_of(char const* argument, string::size_type pos, string::size_type n):
Returns the index in object where a character of argument is found, no matter which character. The parameter n indicates the number of characters of object that should be used in the search: it defines a partial string starting at the beginning of object. If omitted, all characters in object are used. The parameter pos refers to the index in object where the search for argument should start. If the parameter pos is omitted as well, object is scanned completely.
string::size_type object.find_first_of(char c, string::size_type pos):
Returns the index in object where character c is found. If the argument pos is omitted, the search starts at the beginning of object. If provided, it refers to the index in object where the search for c should start.
string::size_type object.find_first_not_of(string argument, string::size_type pos):
Returns the index in object where a character not appearing in argument is found. If the argument pos is omitted, the search starts at the beginning of object. If provided, it refers to the index in object where the search for argument should start.
string::size_type object.find_first_not_of(char const* argument, string::size_type pos, string::size_type n):
Returns the index in object where any character not appearing in argument is found. The parameter n indicates the number of characters of object that should be used in the search: it defines a partial string starting at the beginning of object. If omitted, all characters in object are used. The parameter pos refers to the index in object where the search for argument should start. If the parameter pos is omitted as well, object is scanned completely.
string::size_type object.find_first_not_of(char c, string::size_type pos):
Returns the index in object where another character than c is found. If the argument pos is omitted, the search starts at the beginning of object. If provided, it refers to the index in object where the search for c should start.
string::size_type object.find_last_of(string argument, string::size_type pos):
Returns the last index in object where a character in argument is found. If the argument pos is omitted, the search starts at the beginning of object. If provided, it refers to the index in object where the search for argument should start.
string::size_type object.find_last_of(char const* argument, string::size_type pos, string::size_type n):
Returns the last index in object where a character of argument is found. The parameter n indicates the number of characters of object that should be used in the search: it defines a partial string starting at the beginning of object. If omitted, all characters in object are used. The parameter pos refers to the index in object where the search for argument should start. If the parameter pos is omitted as well, object is scanned completely.
string::size_type object.find_last_of(char c, string::size_type pos):
Returns the last index in object where character c is found. If the argument pos is omitted, the search starts at the beginning of object. If provided, it refers to the index in object where the search for c should start.
string::size_type object.find_last_not_of(string argument, string::size_type pos):
Returns the last index in object where any character not appearing in argument is found. If the argument pos is omitted, the search starts at the beginning of object. If provided, it refers to the index in object where the search for argument should start.
string::size_type object.find_last_not_of(char const* argument, string::size_type pos, string::size_type n):
Returns the last index in object where any character not appearing in argument is found. The parameter n indicates the number of characters of object that should be used in the search: it defines a partial string starting at the beginning of object. If omitted, all characters in object are used. The parameter pos refers to the index in object where the search for argument should start. If the parameter pos is omitted as well, all of object is scanned.
string::size_type object.find_last_not_of(char c, string::size_type pos):
Returns the last index in object where another character than c is found. If the argument pos is omitted, the search starts at the beginning of object. If provided, it refers to the index in object where the search for c 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) from instream. The delimiter has a default value '\n'. It is removed from instream, but it is not stored in object.
string &object.insert(string::size_type t_pos, string argument, string::size_type pos; string::size_type n):
This member function can be used to insert (a sub)string of argument into object, at object's index position t_pos. The basic form inserts argument completely at index t_pos. The way other forms of insert() work depend on the specification of extra arguments:
- If pos is specified, argument is inserted from index position pos until the end of argument.
- If pos and n are provided, n characters of argument, starting at index position pos are inserted into object.
If argument is of type char const *, no parameter pos is available. So, with char const * arguments, either all characters or an initial subset of the characters of the provided char const * argument are inserted into object.
- string &object.insert(string::size_type t_pos, string::size_type n, char c): Using this member function, n characters c can be inserted to object.
iterator object.insert(iterator p, char c):
The character c is inserted at the (iterator) position p in object. The iterator p is returned.
iterator object.insert(iterator p, string::size_type n, char c):
N characters c are inserted at the (iterator) position p in object. The iterator p is returned.
iterator object.insert(iterator p, InputIterator first, InputIterator last):
The range of characters implied by the InputIterators first and last are inserted at the (iterator) position p in object. The iterator p is returned.
string::size_type object.length():
returns the number of characters stored in object.
string::size_type object.max_size():
returns the maximum number of characters that can be stored in object.
string& object.replace(string::size_type pos1, string::size_type n1, const string argument, string::size_type pos2, string::size_type n2):
The substring of n1 characters of object, starting at position pos1 is replaced by argument. If n1 is set to 0, the member function inserts argument into object.
The basic form uses argument completely. The way other forms of replace() work depends on the specification of extra arguments:
- If pos2 is specified, argument is inserted from index position pos2 until the end of argument.
- If pos2 and n2 are provided, n2 characters of argument, starting at index position pos2 are inserted into object.
If argument is of type char const *, no parameter pos2 is available. So, with char const * arguments, either all characters or an initial subset of the characters of the provided char const * argument are replaced in object.
string &object.replace(string::size_type pos, string::size_type n1, string::size_type n2, char c):
This member function can be used to replace n1 characters of object, starting at index position pos, by n2 c-characters. The argument n2 may be omitted, in which case the string to be replaced is replaced by just one character c.
string& object.replace (iterator i1, iterator i2, string argument):
Here, the string implied by the iterators i1 and i2 are replaced by the string str. If argument is a char const *, an extra argument n may be used, specifying the number of characters of argument that are used in the replacement.
iterator object.replace(iterator f, iterator l, string argument):
The range of characters of object, implied by the iterators f and l are replaced by argument. If argument is a char const *, an extra argument n may be used, specifying the number of characters of argument that are used in the replacement. The string object is returned.
iterator object.replace(iterator f, iterator l, string::size_type n, char c):
The range of characters of object, implied by the iterators f and l are replaced by n c-characters. The iterator f is returned.
string object.replace(iterator i1, iterator i2, InputIterator j1, InputIterator j2):
Here the range of characters implied by the iterators i1 and i2 is replaced by the range of characters implied by the InputIterators j1 and j2.
void object.resize(string::size_type n, char c):
The string stored in object is resized to n characters. The second argument is optional. If provided and the string is enlarged, the extra characters are initialized to c.
string::size_type object.rfind(string argument, string::size_type pos):
Returns the index in object where argument is found. Searching proceeds from the end of object back to the beginning. If the argument pos is omitted, the search starts at the beginning of object. If provided, it refers to the index in object where the search for argument should start.
string::size_type object.rfind(char const *argument, string::size_type pos, string::size_type n):
Returns the index in object where argument is found. Searching proceeds from the end of object back to the beginning. The parameter n indicates the number of characters of argument that should be used in the search: it defines a partial string starting at the beginning of argument. If omitted, all characters in argument are used. The parameter pos refers to the index in object where the search for argument should start. If the parameter pos is omitted as well, all of object is scanned.
string::size_type object.rfind(char c, string::size_type pos):
Returns the index in object where c is found. Searching proceeds from the end of object back to the beginning. If the argument pos is omitted, the search starts at the beginning of object. If provided, it refers to the index in object where the search for argument should start.
string::size_type object.size():
returns the number of characters stored in object.
string object.substr(string::size_type pos, string::size_type n):
Returns a substring of object. The parameter n may be used to specify the number of characters of argument that are returned. The parameter pos may be used to specify the index of the first character of argument that is returned. Either n or both arguments may be omitted.
string::size_type object.swap(string argument):
swaps the contents of the object and argument. In this case, argument must be a string and cannot be a char const *.