C++:std::string 的使用

已于 2023-07-27 11:24:08 修改
阅读量1.2k 收藏 2
点赞数 2
分类专栏： C++ 文章标签： c++ 开发语言 visualstudio
于 2023-07-27 10:58:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67505039/article/details/131954041
版权

目录

std::string

string概述

成员类型

成员函数

(constructor) 构造函数

(destructor) 析构函数

operator= 赋值

迭代器相关

容器大小或容量相关

成员访问相关

*添加、删除等修改相关操作*

字符串操作

成员常量

*重载的非成员函数*

std::string

namespace std{
    class string
    {
       public:
            string(const char*a){}
        
       private:
           char *str;
    }
}

string概述

typedef basic_string<char> string;

　　字符串是表示字符序列的对象。 　　

        标准string类使用类似于字节标准容器的接口提供对此类对象的支持，但是添加了专门用于操作单字节字符(single-byte characters)的字符串的特性。 　　

        string类是basic_string类模板的实例化，该模板使用char作为其字符类型，并具有默认的char_traits和allocator类型。 　　

        需要注意的是，这个类独立于所使用的编码来处理字节（即与编码无关）：如果用于处理多字节或可变长度字符(如UTF-8)的序列，那么这个类的所有成员(如长度或大小)及其迭代器仍将以字节(而不是实际编码的字符)进行操作。

成员类型

member typedefinition
value_typechar
traits_typechar_traits<char>
allocator_typeallocator<char>
referencechar&
const_referenceconst char&
pointerchar*
const_pointerconst char*
iteratora random access iterator to char (convertible to const_iterator)
const_iteratora random access iterator to const char
reverse_iteratorreverse_iterator<iterator>
const_reverse_iteratorreverse_iterator<const_iterator>
difference_typeptrdiff_t
size_typesize_t

成员函数

  • (constructor) 构造函数
default (1)string();
copy (2)string (const string& str);
substring (3)string (const string& str, size_t pos, size_t len = npos);
from c-string (4)string (const char* s);
from buffer (5)string (const char* s, size_t n);
fill (6)string (size_t n, char c);
range (7)template <class InputIterator> string (InputIterator first, InputIterator last);
initializer list (8)string (initializer_list<char> il);
move (9)string (string&& str) noexcept;
  • (destructor) 析构函数
    ~string();
  • operator= 赋值
string (1)string& operator= (const string& str);
c-string (2)string& operator= (const char* s);
character (3)string& operator= (char c);
initializer list (4)string& operator= (initializer_list<char> il);
move (5)string& operator= (string&& str) noexcept;
  • 迭代器相关
函数函数原型功能描述
beginiterator begin() noexcept;Return iterator to beginning
const_iterator begin() const noexcept;
enditerator end() noexcept;Return iterator to end
const_iterator end() const noexcept;
rbeginreverse_iterator rbegin() noexcept;Return reverse iterator to reverse beginning
const_reverse_iterator rbegin() const noexcept;
rendreverse_iterator rend() noexcept;Return reverse iterator to reverse end
const_reverse_iterator rend() const noexcept;
cbeginconst_iterator cbegin() const noexcept;Return const_iterator to beginning
cendconst_iterator cend() const noexcept;Return const_iterator to end
crbeginconst_reverse_iterator crbegin() const noexcept;Return const_reverse_iterator to reverse beginning
crendconst_reverse_iterator crend() const noexcept;Return const_reverse_iterator to reverse end

　迭代器示例：

// string::begin/end
#include <iostream>
#include <string>
​
int main ()
{
  std::string str ("Test string");
  for ( std::string::iterator it=str.begin(); it!=str.end(); ++it)
{
    std::cout << str;
  std::cout << '\n';
​}
  return 0;
}
​
Output:
Test string
  • 容器大小或容量相关
函数函数原型功能描述
sizesize_t size() const noexcept;Return length of string
lengthsize_t length() const noexcept;Return length of string
max_sizesize_t max_size() const noexcept;Return maximum size of string
resizevoid resize (size_t n);Resize string
void resize (size_t n, const value_type& val);
capacitysize_t capacity() const noexcept;Return size of allocated storage
reservevoid reserve (size_t n = 0);Request a change in capacity
clearvoid clear() noexcept;Clear string
emptybool empty() const noexcept;Test if string is empty
shrink_to_fitvoid shrink_to_fit();Shrink to fit

