cppreference.com > C++ Strings append Syntax:
      #include <string>
      string& append( const string& str );
      string& append( const char* str );
      string& append( const string& str, size_type index, size_type len );
      string& append( const char* str, size_type num );
      string& append( size_type num, char ch );
      string& append( input_iterator start, input_iterator end );
The append() function either: appends str on to the end of the current string, appends a substring of str starting at index that is len characters long on to the end of the current string, appends num characters of str on to the end of the current string, appends num repititions of ch on to the end of the current string, or appends the sequence denoted by start and end on to the end of the current string. For example, the following code uses append() to add 10 copies of the '!' character to a string:
       string str = "Hello World";
       str.append( 10, '!' );
       cout << str << endl;
That code displays:
       Hello World!!!!!!!!!!
In the next example, append() is used to concatenate a substring of one string onto another string:
     string str1 = "Eventually I stopped caring...";
     string str2 = "but that was the '80s so nobody noticed.";

     str1.append( str2, 25, 15 );
     cout << "str1 is " << str1 << endl;
When run, the above code displays:
     str1 is Eventually I stopped caring...nobody noticed.

capacity
Syntax:

      #include <string>
      size_type capacity() const;

The capacity() function returns the number of elements that the string can hold before it will need to allocate more space.

For example, the following code uses two different methods to set the capacity of two vectors. One method passes an argument to the constructor that suggests an initial size, the other method calls the reserve function to achieve a similar goal:

     vector<int> v1(10);
     cout << "The capacity of v1 is " << v1.capacity() << endl;
     vector<int> v2;
     v2.reserve(20);
     cout << "The capacity of v2 is " << v2.capacity() << endl;

When run, the above code produces the following output:

     The capacity of v1 is 10
     The capacity of v2 is 20

C++ containers are designed to grow in size dynamically. This frees the programmer from having to worry about storing an arbitrary number of elements in a container. However, sometimes the programmer can improve the performance of her program by giving hints to the compiler about the size of the containers that the program will use. These hints come in the form of the reserve() function and the constructor used in the above example, which tell the compiler how large the container is expected to get.

The capacity() function runs in constant time.

Related topics:
reserve
resize
size

assign
Syntax:

      #include <string>
      void assign( size_type num, const char& val );
      void assign( input_iterator start, input_iterator end );
      string& assign( const string& str );
      string& assign( const char* str );
      string& assign( const char* str, size_type num );
      string& assign( const string& str, size_type index, size_type len );
      string& assign( size_type num, const char& ch );

The deafult assign() function gives the current string the values from start to end, or gives it num copies of val.

In addition to the normal (C++ Lists) assign() functionality that all C++ containers have, strings possess an assign() function that also allows them to:

- assign str to the current string,
- assign the first num characters of str to the current string,
- assign a substring of str starting at index that is len characters long to the current string,

For example, the following code:

       string str1, str2 = "War and Peace";
       str1.assign( str2, 4, 3 );
       cout << str1 << endl;

displays

       and

This function will destroy the previous contents of the string.

Related topics:
(C++ Lists) assign

at
Syntax:

      #include <string>
      TYPE& at( size_type loc );
      const TYPE& at( size_type loc ) const;

The at() function returns a reference to the element in the string at index loc. The at() function is safer than the [] operator, because it won't let you reference items outside the bounds of the string.

For example, consider the following code:

     vector<int> v( 5, 1 );
     for( int i = 0; i < 10; i++ ) {
       cout << "Element " << i << " is " << v[i] << endl;
     }

This code overrunns the end of the vector, producing potentially dangerous results. The following code would be much safer:

     vector<int> v( 5, 1 );
     for( int i = 0; i < 10; i++ ) {
       cout << "Element " << i << " is " << v.at(i) << endl;
     }

Instead of attempting to read garbage values from memory, the at() function will realize that it is about to overrun the vector and will throw an exception.

Related topics:
(C++ Multimaps) Container operators
(C++ Double-ended Queues) Container operators

begin
Syntax:

      #include <string>
      iterator begin();
      const_iterator begin() const;

The function begin() returns an iterator to the first element of the string. begin() should run in constant time.

