STL-string-2

已于 2023-06-07 16:32:02 修改
阅读量710 收藏 1
点赞数
分类专栏： STL 文章标签： c++ 开发语言
于 2023-06-05 14:50:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013049912/article/details/131046644
版权

Iterators

 Capacity

resize

void resize (size_t n);void resize (size_t n, char c);

Resize string

将字符串的大小调整为n个字符的长度。 如果n小于当前字符串长度，则当前值将缩短为其第一个n字符，删除第n个字符之后的字符。 如果n大于当前字符串长度，则通过在末尾插入所需数量的字符以达到n的大小来扩展当前内容。如果指定了c，则将新元素初始化为c的副本，否则，它们是值初始化字符（null字符）。

reserve

void reserve (size_t n = 0);

Request a change in capacity

请求字符串容量适应计划中的大小更改，最大长度为n个字符。 如果n大于当前字符串容量，则函数会使容器的容量增加到n个字符（或更多）。 在所有其他情况下，它被视为收缩字符串容量的非绑定请求：容器实现可以自由地进行其他优化，并使字符串的容量大于n。 此函数对字符串长度没有影响，也不能更改其内容。

shrink_to_fit

void shrink_to_fit();

Shrink to fit

请求字符串减小其容量以适应其大小。 该请求是非绑定的，容器实现可以自由地进行其他优化，并使字符串的容量大于其大小。 此函数对字符串长度没有影响，也不能更改其内容。

Element access

 Modifiers

 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);

附加到字符串 通过在字符串当前值的末尾附加附加字符来扩展字符串：

// 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

append

string (1) 
string& append (const string& str);
substring (2) 
string& append (const string& str, size_t subpos, size_t sublen = npos);
c-string (3) 
string& append (const char* s);
buffer (4) 
string& append (const char* s, size_t n);
fill (5) 
string& append (size_t n, char c);
range (6) 
template <class InputIterator>   string& append (InputIterator first, InputIterator last);
initializer list(7) 
string& append (initializer_list<char> il);

附加到字符串

通过在字符串当前值的末尾附加附加字符来扩展字符串：

（1） string

附加str的副本。

（2）  substring

附加str的子字符串的副本。子字符串是str的一部分，从字符位置subbase开始，跨越子字符串（或者直到str的末尾，如果str太短或子字符串为string:：npos）。

（3）  c-string

附加由s指向的以null结尾的字符序列（C字符串）形成的字符串的副本。

（4） buffer

追加s指向的字符数组中前n个字符的副本。

（5） fill

追加字符c的n个连续副本。

（6） range

以相同的顺序追加范围[第一个，最后一个）中的字符序列的副本。

（7）  initializer list

以相同的顺序追加il中每个字符的副本。

// 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.....

push_back

void push_back (char c);

将字符附加到字符串 将字符c追加到字符串的末尾，使其长度增加一。

// 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;
}This example reads an entire file character by character, appending each character to a string object using push_back.

assign

string (1) 
string& assign (const string& str);
substring (2) 
string& assign (const string& str, size_t subpos, size_t sublen = npos);
c-string (3) 
string& assign (const char* s);
buffer (4) 
string& assign (const char* s, size_t n);
fill (5) 
string& assign (size_t n, char c);
range (6) 
template <class InputIterator>   string& assign (InputIterator first, InputIterator last);
initializer list(7) 
string& assign (initializer_list<char> il);
move (8) 
string& assign (string&& str) noexcept;

将内容分配给字符串

为字符串指定一个新值，替换其当前内容。

（1） string

复制str。

（2）  substring

复制str中从字符位置子组开始并跨越子组字符的部分（如果str太短或子组为string:：npos，则复制到str的末尾）。

（3） c-string

复制s指向的以null结尾的字符序列（C字符串）。

（4） buffer

从s指向的字符数组中复制前n个字符。

（5） fill

用字符c的n个连续副本替换当前值。

（6） range