　　示例：

// resizing string
#include <iostream>
#include <string>
​
int main ()
{
  std::string str ("I like to code in C");
  std::cout << str << '\n';
​
  unsigned sz = str.size();
​
  str.resize (sz+2,'+');
  std::cout << str << '\n';
​
  str.resize (14);
  std::cout << str << '\n';
  return 0;
}
​
Output:
I like to code in C
I like to code in C++
I like to code
----------------------------------------------------------

// comparing size, length, capacity and max_size
#include <iostream>
#include <string>
​
int main ()
{
  std::string str ("Test string");
  std::cout << "size: " << str.size() << "\n";
  std::cout << "length: " << str.length() << "\n";
  std::cout << "capacity: " << str.capacity() << "\n";
  std::cout << "max_size: " << str.max_size() << "\n";
  return 0;
}
​
A possible output for this program could be:
size: 11
length: 11
capacity: 15
max_size: 429496729
  • 成员访问相关
函数函数原型功能描述
operator[]char& operator[] (size_t pos);获取字符串的字符
const char& operator[] (size_t pos) const;
atchar& at (size_t pos);获取字符串的字符
const char& at (size_t pos) const;
frontreference front();访问最后一个字符
const_reference front() const;
backchar& back();访问第一个字符
const char& back() const;

　　成员访问示例：

// string::operator[]
#include <iostream>
#include <string>
​using namespace std;

int main ()
{
  std::string str ("Test string");
  for (int i=0; i<str.length(); ++i)
  {
    cout << str[i]<<endl;
  }
  return 0;
}


Output:
Test string
------------------------------------------------------


// string::at
#include <iostream>
#include <string>
​​using namespace std;
int main ()
{
  std::string str ("Test string");
  for (unsigned i=0; i<str.length(); ++i)
  {
       cout << str.at(i)<<endl;
  }
  return 0;
}

Output:
Test string
------------------------------------------------------


// string::front
#include <iostream>
#include <string>
​
int main ()
{
  std::string str ("test string");
  str.front() = 'T';
  std::cout << str << '\n';
  return 0;
}
​
Output:
Test string
------------------------------------------------------


// string::back
#include <iostream>
#include <string>
​
int main ()
{
  std::string str ("hello world.");
  str.back() = '!';
  std::cout << str << '\n';
  return 0;
}
​
Output:
hello world!
 

  •  
    *添加、删除等修改相关操作*
     
 

函数函数原型功能描述
operator+=string& operator+= (const string& str);附加到字符串
string& operator+= (const char* s);
string& operator+= (char c);
string& operator+= (initializer_list<char> il);
appendstring& append (const string& str);附加到字符串
string& append (const string& str, size_t subpos, size_t sublen);
string& append (const char* s);
string& append (const char* s, size_t n);
string& append (size_t n, char c);
template <class InputIterator> string& append (InputIterator first, InputIterator last);
string& append (initializer_list<char> il);
push_backvoid push_back (char c);将字符追加到字符串
assignstring& assign (const string& str);将内容赋值给字符串
string& assign (const string& str, size_t subpos, size_t sublen);
string& assign (const char* s);
string& assign (const char* s, size_t n);
string& assign (size_t n, char c);
template <class InputIterator> string& assign (InputIterator first, InputIterator last);
string& assign (initializer_list<char> il);
string& assign (string&& str) noexcept;
insertstring& insert (size_t pos, const string& str);插入字符串
string& insert (size_t pos, const string& str, size_t subpos, size_t sublen);
string& insert (size_t pos, const char* s);
string& insert (size_t pos, const char* s, size_t n);
string& insert (size_t pos, size_t n, char c); iterator insert (const_iterator p, size_t n, char c);
iterator insert (const_iterator p, char c);
template <class InputIterator> iterator insert (iterator p, InputIterator first, InputIterator last);
string& insert (const_iterator p, initializer_list<char> il);
erasestring& erase (size_t pos = 0, size_t len = npos);删除字符串中的字符
iterator erase (const_iterator p);
iterator erase (const_iterator first, const_iterator last);
replacestring& replace (size_t pos, size_t len, const string& str); string& replace (const_iterator i1, const_iterator i2, const string& str);替换字符串的一部分
string& replace (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen);
string& replace (size_t pos, size_t len, const char* s); string& replace (const_iterator i1, const_iterator i2, const char* s);
string& replace (size_t pos, size_t len, const char* s, size_t n); string& replace (const_iterator i1, const_iterator i2, const char* s, size_t n);
string& replace (size_t pos, size_t len, size_t n, char c); string& replace (const_iterator i1, const_iterator i2, size_t n, char c);
template <class InputIterator> string& replace (const_iterator i1, const_iterator i2, InputIterator first, InputIterator last);
string& replace (const_iterator i1, const_iterator i2, initializer_list<char> il);
swapvoid swap (string& str);交换字符串值
pop_backvoid pop_back();删除最后一个字符
 