For example, the following code uses begin() to initialize an iterator that is used to traverse a list:

       // Create a list of characters
       list<char> charList;
       for( int i=0; i < 10; i++ ) {
         charList.push_front( i + 65 );
       }
       // Display the list
       list<char>::iterator theIterator;
       for( theIterator = charList.begin(); theIterator != charList.end(); theIterator++ ) {
         cout << *theIterator;
       }

Related topics:
end
rbegin
rend

c_str
Syntax:

      #include <string>
      const char* c_str();

The function c_str() returns a const pointer to a regular C string, identical to the current string. The returned string is null-terminated.

Note that since the returned pointer is of type (C/C++ Keywords) const, the character data that c_str() returns cannot be modified.

Related topics:
String operators
data

find_first_of
Syntax:

      #include <string>
      size_type find_first_of( const string &str, size_type index = 0 );
      size_type find_first_of( const char* str, size_type index = 0 );
      size_type find_first_of( const char* str, size_type index, size_type num );
      size_type find_first_of( char ch, size_type index = 0 );

The find_first_of() function either:

- returns the index of the first character within the current string that matches any character in str, beginning the search at index, string::npos if nothing is found,
- returns the index of the first character within the current string that matches any character in str, beginning the search at index and searching at most num characters, string::npos if nothing is found,
- or returns the index of the first occurrence of ch in the current string, starting the search at index, string::npos if nothing is found.

Related topics:
find
find_first_not_of
find_last_not_of
find_last_of
rfind

clear
Syntax:

      #include <string>
      void clear();

The function clear() deletes all of the elements in the string. clear() runs in linear time.

Related topics:
(C++ Lists) erase

compare
Syntax:

      #include <string>
      int compare( const string& str );
      int compare( const char* str );
      int compare( size_type index, size_type length, const string& str );
      int compare( size_type index, size_type length, const string& str, size_type index2,
      size_type length2 );
      int compare( size_type index, size_type length, const char* str, size_type length2 );

The compare() function either compares str to the current string in a variety of ways, returning

Return Value | Case
--- | ---
less than zero | this < str
zero | this == str
greater than zero | this > str

The various functions either:

- compare str to the current string,
- compare str to a substring of the current string, starting at index for length characters,
- compare a substring of str to a substring of the current string, where index2 and length2 refer to str and index and length refer to the current string,
- or compare a substring of str to a substring of the current string, where the substring of str begins at zero and is length2 characters long, and the substring of the current string begins at index and is length characters long.

For example, the following code uses compare() to compare four strings with eachother:

     string names[] = {"Homer", "Marge", "3-eyed fish", "inanimate carbon rod"};

     for( int i = 0; i < 4; i++ ) {
       for( int j = 0; j < 4; j++ ) {
         cout << names[i].compare( names[j] ) << " ";
       }
       cout << endl;
     }

Data from the above code was used to generate this table, which shows how the various strings compare to eachother:

| Homer | Marge | 3-eyed fish | inanimate carbon rod
--- | --- | --- | --- | ---
"Homer".compare( x ) | 0 | -1 | 1 | -1
"Marge".compare( x ) | 1 | 0 | 1 | -1
"3-eyed fish".compare( x ) | -1 | -1 | 0 | -1
"inanimate carbon rod".compare( x ) | 1 | 1 | 1 | 0

Related topics:
String operators

copy
Syntax:

      #include <string>
      size_type copy( char* str, size_type num, size_type index = 0 );

