Usage of C + + string

The reason for discarding the char* string is to choose the string class in the C + + standard library because he does not have to worry about the adequacy of the memory, the length of the string, and so on, and as a class, his integrated operation function is sufficient to fulfill the needs of most of our cases (even 100%). We can use = To do the assignment, = = to compare, + do concatenation (is not very simple?). We can do it as a basic data type for C + +.

First, in order to use the string type in our program, we must include the header file <string>. As follows:
#include <string>//Note This is not string.h string.h is a C string header file

constructor of the String class:

String (const char *s); Initialize with C string s
string (int N,char c); Initialize with n characters c

string S; Generates an empty string s

string S (str)//Copy constructor generates a copy of STR
string s (STR,STRIDX)//The part of "starting at position Stridx" within the string str as the initial value of the string
string s (Str,stridx,strlen)//The part of the string str "starting at STRIDX and at most strlen" as the initial value of the string
string s (CStr)//C string as the initial value of s
string s (chars,chars_len)//Chars_len characters before the C string as the initial value of the string s.
string s (num,c)//generates a string containing num characters c
string s (beg,end)//The initial value of the string s as a character in the interval beg;end (not containing the end)
S.~string ()//Destroy all characters, free memory
In addition, the string class supports both the default constructor and the copy constructor, such as String s1;string s2= "Hello", which is the correct notation. A Length_error exception is thrown when the constructed string is too long to be expressed;

Character manipulation of the string class:
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, but the at function provides a scope check that throws a Out_of_range exception when it crosses the border, and the subscript operator [] does not provide check access.
const char *data () const;//returns a non-null-terminated C-character array
const char *C_STR () const;//returns a null-terminated C string
int copy (char *s, int n, int pos = 0) const;//copies the n characters starting at Pos in the current string to a character array starting with S, returning the number of actual copies

Character description of String:
int capacity () const; Returns the current capacity (that is, the number of elements in a string that do not have to increase memory)
int max_size () const; Returns the length of the largest 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 empty
void Resize (int len,char c);//Set the current size of the string to Len and fill in the insufficient part with the character C

Input and output operations of the String class:
The string class overloaded operator operator>> is used for input, and the same overloaded operator operator<< is used for output operations.
The function getline (IStream &in,string &s) is used to read the string from the input stream in to s, separated by a newline character ' \ n '.

Assignment of String:
String &operator= (const string &s);//assigns the string s to the current string
String &assign (const char *s);//Assigning a value with the C type string s
String &assign (const char *s,int n);//n characters assigned value starting with C string s
String &assign (const string &s);//assigns the string s to the current string
String &assign (int n,char c);//assigns a value to the current string with n characters c
String &assign (const string &s,int start,int N);//assigned the current string from the n characters in the string s from start
String &assign (Const_iterator first,const_itertor last);//Assigning the part between first and last iterators to a string

string Connection:
String &operator+= (const string &s);//Connect the string s to the end of the current string  
String &append (const char *s);           // Concatenate the C-type string s to the end of the current string
string &append (const char *s,int N),//To connect prompt the first n characters of type C string s to the end of the current string
string &append ( Const string &s);   //With operator+= ()
String &append (const string &s,int pos,int N);// Connect prompt the n characters from the POS in the string s to the end of the current string
string &append (int n,char c);       // Adds n characters to the end of the current string C
String &append (Const_iterator first,const_iterator last);//Connect the part between the iterator first and last to the end of the current string

Comparison of String:
BOOL operator== (const string &s1,const string &s2) const;//compares two strings for equality
The operators ">", "<", ">=", "<=", "! =" are overloaded for string comparisons;
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;//compares the current string with the size of S of N characters starting from Pos
int compare (int pos, int n,const string &s,int pos2,int n2) const;//Compare the string of n characters that the current string starts from Pos with S

Pos2 the size of a string that starts with N2 characters
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;
The Compare function returns -1,== when > returns 1,< when return is 0