　　示例：
 

// string::operator+=
#include <iostream>
#include <string>
​
int main ()
{
  std::string name ("John");
  std::string family ("Smith");
  name += " K. ";         // c-string
  name += family;         // string
  name += '\n';           // character
​
  std::cout << name;
  return 0;
}
​
Output:
John K. Smith
 

------------------------------------------------------------


 

// appending to string
#include <iostream>
#include <string>
​
int main ()
{
  std::string str;
  std::string str2="Writing ";
  std::string str3="print 10 and then 5 more";
​
  // used in the same order as described above:
  str.append(str2);                       // "Writing "
  str.append(str3,6,3);                   // "10 "
  str.append("dots are cool",5);          // "dots "
  str.append("here: ");                   // "here: "
  str.append(10u,'.');                    // ".........."
  str.append(str3.begin()+8,str3.end());  // " and then 5 more"
  str.append<int>(5,0x2E);                // "....."
​
  std::cout << str << '\n';
  return 0;
}
​
Output:
Writing 10 dots here: .......... and then 5 more.....
 

------------------------------------------------------------


 

// string::push_back
#include <iostream>
#include <fstream>
#include <string>
​
int main ()
{
  std::string str;
  std::ifstream file ("test.txt",std::ios::in);
  if (file) {
    while (!file.eof()) str.push_back(file.get());
  }
  std::cout << str << '\n';
  return 0;
}
 

------------------------------------------------------------


 

// string::assign
#include <iostream>
#include <string>
​
int main ()
{
  std::string str;
  std::string base="The quick brown fox jumps over a lazy dog.";
​
  // used in the same order as described above:
​
  str.assign(base);
  std::cout << str << '\n';
​
  str.assign(base,10,9);
  std::cout << str << '\n';         // "brown fox"
​
  str.assign("pangrams are cool",7);
  std::cout << str << '\n';         // "pangram"
​
  str.assign("c-string");
  std::cout << str << '\n';         // "c-string"
​
  str.assign(10,'*');
  std::cout << str << '\n';         // "**********"
​
  str.assign<int>(10,0x2D);
  std::cout << str << '\n';         // "----------"
​
  str.assign(base.begin()+16,base.end()-12);
  std::cout << str << '\n';         // "fox jumps over"
​
  return 0;
}
​
Output:
The quick brown fox jumps over a lazy dog.
brown fox
pangram
c-string
**********
----------
fox jumps over
 

------------------------------------------------------------


 

// inserting into a string
#include <iostream>
#include <string>
​
int main ()
{
  std::string str="to be question";
  std::string str2="the ";
  std::string str3="or not to be";
  std::string::iterator it;
​
  // used in the same order as described above:
  str.insert(6,str2);                 // to be (the )question
  str.insert(6,str3,3,4);             // to be (not )the question
  str.insert(10,"that is cool",8);    // to be not (that is )the question
  str.insert(10,"to be ");            // to be not (to be )that is the question
  str.insert(15,1,':');               // to be not to be(:) that is the question
  it = str.insert(str.begin()+5,','); // to be(,) not to be: that is the question
  str.insert (str.end(),3,'.');       // to be, not to be: that is the question(...)
  str.insert (it+2,str3.begin(),str3.begin()+3); // (or )
​
  std::cout << str << '\n';
  return 0;
}
​
Output:
to be, or not to be: that is the question...
 