按相同顺序复制范围[第一个，最后一个）中的字符序列。

（7） initializer list

按照相同的顺序复制il中的每个字符。

（8）  move

获取str的内容。 str处于未指定但有效的状态。

// 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

insert

string (1) 
 string& insert (size_t pos, const string& str);
substring (2) 
 string& insert (size_t pos, const string& str, size_t subpos, size_t sublen = npos);
c-string (3) 
 string& insert (size_t pos, const char* s);
buffer (4) 
 string& insert (size_t pos, const char* s, size_t n);
fill (5) 
 string& insert (size_t pos,   size_t n, char c);iterator insert (const_iterator p, size_t n, char c);
single character (6) 
iterator insert (const_iterator p, char c);
range (7) 
template <class InputIterator>iterator insert (iterator p, InputIterator first, InputIterator last);
initializer list (8) 
 string& insert (const_iterator p, initializer_list<char> il);

插入字符串

在由pos（或p）表示的字符之前的字符串中插入其他字符：

（1）string

插入str的副本。

（2）substring

插入str的子字符串的副本。该子字符串是str的一部分，该部分从字符位置subbase开始，跨越子字符串字符（或者直到str的末尾，如果str太短或子字符串为npos）。

（3）c-string

插入由s指向的以null结尾的字符序列（C字符串）形成的字符串的副本。

（4）buffer

在由s指向的字符数组中插入前n个字符的副本。

（5）fill

插入字符c的n个连续副本。

（6）single character

插入字符c。

（7）range

以相同的顺序插入范围[第一个，最后一个）中的字符序列的副本。

（8）initializer list

按照相同的顺序插入il中每个字符的副本。 size_t是一个无符号整数类型（与成员类型string:：size_type相同）。

// 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...

erase

sequence (1) 
 string& erase (size_t pos = 0, size_t len = npos);
character (2) 
iterator erase (const_iterator p);
range (3) 
iterator erase (const_iterator first, const_iterator last);

删除字符串中的字符

擦除字符串的一部分，缩短其长度：

（1）sequence

删除字符串值中从字符位置pos开始并跨越len个字符的部分（或者，如果内容太短或len为string:：npos，则直到字符串结束）。 请注意，默认参数会擦除字符串中的所有字符（类似于成员函数clear）。

（2）character

删除p所指的字符。

（3）range

删除范围[第一个，最后一个]中的字符序列。

// 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.

replace

string (1) 
string& replace (size_t pos,        size_t len,        const string& str);string& replace (const_iterator i1, const_iterator i2, const string& str);
substring (2) 
string& replace (size_t pos,        size_t len,        const string& str,                 size_t subpos, size_t sublen = npos);
c-string (3) 
string& replace (size_t pos,        size_t len,        const char* s);string& replace (const_iterator i1, const_iterator i2, const char* s);
buffer (4) 
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);
fill (5) 
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);
range (6) 
template <class InputIterator>  string& replace (const_iterator i1, const_iterator i2,                   InputIterator first, InputIterator last);
initializer list (7) 
string& replace (const_iterator i1, const_iterator i2, initializer_list<char> il);

替换字符串的一部分