The copy() function copies num characters of the current string (starting at index if it's specified, 0 otherwise) into str.

The return value of copy() is the number of characters copied.

For example, the following code uses copy() to extract a substring of a string into an array of characters:

     char buf[30];
     memset( buf, '\0', 30 );
     string str = "Trying is the first step towards failure.";
     str.copy( buf, 24 );
     cout << buf << endl;

When run, this code displays:

     Trying is the first step

Note that before calling copy(), we first call (Standard C String and Character) memset() to fill the destination array with copies of the NULL character. This step is included to make sure that the resulting array of characters is NULL-terminated.

Related topics:
substr

data
Syntax:

      #include <string>
      const char *data();

The function data() returns a pointer to the first character in the current string.

Related topics:
String operators
c_str

empty
Syntax:

      #include <string>
      bool empty() const;

The empty() function returns true if the string has no elements, false otherwise.

For example, the following code uses empty() as the stopping condition on a (C/C++ Keywords) while loop to clear a string and display its contents in reverse order:

     vector<int> v;
     for( int i = 0; i < 5; i++ ) {
       v.push_back(i);
     }
     while( !v.empty() ) {
       cout << v.back() << endl;
       v.pop_back();
     }

Related topics:
size

end
Syntax:

      #include <string>
      iterator end();
      const_iterator end() const;

The end() function returns an iterator just past the end of the string.

Note that before you can access the last element of the string using an iterator that you get from a call to end(), you'll have to decrement the iterator first.

For example, the following code uses begin() and end() to iterate through all of the members of a vector:

     vector<int> v1( 5, 789 );
     vector<int>::iterator it;
     for( it = v1.begin(); it != v1.end(); it++ ) {
       cout << *it << endl;
     }

The iterator is initialized with a call to begin(). After the body of the loop has been executed, the iterator is incremented and tested to see if it is equal to the result of calling end(). Since end() returns an iterator pointing to an element just after the last element of the vector, the loop will only stop once all of the elements of the vector have been displayed.

end() runs in constant time.

Related topics:
begin
rbegin
rend

erase
Syntax:

      #include <string>
      iterator erase( iterator loc );
      iterator erase( iterator start, iterator end );
      string& erase( size_type index = 0, size_type num = npos );

The erase() function either:

- removes the character pointed to by loc, returning an iterator to the next character,
- removes the characters between start and end (including the one at start but not the one at end), returning an iterator to the character after the last character removed,
- or removes num characters from the current string, starting at index, and returns *this.

The parameters index and num have default values, which means that erase() can be called with just index to erase all characters after index or with no arguments to erase all characters.

For example:

       string s("So, you like donuts, eh? Well, have all the donuts in the world!");
       cout << "The original string is '" << s << "'" << endl;

       s.erase( 50, 14 );
       cout << "Now the string is '" << s << "'" << endl;
       s.erase( 24 );
       cout << "Now the string is '" << s << "'" << endl;
       s.erase();
       cout << "Now the string is '" << s << "'" << endl;

will display

       The original string is 'So, you like donuts, eh? Well, have all the donuts in the world!'
       Now the string is 'So, you like donuts, eh? Well, have all the donuts'
       Now the string is 'So, you like donuts, eh?'
       Now the string is ''

erase() runs in linear time.

Related topics:
insert

find
Syntax:

      #include <string>
      size_type find( const string& str, size_type index );
      size_type find( const char* str, size_type index );
      size_type find( const char* str, size_type index, size_type length );
      size_type find( char ch, size_type index );

The function find() either:

- returns the first occurrence of str within the current string, starting at index, string::npos if nothing is found,
- returns the first occurrence of str within the current string and within length characters, starting at index, string::npos if nothing is found,
- or returns the index of the first occurrence ch within the current string, starting at index, string::npos if nothing is found.

For example:

       string str1( "Alpha Beta Gamma Delta" );
       string::size_type loc = str1.find( "Omega", 0 );
       if( loc != string::npos )
         cout << "Found Omega at " << loc << endl;
       else
         cout << "Didn't find Omega" << endl;

Related topics:
find_first_not_of
find_first_of
find_last_not_of
find_last_of
rfind

find_first_not_of
Syntax:

      #include <string>
      size_type find_first_not_of( const string& str, size_type index = 0 );
      size_type find_first_not_of( const char* str, size_type index = 0 );
      size_type find_first_not_of( const char* str, size_type index, size_type num );
      size_type find_first_not_of( char ch, size_type index = 0 );

The find_first_not_of() function either:

- returns the index of the first character within the current string that does not match any character in str, beginning the search at index, string::npos if nothing is found,
- returns the index of the first character within the current string that does not match any character in str, beginning the search at index and searching at most num characters, string::npos if nothing is found,
- or returns the index of the first occurrence of a character that does not match ch in the current string, starting the search at index, string::npos if nothing is found.

For example, the following code searches a string of text for the first character that is not a lower-case character, space, comma, or hypen:

     string lower_case = "abcdefghijklmnopqrstuvwxyz ,-";
     string str = "this is the lower-case part, AND THIS IS THE UPPER-CASE PART";
     cout << "first non-lower-case letter in str at: " << str.find_first_not_of(lower_case) << endl;

When run, find_first_not_of() finds the first upper-case letter in str at index 29 and displays this output:

     first non-lower-case letter in str at: 29

Related topics:
find
find_first_not_of
find_first_of
find_last_not_of
find_last_of
rfind

find_last_not_of
Syntax:

      #include <string>
      size_type find_last_not_of( const string& str, size_type index = npos );
      size_type find_last_not_of( const char* str, size_type index = npos);
      size_type find_last_not_of( const char* str, size_type index, size_type num );
      size_type find_last_not_of( char ch, size_type index = npos );

The find_last_not_of() function either:

- returns the index of the last character within the current string that does not match any character in str, doing a reverse search from index, string::npos if nothing is found,
- returns the index of the last character within the current string that does not match any character in str, doing a reverse search from index and searching at most num characters of str, or returning string::npos if nothing is found,
- or returns the index of the last occurrence of a character that does not match ch in the current string, doing a reverse search from index, string::npos if nothing is found.

For example, the following code searches for the last non-lower-case character in a mixed string of characters:

     string lower_case = "abcdefghijklmnopqrstuvwxyz";
     string str = "abcdefgABCDEFGhijklmnop";
     cout << "last non-lower-case letter in str at: " << str.find_last_not_of(lower_case) << endl;

This code displays the following output:

     last non-lower-case letter in str at: 13

Related topics:
find
find_first_not_of
find_first_of
find_last_of
rfind

find_last_of
Syntax:

      #include <string>
      size_type find_last_of( const string& str, size_type index = npos );
      size_type find_last_of( const char* str, size_type index = npos );
      size_type find_last_of( const char* str, size_type index, size_type num );
      size_type find_last_of( char ch, size_type index = npos );

The find_last_of() function either:

- returns the index of the first character within the current string that matches any character in str, doing a reverse search from index, string::npos if nothing is found,
- returns the index of the first character within the current string that matches any character in str, doing a reverse search from index and searching at most num characters, string::npos if nothing is found,
- or returns the index of the first occurrence of ch in the current string, doing a reverse search from index, string::npos if nothing is found.

Related topics:
find
find_first_not_of
find_first_of
find_last_not_of
rfind

getline
Syntax:

      #include <string>
      istream& getline( istream& is, string& s, char delimiter = '\n' );

The C++ string class defines the global function getline() to read strings from and I/O stream. The getline() function, which is not part of the string class, reads a line from is and stores it into s. If a character delimiter is specified, then getline() will use delimiter to decide when to stop reading data.

For example, the following code reads a line of text from STDIN and displays it to STDOUT:

     string s;
     getline( cin, s );
     cout << "You entered " << s << endl;

Related topics:
(C++ I/O) get
(C++ I/O) getline

insert
Syntax:

      #include <string>
      iterator insert( iterator i, const char& ch );
      string& insert( size_type index, const string& str );
      string& insert( size_type index, const char* str );
      string& insert( size_type index1, const string& str, size_type index2, size_type num );
      string& insert( size_type index, const char* str, size_type num );
      string& insert( size_type index, size_type num, char ch );
      void insert( iterator i, size_type num, const char& ch );
      void insert( iterator i, iterator start, iterator end );

The very multi-purpose insert() function either:

- inserts ch before the character denoted by i,
- inserts str into the current string, at location index,
- inserts a substring of str (starting at index2 and num characters long) into the current string, at location index1,
- inserts num characters of str into the current string, at location index,
- inserts num copies of ch into the current string, at location index,
- inserts num copies of ch into the current string, before the character denoted by i,
- or inserts the characters denoted by start and end into the current string, before the character specified by i.

Related topics:
erase
replace

length
Syntax:

      #include <string>
      size_type length() const;

    The length() function returns the number of elements in the current string, performing the same role as the size() function.

Related topics:
size

max_size
Syntax:

      #include <string>
      size_type max_size() const;

The max_size() function returns the maximum number of elements that the string can hold. The max_size() function should not be confused with the size() or capacity() functions, which return the number of elements currently in the string and the the number of elements that the string will be able to hold before more memory will have to be allocated, respectively.

Related topics:
size

push_back
Syntax:

      #include <string>
      void push_back( const TYPE& val );

The push_back() function appends val to the end of the string.

For example, the following code puts 10 integers into a list:

       list<int> the_list;
       for( int i = 0; i < 10; i++ )
         the_list.push_back( i );

When displayed, the resulting list would look like this:

     0 1 2 3 4 5 6 7 8 9

push_back() runs in constant time.

Related topics:
(C++ Lists) assign
(C++ Lists) insert
(C++ Lists) pop_back
(C++ Lists) push_front

rbegin
Syntax:

      #include <string>
      reverse_iterator rbegin();
      const_reverse_iterator rbegin() const;

The rbegin() function returns a reverse_iterator to the end of the current string.

rbegin() runs in constant time.

Related topics:
begin
end
rend

rend
Syntax:

      #include <string>
      reverse_iterator rend();
      const_reverse_iterator rend() const;

The function rend() returns a reverse_iterator to the beginning of the current string.

rend() runs in constant time.

Related topics:
begin
end
rbegin

replace
Syntax:

      #include <string>
      string& replace( size_type index, size_type num, const string& str );
      string& replace( size_type index1, size_type num1, const string& str, size_type index2, size_type num2 );
      string& replace( size_type index, size_type num, const char* str );
      string& replace( size_type index, size_type num1, const char* str, size_type num2 );
      string& replace( size_type index, size_type num1, size_type num2, char ch );
      string& replace( iterator start, iterator end, const string& str );
      string& replace( iterator start, iterator end, const char* str );
      string& replace( iterator start, iterator end, const char* str, size_type num );
      string& replace( iterator start, iterator end, size_type num, char ch );

The function replace() either:

- replaces characters of the current string with up to num characters from str, beginning at index,
- replaces up to num1 characters of the current string (starting at index1) with up to num2 characters from str beginning at index2,
- replaces up to num characters of the current string with characters from str, beginning at index in str,
- replaces up to num1 characters in the current string (beginning at index1) with num2 characters from str beginning at index2,
- replaces up to num1 characters in the current string (beginning at index) with num2 copies of ch,
- replaces the characters in the current string from start to end with str,
- replaces characters in the current string from start to end with num characters from str,
- or replaces the characters in the current string from start to end with num copies of ch.

For example, the following code displays the string "They say he carved it himself...find your soul-mate, Homer."

       string s = "They say he carved it himself...from a BIGGER spoon";
       string s2 = "find your soul-mate, Homer.";
       s.replace( 32, s2.length(), s2 );
       cout << s << endl;

Related topics:
insert

reserve
Syntax:

      #include <string>
      void reserve( size_type size );

The reserve() function sets the capacity of the string to at least size.

reserve() runs in linear time.

Related topics:
capacity

resize
Syntax:

      #include <string>
      void resize( size_type num, const TYPE& val = TYPE() );

The function resize() changes the size of the string to size. If val is specified then any newly-created elements will be initialized to have a value of val.

This function runs in linear time.

Related topics:
(C++ Multimaps) Container constructors & destructors
capacity
size

rfind
Syntax:

      #include <string>
      size_type rfind( const string& str, size_type index );
      size_type rfind( const char* str, size_type index );
      size_type rfind( const char* str, size_type index, size_type num );
      size_type rfind( char ch, size_type index );

The rfind() function either:

- returns the location of the first occurrence of str in the current string, doing a reverse search from index, string::npos if nothing is found,
- returns the location of the first occurrence of str in the current string, doing a reverse search from index, searching at most num characters, string::npos if nothing is found,
- or returns the location of the first occurrence of ch in the current string, doing a reverse search from index, string::npos if nothing is found.

For example, in the following code, the first call to rfind() returns string::npos, because the target word is not within the first 8 characters of the string. However, the second call returns 9, because the target word is within 20 characters of the beginning of the string.

       int loc;
       string s = "My cat's breath smells like cat food.";
       loc = s.rfind( "breath", 8 );
       cout << "The word breath is at index " << loc << endl;
       loc = s.rfind( "breath", 20 );
       cout << "The word breath is at index " << loc << endl;

Related topics:
find
find_first_not_of
find_first_of
find_last_not_of
find_last_of

size
Syntax:

      #include <string>
      size_type size() const;

The size() function returns the number of elements in the current string.

Related topics:
capacity
empty
length
max_size
resize

String constructors
Syntax:

      #include <string>
      string();
      string( const string& s );
      string( size_type length, const char& ch );
      string( const char* str );
      string( const char* str, size_type length );
      string( const string& str, size_type index, size_type length );
      string( input_iterator start, input_iterator end );
      ~string();

The string constructors create a new string containing:

- nothing; an empty string,
- a copy of the given string s,
- length copies of ch,
- a duplicate of str (optionally up to length characters long),
- a substring of str starting at index and length characters long
- a string of characterss denoted by the start and end iterators

For example,

       string str1( 5, 'c' );
       string str2( "Now is the time..." );
       string str3( str2, 11, 4 );
       cout << str1 << endl;
       cout << str2 << endl;
       cout << str3 << endl;

displays

       ccccc
       Now is the time...
       time

The string constructors usually run in linear time, except the empty constructor, which runs in constant time.

String operators
Syntax:

      #include <string>
      bool operator==(const string& c1, const string& c2);
      bool operator!=(const string& c1, const string& c2);
      bool operator<(const string& c1, const string& c2);
      bool operator>(const string& c1, const string& c2);
      bool operator<=(const string& c1, const string& c2);
      bool operator>=(const string& c1, const string& c2);
      string operator+(const string& s1, const string& s2 );
      string operator+(const char* s, const string& s2 );
      string operator+( char c, const string& s2 );
      string operator+( const string& s1, const char* s );
      string operator+( const string& s1, char c );
      ostream& operator<<( ostream& os, const string& s );
      istream& operator>>( istream& is, string& s );
      string& operator=( const string& s );
      string& operator=( const char* s );
      string& operator=( char ch );
      char& operator[]( size_type index );

C++ strings can be compared and assigned with the standard comparison operators: ==, !=, <=, >=, <, >, and =. Performing a comparison or assigning one string to another takes linear time.

Two strings are equal if:

      1. Their size is the same, and
      2. Each member in location i in one string is equal to the the member in location i in the other string.

Comparisons among strings are done lexicographically.

In addition to these normal (C++ Multimaps) Container operators, strings can also be concatenated with the + operator and fed to the C++ I/O stream classes with the << and >> operators.

For example, the following code concatenates two strings and displays the result:

     string s1 = "Now is the time...";
     string s2 = "for all good men...";
     string s3 = s1 + s2;
     cout << "s3 is " << s3 << endl;

Furthermore, strings can be assigned values that are other strings, character arrays, or even single characters. The following code is perfectly valid:

     char ch = 'N';
     string s = ch;

Individual characters of a string can be examined with the [] operator, which runs in constant time.

Related topics:
(C++ Multimaps) Container operators
c_str
compare
data

substr
Syntax:

      #include <string>
      string substr( size_type index, size_type num = npos );

The substr() function returns a substring of the current string, starting at index, and num characters long. If num is omitted, it will default to string::npos, and the substr() function will simply return the remainder of the string starting at index.

For example:

       string s("What we have here is a failure to communicate");
       string sub = s.substr(21);
       cout << "The original string is " << s << endl;
       cout << "The substring is " << sub << endl;

displays

       The original string is What we have here is a failure to communicate
       The substring is a failure to communicate

Related topics:
copy

swap
Syntax:

      #include <string>
      void swap( const container& from );

The swap() function exchanges the elements of the current string with those of from. This function operates in constant time.

For example, the following code uses the swap() function to exchange the values of two strings:

       string first( "This comes first" );
       string second( "And this is second" );
       first.swap( second );
       cout << first << endl;
       cout << second << endl;

The above code displays:

       And this is second
       This comes first

Related topics:
(C++ Lists) splice