------------------------------------------------------------


 

// string::erase
#include <iostream>
#include <string>
​
int main ()
{
  std::string str ("This is an example sentence.");
  std::cout << str << '\n';
                                           // "This is an example sentence."
  str.erase (10,8);                        //            ^^^^^^^^
  std::cout << str << '\n';
                                           // "This is an sentence."
  str.erase (str.begin()+9);               //           ^
  std::cout << str << '\n';
                                           // "This is a sentence."
  str.erase (str.begin()+5, str.end()-9);  //       ^^^^^
  std::cout << str << '\n';
                                           // "This sentence."
  return 0;
}
​
Output:
This is an example sentence.
This is an sentence.
This is a sentence.
This sentence.
 

------------------------------------------------------------


 

// replacing in a string
#include <iostream>
#include <string>
​
int main ()
{
  std::string base="this is a test string.";
  std::string str2="n example";
  std::string str3="sample phrase";
  std::string str4="useful.";
​
  // replace signatures used in the same order as described above:
​
  // Using positions:                 0123456789*123456789*12345
  std::string str=base;           // "this is a test string."
  str.replace(9,5,str2);          // "this is an example string." (1)
  str.replace(19,6,str3,7,6);     // "this is an example phrase." (2)
  str.replace(8,10,"just a");     // "this is just a phrase."     (3)
  str.replace(8,6,"a shorty",7);  // "this is a short phrase."    (4)
  str.replace(22,1,3,'!');        // "this is a short phrase!!!"  (5)
​
  // Using iterators:                                               0123456789*123456789*
  str.replace(str.begin(),str.end()-3,str3);                    // "sample phrase!!!"      (1)
  str.replace(str.begin(),str.begin()+6,"replace");             // "replace phrase!!!"     (3)
  str.replace(str.begin()+8,str.begin()+14,"is coolness",7);    // "replace is cool!!!"    (4)
  str.replace(str.begin()+12,str.end()-4,4,'o');                // "replace is cooool!!!"  (5)
  str.replace(str.begin()+11,str.end(),str4.begin(),str4.end());// "replace is useful."    (6)
  std::cout << str << '\n';
  return 0;
}
​
Output:
replace is useful.
 

------------------------------------------------------------


 

// swap strings
#include <iostream>
#include <string>
​
main ()
{
  std::string buyer ("money");
  std::string seller ("goods");
​
  std::cout << "Before the swap, buyer has " << buyer;
  std::cout << " and seller has " << seller << '\n';
​
  seller.swap (buyer);
​
  std::cout << " After the swap, buyer has " << buyer;
  std::cout << " and seller has " << seller << '\n';
​
  return 0;
}
​
Output:
Before the swap, buyer has money and seller has goods
 After the swap, buyer has goods and seller has money
 

------------------------------------------------------------


 

// string::pop_back
#include <iostream>
#include <string>
​
int main ()
{
  std::string str ("hello world!");
  str.pop_back();
  std::cout << str << '\n';
  return 0;
}
​
Output:
hello world
 

 

  •  
    字符串操作
     
 