将字符串中从字符pos开始并跨越len个字符的部分（或[i1，i2）之间范围内的部分）替换为新内容：

（1）string

复制str。

（2）substring

复制str中从字符位置子组开始并跨越子组字符的部分（如果str太短或子组为string:：npos，则复制到str的末尾）。

（3）c-string

复制s指向的以null结尾的字符序列（C字符串）。

（4）buffer

从s指向的字符数组中复制前n个字符。

（5）fill

用字符c的n个连续副本替换字符串的部分。

（6）range

按相同顺序复制范围[第一个，最后一个）中的字符序列。

（7）initializer list

按照相同的顺序复制il中的每个字符。

// 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

void swap (string& str);

交换字符串值

通过str的内容交换容器的内容，str是另一个字符串对象。长度可能不同。 在调用该成员函数之后，该对象的值是str在调用之前的值，str的值是该对象在调用之前具有的值。 请注意，存在一个具有相同名称的非成员函数，即swap，用类似于该成员函数的优化重载该算法。

// 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

pop_back

void pop_back();

删除最后一个字符 擦除字符串的最后一个字符，有效地将其长度减少一个。

// string::pop_back
#include <iostream>
#include <string>

int main ()
{
  std::string str ("hello world!");
  str.pop_back();
  std::cout << str << '\n';
  return 0;
}hello world

String operations

c_str

const char* c_str() const noexcept;

 获取等效的C字符串

返回一个指向数组的指针，该数组包含一个以null结尾的字符序列（即C字符串），表示字符串对象的当前值。 此数组包含组成字符串对象值的相同字符序列，加上末尾的附加终止null字符（“\0”）。

// strings and c-strings
#include <iostream>
#include <cstring>
#include <string>

int main ()
{
  std::string str ("Please split this sentence into tokens");

  char * cstr = new char [str.length()+1];
  std::strcpy (cstr, str.c_str());

  // cstr now contains a c-string copy of str

  char * p = std::strtok (cstr," ");
  while (p!=0)
  {
    std::cout << p << '\n';
    p = std::strtok(NULL," ");
  }

  delete[] cstr;
  return 0;
}Output:

Please
split
this
sentence
into
tokens

data

const char* data() const noexcept;

Get string data

返回一个指向数组的指针，该数组包含一个以null结尾的字符序列（即C字符串），表示字符串对象的当前值。 此数组包含组成字符串对象值的相同字符序列，加上末尾的附加终止null字符（“\0”）。 指针返回指向字符串对象当前用于存储符合其值的字符的内部数组。 字符串：：data和字符串：：c_str都是同义词，返回相同的值。

// string::data
#include <iostream>
#include <string>
#include <cstring>

int main ()
{
  int length;

  std::string str = "Test string";
  char* cstr = "Test string";

  if ( str.length() == std::strlen(cstr) )
  {
    std::cout << "str and cstr have the same length.\n";

    if ( memcmp (cstr, str.data(), str.length() ) == 0 )
      std::cout << "str and cstr have the same content.\n";
  }
  return 0;
}Output:

str and cstr have the same length.
str and cstr have the same content.

get_allocator

allocator_type get_allocator() const noexcept;

获取分配器

返回与字符串关联的分配器对象的副本。 string使用默认的分配器＜char＞类型，该类型没有状态（因此，返回的值与默认构造的分配器相同）。

copy

size_t copy (char* s, size_t len, size_t pos = 0) const;

从字符串中复制字符序列

将字符串对象的当前值的子字符串复制到s指向的数组中。该子字符串包含从位置pos开始的len字符。 函数不会在复制内容的末尾附加null字符。

// string::copy
#include <iostream>
#include <string>

int main ()
{
  char buffer[20];
  std::string str ("Test string...");
  std::size_t length = str.copy(buffer,6,5);
  buffer[length]='\0';
  std::cout << "buffer contains: " << buffer << '\n';
  return 0;
}Output:

buffer contains: string

find

string (1) 
size_t find (const string& str, size_t pos = 0) const noexcept;
c-string (2) 
size_t find (const char* s, size_t pos = 0) const;
buffer (3) 
size_t find (const char* s, size_t pos, size_type n) const;
character (4) 
size_t find (char c, size_t pos = 0) const noexcept;

在字符串中查找内容

在字符串中搜索由其参数指定的序列的第一个匹配项。 指定pos时，搜索仅包括位置pos处或之后的字符，忽略任何可能出现的位置pos之前的字符。 请注意，与成员find_first_of不同，无论何时搜索多个字符，仅匹配其中一个字符是不够的，但必须匹配整个序列。

// string::find
#include <iostream>       // std::cout
#include <string>         // std::string

int main ()
{
  std::string str ("There are two needles in this haystack with needles.");
  std::string str2 ("needle");

  // different member versions of find in the same order as above:
  std::size_t found = str.find(str2);
  if (found!=std::string::npos)
    std::cout << "first 'needle' found at: " << found << '\n';

  found=str.find("needles are small",found+1,6);
  if (found!=std::string::npos)
    std::cout << "second 'needle' found at: " << found << '\n';

  found=str.find("haystack");
  if (found!=std::string::npos)
    std::cout << "'haystack' also found at: " << found << '\n';

  found=str.find('.');
  if (found!=std::string::npos)
    std::cout << "Period found at: " << found << '\n';

  // let's replace the first needle:
  str.replace(str.find(str2),str2.length(),"preposition");
  std::cout << str << '\n';

  return 0;
}Notice how parameter pos is used to search for a second instance of the same search string. Output:

first 'needle' found at: 14
second 'needle' found at: 44
'haystack' also found at: 30
Period found at: 51
There are two prepositions in this haystack with needles.

rfind

string (1) 
size_t rfind (const string& str, size_t pos = npos) const noexcept;
c-string (2) 
size_t rfind (const char* s, size_t pos = npos) const;
buffer (3) 
size_t rfind (const char* s, size_t pos, size_t n) const;
character (4) 
size_t rfind (char c, size_t pos = npos) const noexcept;

查找字符串中最后一次出现的内容

在字符串中搜索由其参数指定的序列的最后一次出现。 指定pos时，搜索仅包括从位置pos开始或在位置pos之前的字符序列，忽略从pos之后开始的任何可能的匹配。

// string::rfind
#include <iostream>
#include <string>
#include <cstddef>

int main ()
{
  std::string str ("The sixth sick sheik's sixth sheep's sick.");
  std::string key ("sixth");

  std::size_t found = str.rfind(key);
  if (found!=std::string::npos)
    str.replace (found,key.length(),"seventh");

  std::cout << str << '\n';

  return 0;
}The sixth sick sheik's seventh sheep's sick.

find_first_of

string (1) 
size_t find_first_of (const string& str, size_t pos = 0) const noexcept;
c-string (2) 
size_t find_first_of (const char* s, size_t pos = 0) const;
buffer (3) 
size_t find_first_of (const char* s, size_t pos, size_t n) const;
character (4) 
size_t find_first_of (char c, size_t pos = 0) const noexcept;

查找字符串中的字符

在字符串中搜索与其参数中指定的任何字符匹配的第一个字符。 指定位置时，搜索仅包括位置位置处或位置之后的字符，忽略位置之前可能出现的任何字符。 请注意，序列中的一个字符（不是所有字符）匹配就足够了。请参阅string:：find以获取与整个序列匹配的函数。

// string::find_first_of
#include <iostream>       // std::cout
#include <string>         // std::string
#include <cstddef>        // std::size_t

int main ()
{
  std::string str ("Please, replace the vowels in this sentence by asterisks.");
  std::size_t found = str.find_first_of("aeiou");
  while (found!=std::string::npos)
  {
    str[found]='*';
    found=str.find_first_of("aeiou",found+1);
  }

  std::cout << str << '\n';

  return 0;
}Pl**s*, r*pl*c* th* v*w*ls *n th*s s*nt*nc* by *st*r*sks.

find_last_of

string (1) 
size_t find_last_of (const string& str, size_t pos = npos) const noexcept;
c-string (2) 
size_t find_last_of (const char* s, size_t pos = npos) const;
buffer (3) 
size_t find_last_of (const char* s, size_t pos, size_t n) const;
character (4) 
size_t find_last_of (char c, size_t pos = npos) const noexcept;

从字符串末尾查找字符

在字符串中搜索与其参数中指定的任何字符匹配的最后一个字符。 指定位置时，搜索仅包括位置位置处或位置之前的字符，忽略位置之后可能出现的任何字符。

// string::find_last_of
#include <iostream>       // std::cout
#include <string>         // std::string
#include <cstddef>         // std::size_t

void SplitFilename (const std::string& str)
{
  std::cout << "Splitting: " << str << '\n';
  std::size_t found = str.find_last_of("/\\");
  std::cout << " path: " << str.substr(0,found) << '\n';
  std::cout << " file: " << str.substr(found+1) << '\n';
}

int main ()
{
  std::string str1 ("/usr/bin/man");
  std::string str2 ("c:\\windows\\winhelp.exe");

  SplitFilename (str1);
  SplitFilename (str2);

  return 0;
}
Splitting: /usr/bin/man
 path: /usr/bin
 file: man
Splitting: c:\windows\winhelp.exe
 path: c:\windows
 file: winhelp.exe

find_first_not_of

string (1) 
size_t find_first_not_of (const string& str, size_t pos = 0) const noexcept;
c-string (2) 
size_t find_first_not_of (const char* s, size_t pos = 0) const;
buffer (3) 
size_t find_first_not_of (const char* s, size_t pos, size_t n) const;
character (4) 
size_t find_first_not_of (char c, size_t pos = 0) const noexcept;

查找字符串中缺少字符

在字符串中搜索与参数中指定的任何字符都不匹配的第一个字符。 当指定了pos时，搜索只包括位置pos处或之后的字符，忽略该字符之前可能出现的任何字符。

// string::find_first_not_of
#include <iostream>       // std::cout
#include <string>         // std::string
#include <cstddef>        // std::size_t

int main ()
{
  std::string str ("look for non-alphabetic characters...");

  std::size_t found = str.find_first_not_of("abcdefghijklmnopqrstuvwxyz ");

  if (found!=std::string::npos)
  {
    std::cout << "The first non-alphabetic character is " << str[found];
    std::cout << " at position " << found << '\n';
  }

  return 0;
}The first non-alphabetic character is - at position 12

find_last_not_of

string (1) 
size_t find_last_not_of (const string& str, size_t pos = npos) const noexcept;
c-string (2) 
size_t find_last_not_of (const char* s, size_t pos = npos) const;
buffer (3) 
size_t find_last_not_of (const char* s, size_t pos, size_t n) const;
character (4) 
size_t find_last_not_of (char c, size_t pos = npos) const noexcept;

从末尾开始查找字符串中不匹配的字符

在字符串中搜索与参数中指定的任何字符都不匹配的最后一个字符。 指定位置时，搜索仅包括位置位置处或位置之前的字符，忽略位置之后可能出现的任何字符。

// string::find_last_not_of
#include <iostream>       // std::cout
#include <string>         // std::string
#include <cstddef>        // std::size_t

int main ()
{
  std::string str ("Please, erase trailing white-spaces   \n");
  std::string whitespaces (" \t\f\v\n\r");

  std::size_t found = str.find_last_not_of(whitespaces);
  if (found!=std::string::npos)
    str.erase(found+1);
  else
    str.clear();            // str is all whitespace

  std::cout << '[' << str << "]\n";

  return 0;
}[Please, erase trailing white-spaces]

substr

string substr (size_t pos = 0, size_t len = npos) const;

生成子字符串

返回一个新构造的字符串对象，该对象的值初始化为此对象的子字符串的副本。 子字符串是对象中从字符位置pos开始并跨越len个字符（或直到字符串结束，以先到者为准）的部分。

// string::substr
#include <iostream>
#include <string>

int main ()
{
  std::string str="We think in generalities, but we live in details.";
                                           // (quoting Alfred N. Whitehead)

  std::string str2 = str.substr (3,5);     // "think"

  std::size_t pos = str.find("live");      // position of "live" in str

  std::string str3 = str.substr (pos);     // get from "live" to the end

  std::cout << str2 << ' ' << str3 << '\n';

  return 0;
}
Output:

think live in details.

compare

string (1) 
int compare (const string& str) const noexcept;
substrings (2) 
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 = npos) const;
c-string (3) 
int compare (const char* s) const;int compare (size_t pos, size_t len, const char* s) const;
buffer (4) 
int compare (size_t pos, size_t len, const char* s, size_t n) const;

比较字符串

将字符串对象（或子字符串）的值与其参数指定的字符序列进行比较。 比较的字符串是字符串对象的值，或者如果使用的签名有pos和len参数，则是从位置pos的字符开始并跨越len个字符的子字符串。 将此字符串与比较字符串进行比较，比较字符串由传递给函数的其他参数决定。

// comparing apples with apples
#include <iostream>
#include <string>

int main ()
{
  std::string str1 ("green apple");
  std::string str2 ("red apple");

  if (str1.compare(str2) != 0)
    std::cout << str1 << " is not " << str2 << '\n';

  if (str1.compare(6,5,"apple") == 0)
    std::cout << "still, " << str1 << " is an apple\n";

  if (str2.compare(str2.size()-5,5,"apple") == 0)
    std::cout << "and " << str2 << " is also an apple\n";

  if (str1.compare(6,5,str2,4,5) == 0)
    std::cout << "therefore, both are apples\n";

  return 0;
}Output:

green apple is not red apple
still, green apple is an apple
and red apple is also an apple
therefore, both are apples

Non-member function overloads

operator+ (string)

string (1) 
string operator+ (const string& lhs, const string& rhs);string operator+ (string&&      lhs, string&&      rhs);string operator+ (string&&      lhs, const string& rhs);string operator+ (const string& lhs, string&&      rhs);
c-string (2) 
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);
character (3) 
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);
// concatenating strings
#include <iostream>
#include <string>

