Actual combat the substitution, lookup (some path-related operations) of string series--string in C + +

Source: Internet
Author: User

Continue writing some string operations today.
String gives us a lot of ways, but every time we use it, it's going to be a bit of a hassle.

Scenario 1:
Get a std::string Full_path = "D:\program files\csdn", but I want to get the "D:\program Files\vagaa" this path.
This will require the substitution of the string

std::string"D:\\program files\\csdn"const size_t last_slash_idx1 = full_path .find_last_of("\\/");if (std::string::npos != last_slash_idx1){    std::string::npos);}std::string"\\vagaa";

This uses the * find_last_of* method of the string and uses the erase method to delete it.

Scenario 2:
Get a std::string Full_image_path = "D:\program files\csdn\vagaa.png", but I want to get the file extension based on this path.
We can do this using the Find_last_of+erase method, and we can do this:

std:"D:\\program files\\csdn\\vagaa.png"std::string file_extension_name;.rfind(‘.‘, file_path.length());if (i != string::npos) {    .substr1.length() - i);}

The RFind method and the substr method of string are used at this time.

Scenario 3

===============================================================
Basic knowledge:
From blog http://www.cnblogs.com/xFreedom/archive/2011/05/16/2048037.html

constructor of the string class:
String (const char *s); Initialize with C string s
string (int N,char c); Initialize with n characters c
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);//Assign a value of
string &assign (const char *s,int N) with the C string s, and//n-character assigned value starting with C strings 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),//the string s in the n characters from start assigned to the current string
string &assign (Const_iterator first,const_ Itertor last);//assigns the part between first and last iterators to the 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); Same as operator+= ()
String &append (const string &s,int pos,int N);//n characters starting from Pos in a string connect prompt 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);// Connects 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;
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 [First0,last0] part with 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 [first0,last0] between parts 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 all characters between [First,last] and return the position of the post-delete iterator
Iterator Erase (iterator it);//Remove the character that it points to, and return the location 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

iterator processing of the string class:
The string class provides a forward and backward traversal of the iterator iterator, which provides the syntax for accessing individual characters, similar to a pointer operation, where the iterator does not check the scope.
The iterator variable is declared 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 a string
Const_iterator end () const;
Iterator End (); Returns the position after the last character of a string
Const_iterator rbegin () const;
Iterator Rbegin (); Returns the position of the last character of a string
Const_iterator rend () const;
Iterator rend (); Returns the front of the first character position of a string
Rbegin and rend are used for iterative access from backward forward, by setting the iterator String::reverse_iterator,string::const_reverse_iterator implementation

Actual combat the substitution, lookup (some path-related operations) of string series--string in C + +

Related Article

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.