函数函数原型功能描述
c_strconst char* c_str() const noexcept;Get C string equivalent
dataconst char* data() const noexcept;Get string data
get_allocatorallocator_type get_allocator() const noexcept;Get allocator
copysize_t copy (char* s, size_t len, size_t pos = 0) const;Copy sequence of characters from string
findsize_t find (const string& str, size_t pos = 0) const noexcept;Find content in string
size_t find (const char* s, size_t pos = 0) const;
size_t find (const char* s, size_t pos, size_type n) const;
size_t find (char c, size_t pos = 0) const noexcept;
rfindsize_t rfind (const string& str, size_t pos = npos) const noexcept;Find last occurrence of content in string
size_t rfind (const char* s, size_t pos = npos) const;
size_t rfind (const char* s, size_t pos, size_t n) const;
size_t rfind (char c, size_t pos = npos) const noexcept;
find_first_ofsize_t find_first_of (const string& str, size_t pos = 0) const noexcept;Find character in string. Searches the string for the first character that matches any of the characters specified in its arguments.
size_t find_first_of (const char* s, size_t pos = 0) const;
size_t find_first_of (const char* s, size_t pos, size_t n) const;
size_t find_first_of (char c, size_t pos = 0) const noexcept;
find_last_ofsize_t find_last_of (const string& str, size_t pos = npos) const noexcept;Find character in string from the end. Searches the string for the last character that matches any of the characters specified in its arguments.
size_t find_last_of (const char* s, size_t pos = npos) const;
size_t find_last_of (const char* s, size_t pos, size_t n) const;
size_t find_last_of (char c, size_t pos = npos) const noexcept;
find_first_not_ofsize_t find_first_not_of (const string& str, size_t pos = 0) const noexcept;Find absence of character in string. Searches the string for the first character that does not match any of the characters specified in its arguments.
size_t find_first_not_of (const char* s, size_t pos = 0) const;
size_t find_first_not_of (const char* s, size_t pos, size_t n) const;
size_t find_first_not_of (char c, size_t pos = 0) const noexcept;
find_last_not_ofsize_t find_last_not_of (const string& str, size_t pos = npos) const noexcept;Find non-matching character in string from the end. Searches the string for the last character that does not match any of the characters specified in its arguments.
size_t find_last_not_of (const char* s, size_t pos = npos) const;
size_t find_last_not_of (const char* s, size_t pos, size_t n) const;
size_t find_last_not_of (char c, size_t pos = npos) const noexcept;
substrstring substr (size_t pos = 0, size_t len = npos) const;Generate substring
compareint compare (const string& str) const noexcept;Compare strings
int compare (size_t pos, size_t len, const string& str) const; int compare (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) const;
int compare (size_t pos, size_t len, const string& str) const; int compare (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) const;
int compare (size_t pos, size_t len, const char* s, size_t n) const;
 

 

成员常量
 

nposstatic const size_t npos = -1;Maximum value for size_t
 

　　当用作string成员函数中len(或sublen)参数的值时，其表示“直到字符串结束”。而作为返回值时，它通常用于表示不匹配。
 

 

*重载的非成员函数*
 

函数函数原型功能描述
operator+string operator+ (const string& lhs, const string& rhs);Concatenate strings
string operator+ (string&& lhs, string&& rhs);
string operator+ (string&& lhs, const string& rhs);
string operator+ (const string& lhs, string&& rhs);
string operator+ (const string& lhs, const char* rhs);
string operator+ (string&& lhs, const char* rhs);
string operator+ (const char* lhs, const string& rhs);
string operator+ (const char* lhs, string&& rhs);
string operator+ (const string& lhs, char rhs);
string operator+ (string&& lhs, char rhs);
string operator+ (char lhs, const string& rhs);
string operator+ (char lhs, string&& rhs);
relational operatorsbool operator== (const string& lhs, const string& rhs);Relational operators for string
bool operator== (const char* lhs, const string& rhs);
bool operator== (const string& lhs, const char* rhs);
bool operator!= (const string& lhs, const string& rhs);
bool operator!= (const char* lhs, const string& rhs);
bool operator!= (const string& lhs, const char* rhs);
bool operator< (const string& lhs, const string& rhs);
bool operator< (const char* lhs, const string& rhs);
bool operator< (const string& lhs, const char* rhs);
bool operator<= (const string& lhs, const string& rhs);
bool operator<= (const char* lhs, const string& rhs);
bool operator<= (const string& lhs, const char* rhs);
bool operator> (const string& lhs, const string& rhs);
bool operator> (const char* lhs, const string& rhs);
bool operator> (const string& lhs, const char* rhs);
bool operator>= (const string& lhs, const string& rhs);
bool operator>= (const char* lhs, const string& rhs);
bool operator>= (const string& lhs, const char* rhs);
swapvoid swap (string& x, string& y);Exchanges the values of two strings
operator>>istream& operator>> (istream& is, string& str);Extract string from stream
operator<<ostream& operator<< (ostream& os, const string& str);Insert string into stream
getlineistream& getline (istream& is, string& str, char delim);Get line from stream into string
istream& getline (istream&& is, string& str, char delim);
istream& getline (istream& is, string& str);
istream& getline (istream&& is, string& str);
 

 