main ()
{
  std::string firstlevel ("com");
  std::string secondlevel ("cplusplus");
  std::string scheme ("http://");
  std::string hostname;
  std::string url;

  hostname = "www." + secondlevel + '.' + firstlevel;
  url = scheme + hostname;

  std::cout << url << '\n';

  return 0;
}Output:

http://www.cplusplus.com

relational operators (string)

(1) 
bool operator== (const string& lhs, const string& rhs) noexcept;bool operator== (const char*   lhs, const string& rhs);bool operator== (const string& lhs, const char*   rhs);
(2) 
bool operator!= (const string& lhs, const string& rhs) noexcept;bool operator!= (const char*   lhs, const string& rhs);bool operator!= (const string& lhs, const char*   rhs);
(3) 
bool operator<  (const string& lhs, const string& rhs) noexcept;bool operator<  (const char*   lhs, const string& rhs);bool operator<  (const string& lhs, const char*   rhs);
(4) 
bool operator<= (const string& lhs, const string& rhs) noexcept;bool operator<= (const char*   lhs, const string& rhs);bool operator<= (const string& lhs, const char*   rhs);
(5) 
bool operator>  (const string& lhs, const string& rhs) noexcept;bool operator>  (const char*   lhs, const string& rhs);bool operator>  (const string& lhs, const char*   rhs);
(6) 
bool operator>= (const string& lhs, const string& rhs) noexcept;bool operator>= (const char*   lhs, const string& rhs);bool operator>= (const string& lhs, const char*   rhs);

