Common C ++ string functions

Common C ++ string functions

Http://xiaocao000.spaces.live.com/blog/cns! F826a925cf33491a! 117. Entry

Constructor of the string class:

String (const char * s); // use the C string s for initialization
String (int n, char C); // initialize with n characters C
In addition, the string class also supports default constructor and copy constructor, such as string S1; string S2 = "hello. If the constructed string is too long to be expressed, the length_error exception is thrown.

String character operations:

Const char & operator [] (int n) const;
Const char & at (int n) const;
Char & operator [] (int n );
Char & at (int n );
OPERATOR [] and at () both return the position of the nth character in the current string. However, the at function provides a range check and throws an out_of_range exception when the current string is out of bounds, the subscript operator [] does not provide access check.
Const char * Data () const; // returns a non-null ending C character array
Const char * c_str () const; // returns a null-terminated C string.
Int copy (char * s, int N, int Pos = 0) const; // copy the n characters starting with POS in the current string to the character array starting with S, and return the actual number of copies

Feature description of string:

Int capacity () const; // returns the current capacity (that is, the number of elements in the string that can be stored without adding memory)
Int max_size () const; // returns the maximum length of a string that can be stored in a string object.
Int size () const; // returns the size of the current string
Int length () const; // returns the length of the current string
Bool empty () const; // whether the current string is null
Void resize (INT Len, char C); // set the current size of the string to Len and fill the missing part with character C.

Input and Output operations of the string class:

String type heavy-duty Operator> used for input, also heavy-duty Operator <used for output operations.
The Getline (istream & in, string & S) function is used to read strings from the input stream in to S and separate them with line breaks '\ n.
 

String Value assignment:

String & operator = (const string & S); // assign string s to the current string
String & assign (const char * s); // use the C-type string s to assign a value
String & assign (const char * s, int N); // assign values with n characters starting with string s
String & assign (const string & S); // assign string s to the current string
String & assign (int n, char C); // assign a value to the current string with n characters C
String & assign (const string & S, int start, int N); // assign the n characters starting from start in string s to the current string
String & assign (const_iterator first, const_itertor last); // assign the part between the first and last iterators to the string
 

String connection:

String & operator ++ = (const string & S); // connects string s to the end of the current string
String & append (const char * s); // connect string s of the C type to the end of the current string
String & append (const char * s, int N); // connect the first n characters of the C-type string s to the end of the current string
String & append (const string & S); // same as operator + = ()
String & append (const string & S, int POs, int N); // connects n characters starting from POs in string s to the end of the current string
String & append (int n, char C); // Add n characters to the end of the current string
String & append (const_iterator first, const_iterator last); // link the part of the iterator first and last to the end of the current string
 

String comparison:


Bool operator = (const string & S1, const string & S2) const; // compare whether two strings are equal
Operator ">", "<", "> =", "<= ","! = "Both are reloaded for string comparison;
Int compare (const string & S) const; // compare the size of the current string and S
Int compare (INT POs, int N, const string & S) const; // compare the size of S and the string consisting of n characters starting from POS of the current string
Int compare (INT POs, int N, const string & S, int pos2, int N2) const; // compare the size of a string consisting of n characters starting from POs and N2 characters starting from pos2 in S
Int compare (const char * s) const;
Int compare (INT POs, int N, const char * s) const;
Int compare (INT POs, int N, const char * s, int pos2) const;
When the Compare function is>, 1 is returned. If the value is <,-1 is returned. If the value is =, 0 is returned. 

Substring of string:


String substr (INT Pos = 0, int n = NPOs) const; // returns a string consisting of n characters starting with POS.

String exchange:

Void swap (string & S2); // exchange the value of the current string and S2

 

String-type lookup functions:

Int find (char C, int Pos = 0) const; // start from POs to find the position of character C in the current string
Int find (const char * s, int Pos = 0) const; // start from POs to find the position of string s in the current string
Int find (const char * s, int POs, int N) const; // start from POs to find the position of the First n characters in string s in the current string
Int find (const string & S, int Pos = 0) const; // search for the position of string s in the current string from POS
// Return the location when the search is successful. If the search fails, return the string: NPOs value.

Int rfind (char C, int Pos = NPOs) const; // search for the position of character C in the current string from the POs to the forward
Int rfind (const char * s, int Pos = NPOs) const;
Int rfind (const char * s, int POs, int n = NPOs) const;
Int rfind (const string & S, int Pos = NPOs) const;
// Start from the POs and start from the back to the front to find the position of the string consisting of the First n characters in string s in the current string. If the string fails, return the value of string: NPOs.