注：std::string功能还不是很完善，有些常用方法（比如：去除字符串首尾空字符等功能）还是没有，使用起来不是很方便，这个时候可以选择使用boost中的相应函数。

                

        

        

    




    

      

        

            

              
                
                  摸鱼特长生.
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    2
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
                
  • 
                  
                    打赏
                    
                  
                  
    打赏
    
                
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
C++ 中 string 用法详解

				
			

			

				

					一丁的博客
				

				

					05-15
					
					1809
					
				

			

		

		

			
				
一、字符串及区别

（1）字符串

字符串是表示字符序列的对象。标准字符串类（string）通过类似于标准字节容器的接口为这些对象提供支持，但添加了专门设计用于使用单字节字符串操作的功能。

该字符串类（string）是一个实例的basic_string类模板使用字符（即字节）作为其类型，其默认char_traits和分配器类型（见basic_string的更多信息的模板）。

请注意，此类（st...

			
		

	



                

              
                



	

		

			

				
					
利用C++实现从std::string类型到bool型的转换

				
			

			

				

					01-20
				

			

		

		

			
				
例如，`std::string::compare`用于比较字符串，`std::string::find`用于查找子串，还有`std::string::substr`用于提取子字符串。此外，`std::string`还提供了与C风格字符串交互的成员函数，如`c_str()`，它可以返回...

			
		

	



                


  
              

                


	

		

			

				
					
C++中的std::string类中常用的成员方法详解

				
			

			

				

					qq_43630324的博客
				

				

					07-28
					
					1081
					
				

			

		

		

			
				
C++std::string类中常用的成员方法详解。

			
		

	





	

		

			

				
					
std::string详解

					
热门推荐

				
			

			

				

					wuguangbin1230的博客
				

				

					08-08
					
					5万+
					
				

			

		

		

			
				
之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必 担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。


标准模板库（STL）提供了一个std::strin

			
		

	



		

			
		



	

		

			

				
					
【STL专题】深入探索C++之std::string：不止于字符串【万字详解】

					
最新发布

				
			

			

				

					sobercq的博客
				

				

					05-24
					
					2288
					
				

			

		

		

			
				
1.string是表示字符串的字符串类2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。3.string在底层实际是：basic_string模板类的别名，typedef basic_string string;4. 不能操作多字节或者变长字符的序列。⚠⚠ 在使用string类时，必须包含#include头文件以及;

			
		

	





	

		

			

				
					
C++ STL --- string类用法

				
			

			

				

					weixin_57761086的博客
				

				

					08-26
					
					1161
					
				

			

		

		

			
				
C++STL初阶应用，string类应用，掌握类中最常用的函数，使用大量代码让读者快速理解各个函数的使用方法。同时验证了reserve函数的性质。

			
		

	





	

		

			

				
					
std::string类简介

				
			

			

				

					cherish_2012的专栏
				

				

					06-13
					
					533
					
				

			

		

		

			
				
字符串存取

    有4种方法可以访问各个字符，其中两种方法使用[]操作符，另外两种方法使用at()方法:

 

reference operator[] (size_type pos);
const_reference operator[] (size_type pos) const;
reference at (size_type n);
const_reference 

			
		

	





	

		

			

				
					
C++ STL std::string详细讲解

				
			

			

				

					01-19
				

			

		

		

			
				