字符串的关系运算符

在字符串对象lhs和rhs之间执行适当的比较操作。 函数使用字符串：：compare进行比较。 这些运算符在标头＜string＞中重载。

// string comparisons
#include <iostream>
#include <vector>

int main ()
{
  std::string foo = "alpha";
  std::string bar = "beta";

  if (foo==bar) std::cout << "foo and bar are equal\n";
  if (foo!=bar) std::cout << "foo and bar are not equal\n";
  if (foo< bar) std::cout << "foo is less than bar\n";
  if (foo> bar) std::cout << "foo is greater than bar\n";
  if (foo<=bar) std::cout << "foo is less than or equal to bar\n";
  if (foo>=bar) std::cout << "foo is greater than or equal to bar\n";

  return 0;
}Output:

foo and bar are not equal
foo is less than bar
foo is less than or equal to bar

swap (string)

void swap (string& x, string& y);

交换两个字符串的值

交换字符串对象x和y的值，这样在调用该函数后，x的值就是调用前y上的值，y的值就是x的值。 这是通用算法交换的过载，通过将其内部数据的所有权相互转移到另一个对象来提高其性能（即，字符串交换对其数据的引用，而不实际复制字符）：它的行为就像调用了x.swap（y）。

// 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';

  swap (buyer,seller);

  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