Substring of string:
String substr (int pos = 0,int n = NPOs) const;//Returns a string of n characters starting at Pos

Exchange of String:
void Swap (string &s2); Swap the current string with the value of S2

Lookup function for string class:
int find (char c, int pos = 0) const;//The position of the character C at the current string starting from the POS
int find (const char *s, int pos = 0) const;//Find the position of the string s in the current string starting from the POS
int find (const char *s, int pos, int n) const;//from Pos to find the position of the first n characters in the string s in the current string
int find (const string &s, int pos = 0) const;//Find the position of the string s in the current string starting from the POS
Returns the location when the lookup succeeds, and fails to return the value of String::npos
int RFind (char c, int pos = NPOs) const;//The position of the character C in the current string from the beginning of the POS
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;
Finds the position of the first n characters in the string s in the current string from the beginning of the POS, and returns the value of String::npos on failure.
int find_first_of (char c, int pos = 0) const;//Find the first occurrence of character C 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;
Finds the position of the character in the first n-character array of s in the current string starting from Pos. Find failed return 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;
Finds the first occurrence of a character not in the string s from the current string, fails back to String::npos
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, except that they look forward from behind.

substitution function for string class:
String &replace (int p0, int n0,const char *s);//delete p0 characters from N0, then insert string s at P0
String &replace (int p0, int n0,const char *s, int n),//delete p0 start n0 characters, then insert first n characters of string s at P0
String &replace (int p0, int n0,const string &s),//delete p0 characters from N0, then insert string s at P0
String &replace (int p0, int n0,const string &s, int pos, int n),//delete p0 start N0 character, and then insert string s at P0 to start n characters from Pos
String &replace (int p0, int n0,int n, char c),//delete n0 characters beginning with p0, and then insert n characters C at p0
String &replace (iterator first0, iterator last0,const char *s);//replace the section between [First0,last0] with the string s
String &replace (iterator first0, iterator last0,const char *s, int n);//replace the section between [First0,last0] with the first n characters of S
String &replace (iterator first0, iterator last0,const string &s);//replace the section between [First0,last0] with string s
String &replace (iterator first0, iterator last0,int N, char c);//replace the section between [First0,last0] with n characters c
String &replace (iterator first0, iterator Last0,const_iterator first, const_iterator last);//Put [First0, LAST0) between the parts replaced by [First,last] between the strings

Insert function for 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);
First 4 functions Insert the first n characters of the POS in the string s in the P0 position
String &insert (int p0, int n, char c);//This function inserts n characters c at p0
Iterator insert (iterator it, char c);//insert character C at it to return the position of the post-insertion iterator
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 c in it

Delete function for string class  
Iterator Erase (iterator first, iterator last);//delete [First, Last), returns the position of the post-delete iterator
Iterator erase (iterator it);//Remove the character that it points to, return the position of the post-delete iterator
string &erase (int pos = 0, int n = NPOs);//delete the n characters starting at POS and return the modified string

The iterator processing for the string class:   The
String class provides an iterator to the forward and backward traversal iterator, which provides syntax for accessing individual characters, similar to pointer operations, and iterators do not check scopes. The
declares an iterator variable with string::iterator or String::const_iterator, and Const_iterator does not allow the content of the iteration to be changed. Common iterator functions are:
Const_iterator begin () const;
Iterator begin ();               // Returns the starting position of string
Const_iterator end () const;
Iterator End ();                    //Returns the position after the last character of the 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 position of string before
Rbegin and rend are used to access from backward forward iterations by setting the iterator string::reverse_iterator,string: : Const_reverse_iterator implements

Conversion of C + + strings and C strings

C + + provides a way to get the corresponding c_string from a C + + string by using data (), C_str (), and copy (), where data () returns the string contents as an array of characters, but does not add '% '. C_STR () returns an array of characters ending with ' s ', while copy () copies or writes the contents of the string to an existing c_string or character array. The C + + string does not end with '/'. My advice is to use C + + strings in the program, unless you have to choose C_string.

Usage of C + + string