= std::string::npos) {  str.replace(pos, from.size(), to);  pos += to.size();  }  }  ```   9. **注意事项**：  - `data()`函数返回的指针不以'0'结束，不能直接作为C风格字符串处理，否则可能导致未定义行为。...

			
		

	





	

		

			

				
					
C ++：将MFC CString转换为std :: string

				
			

			

				

					04-06
				

			

		

		

			
				
在UNICODE中：CString str = L“ Test”; std :: wstring ws（str）; std :: string s; s.assign（ws.begin（），ws.end（））;

			
		

	





	

		

			

				
					
c++11 std::move() 的使用

				
			

			

				

					01-07
				

			

		

		

			
				
std::move函数可以以非常简单的方式将左值引用转换为右值引用。...通过std::move，可以避免不必要的拷贝操作。 std::move是为性能而生。 std::move是将对象的状态或者所有权从一个对象转移到另一个...	std::string str =

			
		

	





	

		

			

				
					
C/C++中关于std::string的compare陷阱示例详解

				
			

			

				

					08-28
				

			

		

		

			
				
然而，`std::string::compare`方法与C语言中的`strcmp`函数并不完全相同。`compare`方法会比较两个`std::string`对象在`size()`长度内的所有字节，即使其中包含`\0`（空字符）。这意味着，如果在`std::string`中存在...

			
		

	





	

		

			

				
					
带你玩转std::string类(四)、迭代器

				
			

			

				

					学无止尽，谨言慎行！
				

				

					04-18
					
					1348
					
				

			

		

		

			
				
文章目录成员begin 参数 返回值 例子迭代器有效性数据竞争异常安全end 参数 返回值 例子迭代器有效性数据竞争异常安全rbegin 参数 返回值 例子迭代器有效性数据竞争异常安全rend 参数 返回值 例子迭代器有效性异常安全cbegin 参数 返回值 例子迭代器有效性数据竞争异常安全cend 参数 返回值 例子迭代器有效性数据竞争异常安全crbegin 参数 返回值 例子迭代器有效性数据竞争异常安全crend 参数 返回值 例子迭代器有效性数据竞争异常安全
成员




成员
返回值




beg

			
		

	





	

		

			

				
					
【C++】STL之string类（1）

				
			

			

				

					m0_74352571的博客
				

				

					06-12
					
					965
					
				

			

		

		

			
				
STL之string类中常见的接口函数（超详细）。

			
		

	





	

		

			

				
					
std的使用

				
			

			

				

					qq_37026934的博客
				

				

					04-23
					
					3586
					
				

			

		

		

			
				
前言
STL全称Standard Template Library，就是标准模板库，意思就是一群非常牛批的人实现的各种算法，数据结构的库被当成标准模板给你直接使用，他位于std这个namespace中 ，我们这里还要介绍一个东西叫做迭代器(iterator),迭代器是一个数据类型，其可以表示容器内所有元素的值，也支持做自增等操作，相当于容器和操作容器算法之间的中介1,这个容器也是非常抽象的std数据结构对象，假如我们要迭代每一个数据结构就需要实现不同的数据类型进行迭代，但是有了迭代器就不用了
List
这里

			
		

	





	

		

			

				
					
【C++】STL——string的简单介绍、string类的访问和遍历、operator[] 、begin+ end begin 、rbegin + rend begin 、范围for

				
			

			

				

					Crocodile1006的博客
				

				

					07-08
					
					1402
					
				

			

		

		

			
				
STL、string类、string类的简单介绍、string类对象的访问及遍历操作、operator[]、begin+ end begin、rbegin + rend begin、范围for

			
		

	





	

		

			

				
					
【C++】STL — string的使用 + 模拟实现

				
			

			

				

					上上谦. 的博客
				

				

					09-02
					
					1105
					
				

			

		

		

			
				
STL是（standard template libaray-标准模板库）的首字母缩写，是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。成员函数中层层调用、相互复用，封装在一个类当中，极大地考察了我们之前学的类和对象和C++各种语法，需要大家细心 + 谨慎。但行好事莫问前程，欲戴皇冠必承其重，我们在路上，努力且不放弃……

			
		

	





	

		

			

				
					
C++ std::string用法总结

				
			

			

				

					Gabriel的专栏
				

				

					08-17
					
					2万+
					
				

			

		

		

			
				
转自：http://blog.csdn.net/lanyzh0909/article/details/6957649

			
		

	





	

		

			

				
					
std string 的常用使用

				
			

			

				

					weixin_30735745的博客
				

				

					01-02
					
					99
					
				

			

		

		

			
				
用 string来代替char * 数组，使用sort排序算法来排序，用unique 函数来去重
1、Define
 string s1 = "hello";
 string s2 = "world";
 string s3 = s1 + "," + s2 +"!\n";
2、append
 s1 += ",shanshan\n"...

			
		

	





	

		

			

				
					
C++ std::string

				
			

			

				

					08-25
				

			

		

		

			
				
 std::string::iterator newend = std::remove_if(name.begin(), name.end(), iswhitespace);   此处的iswhitespace是一个判断字符是否为空格的谓词函数。  总结起来，C++的std::string类提供了多种初始化方式、字符...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
摸鱼特长生.

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值