operator>> (string)

istream& operator>> (istream& is, string& str);

从流中提取字符串

从输入流is中提取一个字符串，将序列存储在str中，该字符串将被覆盖（str的前一个值将被替换）。 此函数重载运算符>>，使其行为如istream:：operator>>中对c字符串所述，但应用于字符串对象。 每个提取的字符都被附加到字符串中，就好像调用了其成员push_back一样。 请注意，istream提取操作使用空格作为分隔符；因此，此操作将仅从流中提取可以被视为单词的内容。要提取整行文本，请参阅全局函数getline的字符串重载。

// extract to string
#include <iostream>
#include <string>

main ()
{
  std::string name;

  std::cout << "Please, enter your name: ";
  std::cin >> name;
  std::cout << "Hello, " << name << "!\n";

  return 0;
}

operator<< (string)

ostream& operator<< (ostream& os, const string& str);

将字符串插入流

将符合str值的字符序列插入os。 对于c字符串，此函数重载运算符<<，使其行为如ostream:：运算符<<中所述，但应用于字符串对象。

// inserting strings into output streams
#include <iostream>
#include <string>

main ()
{
  std::string str = "Hello world!";
  std::cout << str << '\n';
  return 0;
}

getline (string)

(1) 
istream& getline (istream&  is, string& str, char delim);istream& getline (istream&& is, string& str, char delim);
(2) 
istream& getline (istream&  is, string& str);istream& getline (istream&& is, string& str);

将行从流转换为字符串