Int find_first_of (char C, int Pos = 0) const; // search for the position where character C appears for the first time from POS
Int find_first_of (const char * s, int Pos = 0) const;
Int find_first_of (const char * s, int POs, int N) const;
Int find_first_of (const string & S, int Pos = 0) const;
// Start from POs to find the position of the first character in the array consisting of the First n characters of S in the current string. String: NPOs

Int find_first_not_of (char C, int Pos = 0) const;
Int find_first_not_of (const char * s, int Pos = 0) const;
Int find_first_not_of (const char * s, int POs, int N) const;
Int find_first_not_of (const string & S, int Pos = 0) const;
// Find the position of the first character not in the string s from the current string. If the string fails to appear, string: NPOs is returned.

int find_last_of(char c, int pos = npos) const;
int find_last_of(const char *s, int pos = npos) const;
int find_last_of(const char *s, int pos, int n = npos) const;
int find_last_of(const string &s,int pos = npos) const;

Int find_last_not_of (char C, int Pos = NPOs) const;
Int find_last_not_of (const char * s, int Pos = NPOs) const;
Int find_last_not_of (const char * s, int POs, int N) const;
Int find_last_not_of (const string & S, int Pos = NPOs) const;
// Find_last_of and find_last_not_of are similar to find_first_of and find_first_not_of, but they are searched forward from the back.

 

Replacement functions of the string class:

String & replace (INT P0, int N0, const char * s); // Delete the N0 characters starting with P0, and insert the string s at P0
String & replace (INT P0, int N0, const char * s, int N); // Delete N0 characters starting with P0, insert the first n characters of string s in P0.
String & replace (INT P0, int N0, const string & S); // Delete the N0 characters starting with P0, and insert the string s at P0
String & replace (INT P0, int N0, const string & S, int POs, int N); // Delete N0 characters starting with P0, then insert n characters starting from POs in string s at P0
String & replace (INT P0, int N0, int N, char C); // Delete N0 characters starting with P0, and then insert n characters C at P0
String & replace (iterator first0, iterator last0, const char * s); // Replace the parts between [first0, last0) with the string s
String & replace (iterator first0, iterator last0, const char * s, int N); // Replace the portion between [first0, last0) with the first n characters of S
String & replace (iterator first0, iterator last0, const string & S); // Replace the parts between [first0, last0) with the string s
String & replace (iterator first0, iterator last0, int N, char C); // Replace the parts between [first0, last0) with N characters C
String & replace (iterator first0, iterator last0, const_iterator first, const_iterator last); // Replace the parts between [first0, last0) with strings between [first, last)

Insert functions of the string class:

String & insert (INT P0, const char * s );
String & insert (INT P0, const char * s, int N );
String & insert (INT P0, const string & S );
String & insert (INT P0, const string & S, int POs, int N );
// The first four functions Insert the first n characters starting with pos in the string s at the P0 position
String & insert (INT P0, int N, char C); // This function inserts n characters in P0 C
Iterator insert (iterator it, char C); // insert character C in it to return the position of the iterator after insertion
Void insert (iterator it, const_iterator first, const_iterator last); // insert characters between [first, last) in it
Void insert (iterator it, int N, char C); // insert n characters in it


Delete functions of the string class

Iterator erase (iterator first, iterator last); // deletes all characters between [first, last) and returns the position of the iterator after deletion.
Iterator erase (iterator it); // deletes the characters it points to and returns the position of the iterator after deletion.
String & erase (INT Pos = 0, int n = NPOs); // Delete the n characters starting with POS and return the modified string

 

String type iterator processing:

The string class provides the iterator for Traversing forward and backward. The iterator provides the syntax for accessing each character, similar to pointer operations. The iterator does not check the range.
Use string: iterator or string: const_iterator to declare the iterator variable. const_iterator cannot change the content of the iteration. Common iterator functions include:
Const_iterator begin () const;
Iterator begin (); // returns the starting position of the string.
Const_iterator end () const;
Iterator end (); // returns the position after the last character of string
Const_iterator rbegin () const;
Iterator rbegin (); // returns the position of the last character of string
Const_iterator rend () const;
Iterator rend (); // returns the first character of the string.
Rbegin and rend are used for iterative access from the back and forward. They are implemented by setting the iterator string: reverse_iterator, string: const_reverse_iterator

 

String stream processing:

By defining ostringstream and istringstream variables, the <sstream> header file contains
For example:
String input ("Hello, this is a test ");
Istringstream is (input );
String S1, S2, S3, S4;
Is> S1> S2> S3> S4; // S1 = "hello, this", S2 = "is", S3 = "", s4 = "test"
Ostringstream OS;
OS <S1 <S2 <S3 <S4;
Cout <OS. STR ();