从is中提取字符并将其存储到str中，直到找到定界字符delim（或换行符'\n'，表示（2））。 如果在is中到达文件末尾，或者在输入操作过程中发生其他错误，提取也会停止。 如果找到了分隔符，则提取并丢弃它（即不存储它，并在它之后开始下一个输入操作）。 请注意，调用之前str中的任何内容都会被新提取的序列所取代。 每个提取的字符都被附加到字符串中，就好像调用了其成员push_back一样。

// extract to string
#include <iostream>
#include <string>

int main ()
{
  std::string name;

  std::cout << "Please, enter your full name: ";
  std::getline (std::cin,name);
  std::cout << "Hello, " << name << "!\n";

  return 0;
}
Adagrad
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第4章-C++-标准库STL-string类.ppt
07-05
第4章-C++-标准库STL-string类.ppt
STL-String源码分析
CodeMyDream的专栏
04-27 189
String是一个模版： template<class _E, class _Tr=char_traits<_E>, class _A=allocator<_E> > class Mybasic_string
C++之STL-String
JYXCZYH的博客
04-24 662
简单来说，string类是用来对字符串进行操作的一个类，除了一些寻常的接口之外它还提供了一些专门设计用于操作单字节字符串的功能等等。
【c++】STL--string
includeevey的博客
12-02 3152
讲解非常详细，欢迎大家观看！
STL-string
Learning is life的博客
03-01 73
#
【C++】STL-string
嗷
08-01 865
STL-string
STL -容器,string容器
08-26
STL -容器,string容器
stl-views.gdb
01-23
# The following STL containers are currently supported: # # std::vector<T> -- via pvector command # std::list<T> -- via plist or plist_member command # std::map,T> -- via pmap or pmap_member command #...
cPP-string--.rar_c string_doc_string stl
09-14
c++中的string用法(一) .doc 详细介绍了 stl string 在C++中的使用方法
STL-基础数据类型的基本用法
01-21
STL-ARR,arry, file,list,map,priority_queue,set,share_ptr,stack,string,template,等基本数据类型
C++教学——从入门到精通 10.循环
QIPABOSHI的博客
04-24 372
一些事嘛，需要重复做，这就是循环在开始学之前我提一个事，最好先学Python再学C++，不然就会像我和piaojunhe_0825一样有C++后遗症，在Python里写了一个for(int i=0;i
【C】 初识C语言
努力学习C/C++
04-21 770
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
笨蛋学C++【C++基础第六弹】
YSL_Monet的博客
04-24 822
定义类需要用到关键字 class，然后指定类的名称，类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数class 类名{访问修饰符（public/protected/private）:成员变量;成员函数();
【C++风云录】精益求精：探索C++开发中的性能优化艺术
记录我的学习历程
04-21 1116
本文将介绍几个在C++开发中常用的性能分析工具和性能优化工具集，包括PerfTools、gperftools、Valgrind、Intel VTune、PAPI以及Boost.Profile。通过深入了解这些工具的功能和用途，读者可以更好地理解如何利用它们来提高代码的执行效率和资源利用率。
C++——初识模板
qq_74245477的博客
04-22 911
之前实现的数据结构，比如栈，我们为了便于修改存储的数据类型，通常使用typedef来重定义数据类型，但是这样有一个缺陷，会导致我们定义的栈存储的都是一种数据，如果同时需要两个栈，一个存储int，一个存储自定义类型，那么typedef就不管用了。比如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，对于字符类型也是如此。概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型的版本。
理解C语言中的位操作和整数类型：一个温度传感器读取问题的解析
最新发布
qq_61637982的博客
04-24 237
当我们编写嵌入式系统的代码时，我们经常需要使用位操作来处理硬件设备的数据。然而，如果我们对C语言的位操作和整数类型不完全理解，可能会遇到一些难以理解的问题。在这篇博客中，我将通过一个实际的例子来解释这些概念，并提供一个解决方案。
C++中的抽象类
hh121386的博客
04-23 200
C++中的抽象类
掉落回弹问题（C语言）
m0_67184754的博客
04-22 364
【代码】掉落回弹问题（C语言）
C++初识--------带你从不同的角度理解引用的巧妙之处
binhyun的博客
04-24 533
引用之顺序表与链表运用&&权限问题
STL string
08-14
pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* [【C++】-- STL之String...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值