basic_string 类
Visual Studio 2015
若要了解有关 Visual Studio 2017 RC 的最新文档，请参阅 Visual Studio 2017 RC 文档。
由模板类 basic_string 的一个对象控制的序列是标准 C++ 字符串类且通常作为字符串被引用，但不应将它们与以 null 结尾的通用于标准 C++ 库的 C 样式字符串相混淆。 标准 C++ 字符串是一个容器，它可使字符串作为普通类型使用，例如，比较和连接操作、迭代器、STL 算法以及复制由类分配器管理的内存和使用它进行分配。 如果您需要将标准 c + + 字符串转换为以 null 结尾的 C 样式字符串，使用basic_string:: c_str成员。
template <class CharType, class Traits = char_traits<CharType>, class Allocator = allocator<CharType>> class basic_string;
参数
CharType
要存储在字符串中的单个字符的数据类型。 标准 c + + 库提供此模板类，与类型定义的专用化字符串类型元素的char， wstring，为wchar_t， u16string为char16_t，和u32string为char32_t。
Traits
各种重要属性CharType basic_string 专用化中的元素描述由类特征。 默认值是char_traits < CharType1>。
Allocator
一种表示存储的分配器对象的类型，该分配器对象封装有关字符串的内存分配和解除分配的详细信息。 默认值是分配器< CharType1>。
构造函数
| basic_string | 构建一个字符串，它为空或被特定字符初始化，或者是某个其他字符串对象或 C 字符串的全部或部分的副本。 |
Typedef
| allocator_type | 表示字符串对象的 allocator 类的类型。 |
| const_iterator | 提供可访问和读取字符串中 const 元素的随机访问迭代器的类型。 |
| const_pointer | 提供指向字符串中 const 元素的指针的类型。 |
| const_reference | 提供对存储于字符串中供读取和执行 const 操作的 const 元素的引用的类型。 |
| const_reverse_iterator | 提供可访问字符串中任何 const 元素的随机访问迭代器的类型。 |
| difference_type | 提供引用同一字符串中的元素的两个迭代器之间的差异的类型。 |
| 迭代器 | 提供可读取或修改字符串中任何元素的随机访问迭代器的类型。 |
| npos | 一个初始化为 –1 的无符号整数值，这个值在搜索功能失败时指示“找不到”或“所有其余字符”。 |
| 指针 | 提供指向字符串中或字符数组中字符元素的指针的类型。 |
| 引用 | 提供对存储在字符串中的元素的引用的类型。 |
| reverse_iterator | 提供可读取或修改反向字符串中元素的随机访问迭代器的类型。 |
| size_type | 字符串中元素的数目的无符号整数类型。 |
| traits_type | 存储在字符串中的元素的字符特征的一个类型。 |
| value_type | 表示存储在字符串中的字符的类型的类型。 |
成员函数
| 追加 | 向字符串的末尾添加字符。 |
| 分配 | 对字符串的内容赋新的字符值。 |
| 在 | 返回对字符串中指定位置的元素的引用。 |
| 返回 | |
| 开始 | 返回发现字符串中第一个元素的位置的迭代器。 |
| c_str | 将字符串的内容转换为以 null 结尾的 C 样式字符串。 |
| 容量 | 返回在不增加字符串内存分配的情况下可存储在字符串中的元素的最大数目。 |
| cbegin | 返回发现字符串中第一个元素的位置的常量迭代器。 |
| cend | 返回发现字符串中最后一个元素之后的位置的常量迭代器。 |
| 清除 | 清除字符串中的全部元素。 |
| 比较 | 将字符串与指定字符串比较，确定两个字符串是否相等或按字典顺序一个字符串是否小于另一个。 |
| 复制 | 将指定数目的字符从源字符串中的索引位置复制到目标字符组。 已否决。 使用basic_string:: _copy_s相反。 |
| crbegin | 返回发现反向字符串中第一个元素的位置的常量迭代器。 |
| crend | 返回发现反向字符串中最后一个元素之后的位置的常量迭代器。 |
| _Copy_s | 将指定数目的字符从源字符串中的索引位置复制到目标字符组。 |
| 数据 | 将字符串的内容转换为字符数组。 |
| 为空 | 测试字符串是否包含字符。 |
| 结束 | 返回发现字符串中最后一个元素之后的位置的迭代器。 |
| 擦除 | 从字符串中的指定位置删除一个或一系列元素。 |
| 查找 | 向前搜索字符串，搜索与指定字符序列匹配的第一个子字符串。 |
| find_first_not_of | 在字符串中搜索不属于指定字符串中元素的第一个字符。 |
| find_first_of | 在字符串中搜索与指定字符串中任何元素匹配的第一个字符。 |
| find_last_not_of | 在字符串中搜索不属于指定字符串中任何元素的最后一个字符。 |
| find_last_of | 在字符串中搜索属于指定字符串中一个元素的最后一个字符。 |
| 前端 | 返回对字符串中第一个元素的引用。 |
| get_allocator | 返回用于构造字符串的 allocator 对象的副本。 |
| 插入 | 将一个、多个或一些列元素插入字符串中的指定位置。 |
| 长度 | 返回字符串中元素的当前数目。 |
| max_size | 返回字符串可包含的字符的最大数目。 |
| pop_back | 删除字符串的最后一个元素。 |
| push_back | 在字符串的末尾处添加一个元素。 |
| rbegin | 返回指向反向字符串中第一个元素的迭代器。 |
| rend | 返回指向刚超出反向字符串的最后一个元素的位置的迭代器。 |
| 替换 | 用指定字符或者从其他范围、字符串或 C 字符串复制的字符来替代字符串中指定位置的元素。 |
| 保留 | 将字符串的容量设置为一个数目，这个数目至少应与指定数目一样大。 |
| 调整大小 | 根据要求追加或删除元素，为字符串指定新的大小。 |
| rfind | 向后搜索字符串，搜索与指定字符序列匹配的第一个子字符串。 |
| shrink_to_fit | 放弃字符串的超出容量。 |
| 大小 | 返回字符串中元素的当前数目。 |
| substr | 从字符串起始处的指定位置复制最多某个数目的字符的子字符串。 |
| 交换 | 交换两个字符串的内容。 |
运算符
| operator + = | 向字符串追加字符。 |
| 运算符 = | 对字符串的内容赋新的字符值。 |
| [operator]](#basic_string__operator_at) | 使用字符串中的指定索引提供对字符的引用。 |
如果要求函数生成的序列长于max_size元素，该函数将进行相应报告长度错误通过引发类型的对象length_error。
引用、 指针和迭代器用于指定受控序列的元素可能会变为无效或为非首次调用之后对可更改受控制的序列的函数的任何调用const成员函数。
标头︰<>>
命名空间： std
表示字符串对象的分配器类的类型。
typedef Allocator allocator_type;
备注
类型是模板参数的同义词分配器。
示例
// basic_string_allocator_type.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The following lines declare objects
// that use the default allocator.
string s1;
basic_string <char>::allocator_type xchar = s1.get_allocator( );
// You can now call functions on the allocator class xchar used by s1
}
向字符串的末尾添加字符。
basic_string<CharType, Traits, Allocator>& append(
const value_type* ptr);
basic_string<CharType, Traits, Allocator>& append(
const value_type* ptr,
size_type count);
basic_string<CharType, Traits, Allocator>& append(
const basic_string<CharType, Traits, Allocator>& str,
size_type _Off,
size_type count);
basic_string<CharType, Traits, Allocator>& append(
const basic_string<CharType, Traits, Allocator>& str);
basic_string<CharType, Traits, Allocator>& append(
size_type count,
value_type _Ch);
template <class InputIterator>
basic_string<CharType, Traits, Allocator>& append(
InputIterator first,
InputIterator last);
basic_string<CharType, Traits, Allocator>& append(
const_pointer first,
const_pointer last);
basic_string<CharType, Traits, Allocator>& append(
const_iterator first,
const_iterator last);
参数
ptr
C 字符串要追加。
str
要追加的字符字符串。
_Off
提供要追加的字符的源字符串部分的索引。
count
要追加，最多 source 字符串中的字符数。
_Ch
要追加的字符值。
first
发现输入迭代器范围中的第一个元素要追加。
last
输入迭代器、 const_pointer 或 const_iterator 寻址范围中最后一个元素之外的组件的位置要追加。
返回值
对追加成员函数所传递字符的字符串对象的引用。
备注
字符可能会追加到字符串使用运算符 + =或成员函数追加或push_back。 operator+=追加多个参数时的单一参数值追加允许为添加指定的字符串的特定部分的成员函数。
示例
// basic_string_append.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function
// appending a C-string to a string
string str1a ( "Hello " );
cout << "The original string str1 is: " << str1a << endl;
const char *cstr1a = "Out There ";
cout << "The C-string cstr1a is: " << cstr1a << endl;
str1a.append ( cstr1a );
cout << "Appending the C-string cstr1a to string str1 gives: "
<< str1a << "." << endl << endl;
// The second member function
// appending part of a C-string to a string
string str1b ( "Hello " );
cout << "The string str1b is: " << str1b << endl;
const char *cstr1b = "Out There ";
cout << "The C-string cstr1b is: " << cstr1b << endl;
str1b.append ( cstr1b , 3 );
cout << "Appending the 1st part of the C-string cstr1b "
<< "to string str1 gives: " << str1b << "."
<< endl << endl;
// The third member function
// appending part of one string to another
string str1c ( "Hello " ), str2c ( "Wide World " );
cout << "The string str2c is: " << str2c << endl;
str1c.append ( str2c , 5 , 5 );
cout << "The appended string str1 is: "
<< str1c << "." << endl << endl;
// The fourth member function
// appending one string to another in two ways,
// comparing append and operator [ ]
string str1d ( "Hello " ), str2d ( "Wide " ), str3d ( "World " );
cout << "The string str2d is: " << str2d << endl;
str1d.append ( str2d );
cout << "The appended string str1d is: "
<< str1d << "." << endl;
str1d += str3d;
cout << "The doubly appended strig str1 is: "
<< str1d << "." << endl << endl;
// The fifth member function
// appending characters to a string
string str1e ( "Hello " );
str1e.append ( 4 , '!' );
cout << "The string str1 appended with exclamations is: "
<< str1e << endl << endl;
// The sixth member function
// appending a range of one string to another
string str1f ( "Hello " ), str2f ( "Wide World " );
cout << "The string str2f is: " << str2f << endl;
str1f.append ( str2f.begin ( ) + 5 , str2f.end ( ) - 1 );
cout << "The appended string str1 is: "
<< str1f << "." << endl << endl;
}
Output
The original string str1 is: Hello The C-string cstr1a is: Out There Appending the C-string cstr1a to string str1 gives: Hello Out There . The string str1b is: Hello The C-string cstr1b is: Out There Appending the 1st part of the C-string cstr1b to string str1 gives: Hello Out. The string str2c is: Wide World The appended string str1 is: Hello World. The string str2d is: Wide The appended string str1d is: Hello Wide . The doubly appended strig str1 is: Hello Wide World . The string str1 appended with exclamations is: Hello !!!! The string str2f is: Wide World The appended string str1 is: Hello World.
对字符串的内容赋新的字符值。
basic_string<CharType, Traits, Allocator>& assign(
const value_type* ptr);
basic_string<CharType, Traits, Allocator>& assign(
const value_type* ptr,
size_type count);
basic_string<CharType, Traits, Allocator>& assign(
const basic_string<CharType, Traits, Allocator>& str,
size_type off,
size_type count);
basic_string<CharType, Traits, Allocator>& assign(
const basic_string<CharType, Traits, Allocator>& str);
basic_string<CharType, Traits, Allocator>& assign(
size_type count,
value_type _Ch);
template <class InIt>
basic_string<CharType, Traits, Allocator>& assign(
InputIterator first,
InputIterator last);
basic_string<CharType, Traits, Allocator>& assign(
const_pointer first,
const_pointer last);
basic_string<CharType, Traits, Allocator>& assign(
const_iterator first,
const_iterator last);
参数
ptr
指向要分配给目标字符串的 C 字符串的字符的指针。
count
要追加，最多 source 字符串中的字符数。
str
其字符是分配给目标字符串的源字符串。
_Ch
要分配的字符值。
first
输入迭代器、 const_pointer 或 const_iterator 寻址的范围内的源字符串的第一个字符分配到目标范围。
last
输入迭代器、 const_pointer 或 const_iterator 寻址远端的范围中最后一个字符源字符串内的一个要分配给目标范围。
off
此时将启动新字符要分配的位置。
返回值
对正在由成员函数分配新字符的字符串对象的引用。
备注
可以将字符串分配新的字符值。 新的值可以是字符串和 C 字符串或单个字符。 运算符 =如果新值可以是描述由单个参数; 否则为可能使用成员函数分配，它具有多个参数，可用来指定字符串的哪一部分是要分配给目标字符串。
示例
// basic_string_assign.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function assigning the
// characters of a C-string to a string
string str1a;
const char *cstr1a = "Out There";
cout << "The C-string cstr1a is: " << cstr1a << "." << endl;
str1a.assign ( cstr1a );
cout << "Assigning the C-string cstr1a to string str1 gives: "
<< str1a << "." << endl << endl;
// The second member function assigning a specific
// number of the of characters a C-string to a string
string str1b;
const char *cstr1b = "Out There";
cout << "The C-string cstr1b is: " << cstr1b << endl;
str1b.assign ( cstr1b , 3 );
cout << "Assigning the 1st part of the C-string cstr1b "
<< "to string str1 gives: " << str1b << "."
<< endl << endl;
// The third member function assigning a specific number
// of the characters from one string to another string
string str1c ( "Hello " ), str2c ( "Wide World " );
cout << "The string str2c is: " << str2c << endl;
str1c.assign ( str2c , 5 , 5 );
cout << "The newly assigned string str1 is: "
<< str1c << "." << endl << endl;
// The fourth member function assigning the characters
// from one string to another string in two equivalent
// ways, comparing the assign and operator =
string str1d ( "Hello" ), str2d ( "Wide" ), str3d ( "World" );
cout << "The original string str1 is: " << str1d << "." << endl;
cout << "The string str2d is: " << str2d << endl;
str1d.assign ( str2d );
cout << "The string str1 newly assigned with string str2d is: "
<< str1d << "." << endl;
cout << "The string str3d is: " << str3d << "." << endl;
str1d = str3d;
cout << "The string str1 reassigned with string str3d is: "
<< str1d << "." << endl << endl;
// The fifth member function assigning a specific
// number of characters of a certain value to a string
string str1e ( "Hello " );
str1e.assign ( 4 , '!' );
cout << "The string str1 assigned with eclamations is: "
<< str1e << endl << endl;
// The sixth member function assigning the value from
// the range of one string to another string
string str1f ( "Hello " ), str2f ( "Wide World " );
cout << "The string str2f is: " << str2f << endl;
str1f.assign ( str2f.begin ( ) + 5 , str2f.end ( ) - 1 );
cout << "The string str1 assigned a range of string str2f is: "
<< str1f << "." << endl << endl;
}
Output
The C-string cstr1a is: Out There. Assigning the C-string cstr1a to string str1 gives: Out There. The C-string cstr1b is: Out There Assigning the 1st part of the C-string cstr1b to string str1 gives: Out. The string str2c is: Wide World The newly assigned string str1 is: World. The original string str1 is: Hello. The string str2d is: Wide The string str1 newly assigned with string str2d is: Wide. The string str3d is: World. The string str1 reassigned with string str3d is: World. The string str1 assigned with eclamations is: !!!! The string str2f is: Wide World The string str1 assigned a range of string str2f is: World.
使用字符串中的指定索引提供对字符的引用。
const_reference at(size_type _Off) const; reference at(size_type _Off);
参数
_Off
要引用的元素的位置的索引。
返回值
对字符串中指定的参数索引的位置的字符的引用。
备注
该字符串的第一个元素具有零的索引，并且以下元素连续方式进行索引的正整数，以便长度的字符串n具有nth 元素的数量来索引n – 1。
该成员operator []快于成员函数在提供读取和写入访问权限字符串的元素。
该成员operator[]不会检查作为参数传递的索引是否有效，但成员函数在应使用作用，因此，如果的有效性不一定。 无效的索引，这是一个索引小于零或大于或等于传递给成员函数的字符串的大小在引发out_of_range 类异常。 无效的索引传递给operator[]导致未定义的行为，但索引等于字符串的长度是常量字符串的有效索引，该运算符将返回 null 字符时传递此索引。
返回的引用，可能会失效字符串重新分配或修改非const字符串。
示例
// basic_string_at.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ( "Hello world" ), str2 ( "Goodbye world" );
const string cstr1 ( "Hello there" ), cstr2 ( "Goodbye now" );
cout << "The original string str1 is: " << str1 << endl;
cout << "The original string str2 is: " << str2 << endl;
// Element access to the non const strings
basic_string <char>::reference refStr1 = str1 [6];
basic_string <char>::reference refStr2 = str2.at ( 3 );
cout << "The character with an index of 6 in string str1 is: "
<< refStr1 << "." << endl;
cout << "The character with an index of 3 in string str2 is: "
<< refStr2 << "." << endl;
// Element access to the const strings
basic_string <char>::const_reference crefStr1 = cstr1 [ cstr1.length ( ) ];
basic_string <char>::const_reference crefStr2 = cstr2.at ( 8 );
if ( crefStr1 == '\0' )
cout << "The null character is returned as a valid reference."
<< endl;
else
cout << "The null character is not returned." << endl;
cout << "The character with index 8 in the const string cstr2 is: "
<< crefStr2 << "." << endl;
}
返回对字符串中最后一个元素的引用。
const_reference back() const; reference back();
返回值
对字符串中最后一个元素的引用，必须为非空值。
备注
构造一个字符串，它为空、由特定字符初始化，或者是另一个字符串对象或 C 样式（以 null 终止）字符串的全部或部分的副本。
basic_string();
explicit basic_string(
const allocator_type& _Al);
basic_string(
const basic_string& right);
basic_string(
basic_string&& right);
basic_string(
const basic_string& right,
size_type _Roff,
size_type count = npos);
basic_string(
const basic_string& right,
size_type _Roff,
size_type count,
const allocator_type& _Al);
basic_string(
const value_type* ptr,
size_type count);
basic_string(
const value_type* ptr,
size_type count,
const allocator_type& _Al);
basic_string(
const value_type* ptr);
basic_string(
const value_type* ptr,
const allocator_type& _Al);
basic_string(
size_type count,
value_type _Ch);
basic_string(
size_type count,
value_type _Ch,
const allocator_type& _Al);
template <class InputIterator>
basic_string(
InputIterator first,
InputIterator last);
template <class InputIterator>
basic_string(
InputIterator first,
InputIterator last,
const allocator_type& _Al);
basic_string(
const_pointer first,
const_pointer last);
basic_string(
const_iterator first,
const_iterator last);
参数
ptr
C 字符串，其字符将用于初始化正在构造的 string。 此值不能为 null 指针。
_Al
正在构造的字符串对象的存储分配器类。
count
要初始化的字符数。
right
用于初始化正在构造的字符串的字符串。
_Roff
字符串中字符的索引，该字符串会最先用于初始化正在构造的字符串的字符值。
_Ch
要复制到正在构造的字符串中的字符值。
first
输入迭代器（const_pointer 或 const_iterator），用于寻址要插入的源范围中的第一个元素。
last
输入迭代器（const_pointer 或 const_iterator），用于寻址要插入的源范围中超出最后一个元素的元素的位置。
返回值
对构造函数正在构造的字符串对象的引用。
备注
所有构造函数都会存储basic_string:: allocator_type并初始化受控的序列。 分配器对象是参数 al（如果存在）。 对于复制构造函数，它是right. basic_string:: get_allocator()。 否则，它是 Alloc()。
受控序列初始化为剩余操作数指定的操作数序列的副本。 没有操作数序列的构造函数指定空的初始受控序列。 如果InputIterator是整数类型在模板的构造函数，操作数序列 _First, last的行为与相同(size_type) first, (value_type) last。
示例
// basic_string_ctor.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function initializing with a C-string
const char *cstr1a = "Hello Out There.";
basic_string <char> str1a ( cstr1a , 5);
cout << "The string initialized by C-string cstr1a is: "
<< str1a << "." << endl;
// The second member function initializing with a string
string str2a ( "How Do You Do" );
basic_string <char> str2b ( str2a , 7 , 7 );
cout << "The string initialized by part of the string cstr2a is: "
<< str2b << "." << endl;
// The third member function initializing a string
// with a number of characters of a specific value
basic_string <char> str3a ( 5, '9' );
cout << "The string initialized by five number 9s is: "
<< str3a << endl;
// The fourth member function creates an empty string
// and string with a specified allocator
basic_string <char> str4a;
string str4b;
basic_string <char> str4c ( str4b.get_allocator( ) );
if (str4c.empty ( ) )
cout << "The string str4c is empty." << endl;
else
cout << "The string str4c is not empty." << endl;
// The fifth member function initializes a string from
// another range of characters
string str5a ( "Hello World" );
basic_string <char> str5b ( str5a.begin ( ) + 5 , str5a.end ( ) );
cout << "The string initialized by another range is: "
<< str5b << "." << endl;
}
返回发现字符串中第一个元素的位置的迭代器。
const_iterator begin() const; iterator begin();
返回值
随机访问迭代器的第一个元素的序列或刚超出空序列的末尾。
示例
// basic_string_begin.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( ) {
using namespace std;
string str1 ( "No way out." ), str2;
basic_string <char>::iterator strp_Iter, str1_Iter, str2_Iter;
basic_string <char>::const_iterator str1_cIter;
str1_Iter = str1.begin ( );
cout << "The first character of the string str1 is: "
<< *str1_Iter << endl;
cout << "The full original string str1 is: " << str1 << endl;
// The dereferenced iterator can be used to modify a character
*str1_Iter = 'G';
cout << "The first character of the modified str1 is now: "
<< *str1_Iter << endl;
cout << "The full modified string str1 is now: " << str1 << endl;
// The following line would be an error because iterator is const
// *str1_cIter = 'g';
// For an empty string, begin is equivalent to end
if ( str2.begin ( ) == str2.end ( ) )
cout << "The string str2 is empty." << endl;
else
cout << "The string str2 is not empty." << endl;
}
将作为 C 样式字符串的内容转换为 null 终止的字符串。
const value_type *c_str() const;
返回值
指向 C 样式版本的调用的字符串的指针。 在调用非常量函数，包括该对象上的 basic_string 类中的析构函数后，指针值不正确。
备注
C + + 模板类 basic_string 属于字符串类型的对象<>>是否不一定是以 null 终止。 Null 字符 \0' 用作 C 字符串中的特殊字符来标记字符串的末尾而字符串类型的对象中的任何特殊含义，可能就像任何其他字符字符串的一部分。 没有从 const 的自动转换char* 到字符串，但该字符串类不提供对从 C 样式字符串的类型的对象的自动转换basic_string<>>。
不应修改返回的 C 样式字符串，这可能使无效指针，指向字符串，或删除，因为字符串具有有限的生存期，并且归的类别字符串。
示例
// basic_string_c_str.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ( "Hello world" );
cout << "The original string object str1 is: "
<< str1 << endl;
cout << "The length of the string object str1 = "
<< str1.length ( ) << endl << endl;
// Converting a string to an array of characters
const char *ptr1 = 0;
ptr1= str1.data ( );
cout << "The modified string object ptr1 is: " << ptr1
<< endl;
cout << "The length of character array str1 = "
<< strlen ( ptr1) << endl << endl;
// Converting a string to a C-style string
const char *c_str1 = str1.c_str ( );
cout << "The C-style string c_str1 is: " << c_str1
<< endl;
cout << "The length of C-style string str1 = "
<< strlen ( c_str1) << endl << endl;
}
Output
The original string object str1 is: Hello world The length of the string object str1 = 11 The modified string object ptr1 is: Hello world The length of character array str1 = 11 The C-style string c_str1 is: Hello world The length of C-style string str1 = 11
返回在不增加字符串内存分配的情况下可存储在字符串中的元素的最大数目。
size_type capacity() const;
返回值
当前分配的内存来存放字符串中的存储区的大小。
备注
成员函数将返回当前分配用于保存受控的序列的值至少为最大的存储空间大小。
示例
// basic_string_capacity.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ("Hello world");
cout << "The original string str1 is: " << str1 << endl;
// The size and length member functions differ in name only
basic_string <char>::size_type sizeStr1, lenStr1;
sizeStr1 = str1.size ( );
lenStr1 = str1.length ( );
basic_string <char>::size_type capStr1, max_sizeStr1;
capStr1 = str1.capacity ( );
max_sizeStr1 = str1.max_size ( );
// Compare size, length, capacity & max_size of a string
cout << "The current size of original string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The current length of original string str1 is: "
<< lenStr1 << "." << endl;
cout << "The capacity of original string str1 is: "
<< capStr1 << "." << endl;
cout << "The max_size of original string str1 is: "
<< max_sizeStr1 << "." << endl << endl;
str1.erase ( 6, 5 );
cout << "The modified string str1 is: " << str1 << endl;
sizeStr1 = str1.size ( );
lenStr1 = str1.length ( );
capStr1 = str1.capacity ( );
max_sizeStr1 = str1.max_size ( );
// Compare size, length, capacity & max_size of a string
// after erasing part of the original string
cout << "The current size of modified string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The current length of modified string str1 is: "
<< lenStr1 << "." << endl;
cout << "The capacity of modified string str1 is: "
<< capStr1 << "." << endl;
cout << "The max_size of modified string str1 is: "
<< max_sizeStr1 << "." << endl;
}
返回确定范围中第一个元素地址的 const 迭代器。
const_iterator cbegin() const;
返回值
const 随机访问迭代器，指向范围的第一个元素，或刚超出空范围末尾的位置（对于空范围，cbegin() == cend()）。
备注
由于使用 cbegin 的返回值，因此不能修改范围中的元素。
可以使用此成员函数替代 begin() 成员函数，以保证返回值为 const_iterator。 通常情况下，结合使用自动类型推导关键字，如下面的示例中所示。 在示例中，请考虑Container的可修改 (非const) 容器支持任何种类的begin()和cbegin()。
C++
auto i1 = Container.begin(); // i1 is Container<T>::iterator auto i2 = Container.cbegin(); // i2 is Container<T>::const_iterator
返回一个 const 迭代器，此迭代器用于发现刚超出范围中最后一个元素的位置。
const_iterator cend() const;
返回值
指向刚超出范围末尾的位置的 const 随机访问迭代器。
备注
cend 用于测试迭代器是否超过了其范围的末尾。
可以使用此成员函数替代 end() 成员函数，以保证返回值为 const_iterator。 通常情况下，结合使用自动类型推导关键字，如下面的示例中所示。 在示例中，请考虑Container的可修改 (非const) 容器支持任何种类的end()和cend()。
C++
auto i1 = Container.end(); // i1 is Container<T>::iterator auto i2 = Container.cend(); // i2 is Container<T>::const_iterator
不应对 cend 返回的值取消引用。
清除字符串中的全部元素。
void clear();
备注
在其调用成员函数的字符串将为空。
示例
// basic_string_clear.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ("Hello world"), str2;
basic_string <char>::iterator str_Iter;
cout << "The original string str1 is: ";
for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
cout << *str_Iter;
cout << endl;
str1.clear ( );
cout << "The modified string str1 is: ";
for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
cout << *str_Iter;
cout << endl;
//For an empty string, begin is equivalent to end
if ( str1.begin ( ) == str1.end ( ) )
cout << "Nothing printed above because "
<< "the string str1 is empty." << endl;
else
cout << "The string str1 is not empty." << endl;
}
Output
The original string str1 is: Hello world The modified string str1 is: Nothing printed above because the string str1 is empty.
通过使用指定的字符串以确定两个字符串是否相等或如果其中一个是按字典序小于另区分大小写比较。
int compare(
const basic_string<CharType, Traits, Allocator>& str) const;
int compare(
size_type _Pos1,
size_type _Num1,
const basic_string<CharType, Traits, Allocator>& str) const;
int compare(
size_type _Pos1,
size_type _Num1,
const basic_string<CharType, Traits, Allocator>& str,
size_type _Off,
size_type count) const;
int compare(
const value_type* ptr) const;
int compare(
size_type _Pos1,
size_type _Num1,
const value_type* ptr) const;
int compare(
size_type _Pos1,
size_type _Num1,
const value_type* ptr
size_type _Num2) const;
参数
str
要为操作数字符串进行比较的字符串。
_Pos1
操作数字符串比较开始的索引。
_Num1
最大操作数字符串进行比较的字符数。
_Num2
最大参数字符串进行比较的字符数。
_Off
参数字符串比较开始的索引。
count
最大参数字符串进行比较的字符数。
ptr
C 字符串进行比较的操作数字符串。
返回值
如果操作数字符串小于参数字符串中;，负值如果两个字符串相等，则为零或正值操作数字符串是否大于参数字符串。
备注
比较成员函数比较全部或部分的参数和操作数字符串具体取决于在使用中。
执行的比较是区分大小写。
示例
// basic_string_compare.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function compares
// an operand string to a parameter string
int comp1;
string s1o ( "CAB" );
string s1p ( "CAB" );
cout << "The operand string is: " << s1o << endl;
cout << "The parameter string is: " << s1p << endl;
comp1 = s1o.compare ( s1p );
if ( comp1 < 0 )
cout << "The operand string is less than "
<< "the parameter string." << endl;
else if ( comp1 == 0 )
cout << "The operand string is equal to "
<< "the parameter string." << endl;
else
cout << "The operand string is greater than "
<< "the parameter string." << endl;
cout << endl;
// The second member function compares part of
// an operand string to a parameter string
int comp2a, comp2b;
string s2o ( "AACAB" );
string s2p ( "CAB" );
cout << "The operand string is: " << s2o << endl;
cout << "The parameter string is: " << s2p << endl;
comp2a = s2o.compare ( 2 , 3 , s2p );
if ( comp2a < 0 )
cout << "The last three characters of "
<< "the operand string\n are less than "
<< "the parameter string." << endl;
else if ( comp2a == 0 )
cout << "The last three characters of "
<< "the operand string\n are equal to "
<< "the parameter string." << endl;
else
cout << "The last three characters of "
<< "the operand string\n is greater than "
<< "the parameter string." << endl;
comp2b = s2o.compare ( 0 , 3 , s2p );
if ( comp2b < 0 )
cout << "The first three characters of "
<< "the operand string\n are less than "
<< "the parameter string." << endl;
else if ( comp2b == 0 )
cout << "The first three characters of "
<< "the operand string\n are equal to "
<< "the parameter string." << endl;
else
cout << "The first three characters of "
<< "the operand string\n is greater than "
<< "the parameter string." << endl;
cout << endl;
// The third member function compares part of
// an operand string to part of a parameter string
int comp3a;
string s3o ( "AACAB" );
string s3p ( "DCABD" );
cout << "The operand string is: " << s3o << endl;
cout << "The parameter string is: " << s3p << endl;
comp3a = s3o.compare ( 2 , 3 , s3p , 1 , 3 );
if ( comp3a < 0 )
cout << "The three characters from position 2 of "
<< "the operand string are less than\n "
<< "the 3 characters parameter string "
<< "from position 1." << endl;
else if ( comp3a == 0 )
cout << "The three characters from position 2 of "
<< "the operand string are equal to\n "
<< "the 3 characters parameter string "
<< "from position 1." << endl;
else
cout << "The three characters from position 2 of "
<< "the operand string is greater than\n "
<< "the 3 characters parameter string "
<< "from position 1." << endl;
cout << endl;
// The fourth member function compares
// an operand string to a parameter C-string
int comp4a;
string s4o ( "ABC" );
const char* cs4p = "DEF";
cout << "The operand string is: " << s4o << endl;
cout << "The parameter C-string is: " << cs4p << endl;
comp4a = s4o.compare ( cs4p );
if ( comp4a < 0 )
cout << "The operand string is less than "
<< "the parameter C-string." << endl;
else if ( comp4a == 0 )
cout << "The operand string is equal to "
<< "the parameter C-string." << endl;
else
cout << "The operand string is greater than "
<< "the parameter C-string." << endl;
cout << endl;
// The fifth member function compares part of
// an operand string to a parameter C-string
int comp5a;
string s5o ( "AACAB" );
const char* cs5p = "CAB";
cout << "The operand string is: " << s5o << endl;
cout << "The parameter string is: " << cs5p << endl;
comp5a = s5o.compare ( 2 , 3 , s2p );
if ( comp5a < 0 )
cout << "The last three characters of "
<< "the operand string\n are less than "
<< "the parameter C-string." << endl;
else if ( comp5a == 0 )
cout << "The last three characters of "
<< "the operand string\n are equal to "
<< "the parameter C-string." << endl;
else
cout << "The last three characters of "
<< "the operand string\n is greater than "
<< "the parameter C-string." << endl;
cout << endl;
// The sixth member function compares part of
// an operand string to part of an equal length of
// a parameter C-string
int comp6a;
string s6o ( "AACAB" );
const char* cs6p = "ACAB";
cout << "The operand string is: " << s6o << endl;
cout << "The parameter C-string is: " << cs6p << endl;
comp6a = s6o.compare ( 1 , 3 , cs6p , 3 );
if ( comp6a < 0 )
cout << "The 3 characters from position 1 of "
<< "the operand string are less than\n "
<< "the first 3 characters of the parameter C-string."
<< endl;
else if ( comp6a == 0 )
cout << "The 3 characters from position 2 of "
<< "the operand string are equal to\n "
<< "the first 3 characters of the parameter C-string."
<< endl;
else
cout << "The 3 characters from position 2 of "
<< "the operand string is greater than\n "
<< "the first 3 characters of the parameter C-string."
<< endl;
cout << endl;
}
Output
The operand string is: CAB The parameter string is: CAB The operand string is equal to the parameter string. The operand string is: AACAB The parameter string is: CAB The last three characters of the operand string are equal to the parameter string. The first three characters of the operand string are less than the parameter string. The operand string is: AACAB The parameter string is: DCABD The three characters from position 2 of the operand string are equal to the 3 characters parameter string from position 1. The operand string is: ABC The parameter C-string is: DEF The operand string is less than the parameter C-string. The operand string is: AACAB The parameter string is: CAB The last three characters of the operand string are equal to the parameter C-string. The operand string is: AACAB The parameter C-string is: ACAB The 3 characters from position 2 of the operand string are equal to the first 3 characters of the parameter C-string.
提供的随机访问迭代器的类型可访问和读取const在字符串中的元素。
typedef implementation-defined const_iterator;
备注
一种类型const_iterator不能用于修改字符的值，用于循环访问在一个向前方向的字符串。
示例
请参阅示例开始以举例说明如何声明和使用const_iterator。
提供指向的指针的类型const字符串中的元素。
typedef typename allocator_type::const_pointer const_pointer;
备注
类型为同义词allocator_type::const_pointer。
类型为字符串，它等效于char*。
进行声明时，必须先初始化声明 const 指针。 Const 指针始终指向同一内存位置，并可能会指出与常量或非常量数据。
示例
// basic_string_const_ptr.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
basic_string<char>::const_pointer pstr1a = "In Here";
const char *cstr1c = "Out There";
cout << "The string pstr1a is: " << pstr1a << "." << endl;
cout << "The C-string cstr1c is: " << cstr1c << "." << endl;
}
Output
The string pstr1a is: In Here. The C-string cstr1c is: Out There.
提供对引用的类型const元素存储在字符串中供读取和执行const操作。
typedef typename allocator_type::const_reference const_reference;
备注
const_reference 类型不能用于修改元素的值。
类型为同义词allocator_type::const_reference。 字符串类型，它等效于 const char <。
示例
请参阅示例在以举例说明如何声明和使用const_reference。
一种提供随机访问迭代器可读取任何const在字符串中的元素。
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
备注
一种类型const_reverse_iterator不能修改字符的值，用于循环访问字符串按相反的顺序。
示例
请参阅示例rbegin以举例说明如何声明和使用const_reverse_iterator。
将指定数目的字符从源字符串中的索引位置复制到目标字符组。
此方法可能是不安全，依赖于调用方检查传递的值正确。 请考虑使用basic_string:: _copy_s相反。
size_type copy(
value_type* ptr,
size_type count,
size_type _Off = 0) const;
参数
ptr
元素将被复制到目标字符组。
_ Count
要从中复制，最多，源字符串的字符数。
_Off
要从该副本的源字符串中的开始位置。
返回值
实际复制的字符数。
备注
Null 字符不追加到该副本的末尾。
示例
// basic_string_copy.cpp
// compile with: /EHsc /W3
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ( "Hello World" );
basic_string <char>::iterator str_Iter;
char array1 [ 20 ] = { 0 };
char array2 [ 10 ] = { 0 };
basic_string <char>:: pointer array1Ptr = array1;
basic_string <char>:: value_type *array2Ptr = array2;
cout << "The original string str1 is: ";
for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
cout << *str_Iter;
cout << endl;
basic_string <char>:: size_type nArray1;
// Note: string::copy is potentially unsafe, consider
// using string::_Copy_s instead.
nArray1 = str1.copy ( array1Ptr , 12 ); // C4996
cout << "The number of copied characters in array1 is: "
<< nArray1 << endl;
cout << "The copied characters array1 is: " << array1 << endl;
basic_string <char>:: size_type nArray2;
// Note: string::copy is potentially unsafe, consider
// using string::_Copy_s instead.
nArray2 = str1.copy ( array2Ptr , 5 , 6 ); // C4996
cout << "The number of copied characters in array2 is: "
<< nArray2 << endl;
cout << "The copied characters array2 is: " << array2Ptr << endl;
}
Output
The original string str1 is: Hello World The number of copied characters in array1 is: 11 The copied characters array1 is: Hello World The number of copied characters in array2 is: 5 The copied characters array2 is: World
返回发现反向字符串中第一个元素的位置的常量迭代器。
const_reverse_iterator crbegin() const;
返回值
指向刚超出字符串末尾的位置的反向迭代器。 该位置指定反向序列的开头。
返回发现反向字符串中最后一个元素之后的位置的常量迭代器。
const_reverse_iterator crend() const;
返回值
用于发现反向字符串中最后一个元素之后的位置（非反向字符串中第一个元素之前的位置）的常量反向迭代器。
备注
将指定数目的字符从源字符串中的索引位置复制到目标字符组。
size_type _Copy_s(
value_type* dest,
size_type dest_size,
size_type count,
size_type _Off = 0) const;
参数
dest
元素将被复制到目标字符组。
dest_size
大小dest。
_ Count
要从中复制，最多，源字符串的字符数。
_Off
要从该副本的源字符串中的开始位置。
返回值
实际复制的字符数。
备注
Null 字符不追加到该副本的末尾。
示例
// basic_string__Copy_s.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1("Hello World");
basic_string<char>::iterator str_Iter;
const int array1_size = 20;
char array1[array1_size] = { 0 };
const int array2_size = 10;
char array2[array2_size] = { 0 };
basic_string<char>:: pointer array1Ptr = array1;
basic_string<char>:: value_type *array2Ptr = array2;
cout << "The original string str1 is: ";
for (str_Iter = str1.begin(); str_Iter != str1.end(); str_Iter++)
cout << *str_Iter;
cout << endl;
basic_string<char>::size_type nArray1;
nArray1 = str1._Copy_s(array1Ptr, array1_size, 12);
cout << "The number of copied characters in array1 is: "
<< nArray1 << endl;
cout << "The copied characters array1 is: " << array1 << endl;
basic_string<char>:: size_type nArray2;
nArray2 = str1._Copy_s(array2Ptr, array2_size, 5, 6);
cout << "The number of copied characters in array2 is: "
<< nArray2 << endl;
cout << "The copied characters array2 is: " << array2Ptr << endl;
}
Output
The original string str1 is: Hello World The number of copied characters in array1 is: 11 The copied characters array1 is: Hello World The number of copied characters in array2 is: 5 The copied characters array2 is: World
将字符串的内容转换为字符数组。
const value_type *data() const;
返回值
指向数组，其中包含的字符串，或为空数组，不能被取消引用一个非 null 指针的内容的第一个元素的指针。
备注
C + + 模板类 basic_string 属于字符串类型的对象<>>是否不一定是以 null 终止。 返回类型数据不是一个有效的 C 字符串，因为都可不附加任何 null 字符。 Null 字符 \0' 用作 C 字符串中的特殊字符中用于标记字符串的末尾，而字符串类型的对象中的没有特殊含义，可能就像任何其他字符的字符串对象的一部分。
没有从 const 的自动转换**char* 到字符串，但该字符串类不提供对从 C 样式字符串的类型的对象的自动转换basic_string <> </> > **。
不应修改返回的字符串，因为这可能使无效指针，指向字符串，或删除，因为字符串具有有限的生存期，并且归的类别字符串。
示例
// basic_string_data.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ( "Hello world" );
cout << "The original string object str1 is: "
<< str1 << endl;
cout << "The length of the string object str1 = "
<< str1.length ( ) << endl << endl;
// Converting a string to an array of characters
const char *ptr1 = 0;
ptr1= str1.data ( );
cout << "The modified string object ptr1 is: " << ptr1
<< endl;
cout << "The length of character array str1 = "
<< strlen ( ptr1) << endl << endl;
// Converting a string to a C-style string
const char *c_str1 = str1.c_str ( );
cout << "The C-style string c_str1 is: " << c_str1
<< endl;
cout << "The length of C-style string str1 = "
<< strlen ( c_str1) << endl << endl;
}
Output
The original string object str1 is: Hello world The length of the string object str1 = 11 The modified string object ptr1 is: Hello world The length of character array str1 = 11 The C-style string c_str1 is: Hello world The length of C-style string str1 = 11
提供引用同一字符串中的元素的两个迭代器之间的差异的类型。
typedef typename allocator_type::difference_type difference_type;
备注
带符号的整数类型描述一个可表示受控序列中任意两个元素的地址之间的差异的对象。
类型为字符串，它等效于ptrdiff_t。
示例
// basic_string_diff_type.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ( "quintillion" );
cout << "The original string str1 is: " << str1 << endl;
basic_string <char>::size_type indexChFi, indexChLi;
indexChFi = str1.find_first_of ( "i" );
indexChLi = str1.find_last_of ( "i" );
basic_string<char>::difference_type diffi = indexChLi - indexChFi;
cout << "The first character i is at position: "
<< indexChFi << "." << endl;
cout << "The last character i is at position: "
<< indexChLi << "." << endl;
cout << "The difference is: " << diffi << "." << endl;
}
Output
The original string str1 is: quintillion The first character i is at position: 2. The last character i is at position: 8. The difference is: 6.
测试是否该字符串包含字符。
bool empty() const;
返回值
true如果字符串对象不包含字符;false是否至少一个字符。
备注
成员函数是等效于大小= = 0。
示例
// basic_string_empty.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main() {
using namespace std;
bool b1, b2;
string str1 ("Hello world");
cout << "The original string object str1 is: " << str1 << endl;
b1 = str1.empty();
if (b1)
cout << "The string object str1 is empty." << endl;
else
cout << "The string object str1 is not empty." << endl;
cout << endl;
// An example of an empty string object
string str2;
b2 = str2.empty();
if (b2)
cout << "The string object str2 is empty." << endl;
else
cout << "The string object str2 is not empty." << endl;
}
返回发现字符串中最后一个元素之后的位置的迭代器。
const_iterator end() const; iterator end();
返回值
返回发现字符串中的最后一个元素之后的位置的随机访问迭代器。
备注
结束通常用于测试是否迭代器已到达其字符串的末尾。 返回的值结束不应取消引用。
如果返回值为结束分配给const_iterator，不能修改字符串对象。 如果返回值为结束分配给迭代器，可以修改字符串对象。
示例
// basic_string_end.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ( "No way out." ), str2;
basic_string <char>::iterator str_Iter, str1_Iter, str2_Iter;
basic_string <char>::const_iterator str1_cIter;
str1_Iter = str1.end ( );
str1_Iter--;
str1_Iter--;
cout << "The last character-letter of the string str1 is: " << *str1_Iter << endl;
cout << "The full orginal string str1 is: " << str1 << endl;
// end used to test when an iterator has reached the end of its string
cout << "The string is now: ";
for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
cout << *str_Iter;
cout << endl;
// The dereferenced iterator can be used to modify a character
*str1_Iter = 'T';
cout << "The last character-letter of the modified str1 is now: "
<< *str1_Iter << endl;
cout << "The modified string str1 is now: " << str1 << endl;
// The following line would be an error because iterator is const
// *str1_cIter = 'T';
// For an empty string, end is equivalent to begin
if ( str2.begin( ) == str2.end ( ) )
cout << "The string str2 is empty." << endl;
else
cout << "The stringstr2 is not empty." << endl;
}
Output
The last character-letter of the string str1 is: t The full orginal string str1 is: No way out. The string is now: No way out. The last character-letter of the modified str1 is now: T The modified string str1 is now: No way ouT. The string str2 is empty.
从字符串中的指定位置删除一个或一系列元素。
iterator erase(
iterator first,
iterator last);
iterator erase(
iterator _It);
basic_string<CharType, Traits, Allocator>& erase(
size_type _Pos = 0,
size_type count = npos);
参数
first
发现的迭代器范围中第一个元素的位置被清除。
last
发现的迭代器中的位置的最后一个元素之后范围被清除。
_It
发现的迭代器在字符串中元素的位置被清除。
_Pos
要删除的字符串中的第一个字符的索引。
count
如果有任意多个字符串开头的范围中将删除的元素数目_Pos。
返回值
对于前两个成员函数，通过成员函数删除最后一个字符之后发现的第一个字符的迭代器。 对于第三个成员函数，已被清除元素的字符串对象的引用。
备注
第三个成员函数将返回*这。
示例
// basic_string_erase.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The 1st member function using a range demarcated
// by iterators
string str1 ( "Hello world" );
basic_string <char>::iterator str1_Iter;
cout << "The original string object str1 is: "
<< str1 << "." << endl;
str1_Iter = str1.erase ( str1.begin ( ) + 3 , str1.end ( ) - 1 );
cout << "The first element after those removed is: "
<< *str1_Iter << "." << endl;
cout << "The modified string object str1 is: " << str1
<< "." << endl << endl;
// The 2nd member function erasing a char pointed to
// by an iterator
string str2 ( "Hello World" );
basic_string <char>::iterator str2_Iter;
cout << "The original string object str2 is: " << str2
<< "." << endl;
str2_Iter = str2.erase ( str2.begin ( ) + 5 );
cout << "The first element after those removed is: "
<< *str2_Iter << "." << endl;
cout << "The modified string object str2 is: " << str2
<< "." << endl << endl;
// The 3rd member function erasing a number of chars
// after a char
string str3 ( "Hello computer" ), str3m;
basic_string <char>::iterator str3_Iter;
cout << "The original string object str3 is: "
<< str3 << "." << endl;
str3m = str3.erase ( 6 , 8 );
cout << "The modified string object str3m is: "
<< str3m << "." << endl;
}
Output
The original string object str1 is: Hello world. The first element after those removed is: d. The modified string object str1 is: Held. The original string object str2 is: Hello World. The first element after those removed is: W. The modified string object str2 is: HelloWorld. The original string object str3 is: Hello computer. The modified string object str3m is: Hello .
向前搜索字符串，搜索与指定字符序列匹配的第一个子字符串。
size_type find(
value_type _Ch,
size_type _Off = 0) const;
size_type find(
const value_type* ptr,
size_type _Off = 0) const;
size_type find(
const value_type* ptr,
size_type _Off,
size_type count) const;
size_type find(
const basic_string<CharType, Traits, Allocator>& str,
size_type _Off = 0) const;
参数
_Ch
成员函数要搜索的字符值。
_Off
搜索开始处的索引。
ptr
成员函数要搜索的 C 字符串。
count
在成员函数要搜索的 C 字符串中从第一个字符开始计数的字符数。
str
成员函数要搜索的字符串。
返回值
搜索成功时，则为搜索的子字符串的首个字符的索引；否则为 npos。
示例
// basic_string_find.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function
// searches for a single character in a string
string str1 ( "Hello Everyone" );
cout << "The original string str1 is: " << str1 << endl;
basic_string <char>::size_type indexCh1a, indexCh1b;
indexCh1a = str1.find ( "e" , 3 );
if (indexCh1a != string::npos )
cout << "The index of the 1st 'e' found after the 3rd"
<< " position in str1 is: " << indexCh1a << endl;
else
cout << "The character 'e' was not found in str1 ." << endl;
indexCh1b = str1.find ( "x" );
if (indexCh1b != string::npos )
cout << "The index of the 'x' found in str1 is: "
<< indexCh1b << endl << endl;
else
cout << "The Character 'x' was not found in str1."
<< endl << endl;
// The second member function searches a string
// for a substring as specified by a C-string
string str2 ( "Let me make this perfectly clear." );
cout << "The original string str2 is: " << str2 << endl;
basic_string <char>::size_type indexCh2a, indexCh2b;
const char *cstr2 = "perfect";
indexCh2a = str2.find ( cstr2 , 5 );
if ( indexCh2a != string::npos )
cout << "The index of the 1st element of 'perfect' "
<< "after\n the 5th position in str2 is: "
<< indexCh2a << endl;
else
cout << "The substring 'perfect' was not found in str2 ."
<< endl;
const char *cstr2b = "imperfectly";
indexCh2b = str2.find ( cstr2b , 0 );
if (indexCh2b != string::npos )
cout << "The index of the 1st element of 'imperfect' "
<< "after\n the 5th position in str3 is: "
<< indexCh2b << endl;
else
cout << "The substring 'imperfect' was not found in str2 ."
<< endl << endl;
// The third member function searches a string
// for a substring as specified by a C-string
string str3 ( "This is a sample string for this program" );
cout << "The original string str3 is: " << str3 << endl;
basic_string <char>::size_type indexCh3a, indexCh3b;
const char *cstr3a = "sample";
indexCh3a = str3.find ( cstr3a );
if ( indexCh3a != string::npos )
cout << "The index of the 1st element of sample "
<< "in str3 is: " << indexCh3a << endl;
else
cout << "The substring 'perfect' was not found in str3 ."
<< endl;
const char *cstr3b = "for";
indexCh3b = str3.find ( cstr3b , indexCh3a + 1 , 2 );
if (indexCh3b != string::npos )
cout << "The index of the next occurrence of 'for' is in "
<< "str3 begins at: " << indexCh3b << endl << endl;
else
cout << "There is no next occurrence of 'for' in str3 ."
<< endl << endl;
// The fourth member function searches a string
// for a substring as specified by a string
string str4 ( "clearly this perfectly unclear." );
cout << "The original string str4 is: " << str4 << endl;
basic_string <char>::size_type indexCh4a, indexCh4b;
string str4a ( "clear" );
indexCh4a = str4.find ( str4a , 5 );
if ( indexCh4a != string::npos )
cout << "The index of the 1st element of 'clear' "
<< "after\n the 5th position in str4 is: "
<< indexCh4a << endl;
else
cout << "The substring 'clear' was not found in str4 ."
<< endl;
string str4b ( "clear" );
indexCh4b = str4.find ( str4b );
if (indexCh4b != string::npos )
cout << "The index of the 1st element of 'clear' "
<< "in str4 is: "
<< indexCh4b << endl;
else
cout << "The substring 'clear' was not found in str4 ."
<< endl << endl;
}
Output
The original string str1 is: Hello Everyone The index of the 1st 'e' found after the 3rd position in str1 is: 8 The Character 'x' was not found in str1. The original string str2 is: Let me make this perfectly clear. The index of the 1st element of 'perfect' after the 5th position in str2 is: 17 The substring 'imperfect' was not found in str2 . The original string str3 is: This is a sample string for this program The index of the 1st element of sample in str3 is: 10 The index of the next occurrence of 'for' is in str3 begins at: 24 The original string str4 is: clearly this perfectly unclear. The index of the 1st element of 'clear' after the 5th position in str4 is: 25 The index of the 1st element of 'clear' in str4 is: 0
不是指定的字符串的元素的第一个字符在字符串中搜索。
size_type find_first_not_of(
value_type _Ch,
size_type _Off = 0) const;
size_type find_first_not_of(
const value_type* ptr,
size_type _Off = 0) const;
size_type find_first_not_of(
const value_type* ptr,
size_type _Off,
size_type count) const;
size_type find_first_not_of(
const basic_string<CharType, Traits, Allocator>& str,
size_type _Off = 0) const;
参数
_Ch
成员函数要搜索的字符值。
_Off
搜索开始处的索引。
ptr
成员函数要搜索的 C 字符串。
count
在成员函数要搜索的 C 字符串中从第一个字符开始计数的字符数。
str
成员函数要搜索的字符串。
返回值
搜索成功时，则为搜索的子字符串的首个字符的索引；否则为 npos。
示例
// basic_string_find_first_not_of.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function
// searches for a single character in a string
string str1 ( "xddd-1234-abcd" );
cout << "The original string str1 is: " << str1 << endl;
basic_string <char>::size_type indexCh1a, indexCh1b;
static const basic_string <char>::size_type npos = -1;
indexCh1a = str1.find_first_not_of ( "d" , 2 );
if ( indexCh1a != npos )
cout << "The index of the 1st 'd' found after the 3rd"
<< " position in str1 is: " << indexCh1a << endl;
else
cout << "The character 'd' was not found in str1 ." << endl;
indexCh1b = str1.find_first_not_of ( "x" );
if (indexCh1b != npos )
cout << "The index of the 'non x' found in str1 is: "
<< indexCh1b << endl << endl;
else
cout << "The character 'non x' was not found in str1."
<< endl << endl;
// The second member function searches a string
// for a substring as specified by a C-string
string str2 ( "BBB-1111" );
cout << "The original string str2 is: " << str2 << endl;
basic_string <char>::size_type indexCh2a, indexCh2b;
const char *cstr2 = "B1";
indexCh2a = str2.find_first_not_of ( cstr2 , 6 );
if ( indexCh2a != npos )
cout << "The index of the 1st occurrence of an "
<< "element of 'B1' in str2 after\n the 6th "
<< "position is: " << indexCh2a << endl;
else
cout << "Elements of the substring 'B1' were not"
<< "\n found in str2 after the 6th position."
<< endl;
const char *cstr2b = "B2";
indexCh2b = str2.find_first_not_of ( cstr2b );
if ( indexCh2b != npos )
cout << "The index of the 1st element of 'B2' "
<< "after\n the 0th position in str2 is: "
<< indexCh2b << endl << endl;
else
cout << "The substring 'B2' was not found in str2 ."
<< endl << endl << endl;
// The third member function searches a string
// for a substring as specified by a C-string
string str3 ( "444-555-GGG" );
cout << "The original string str3 is: " << str3 << endl;
basic_string <char>::size_type indexCh3a, indexCh3b;
const char *cstr3a = "45G";
indexCh3a = str3.find_first_not_of ( cstr3a );
if ( indexCh3a != npos )
cout << "The index of the 1st occurrence of an "
<< "element in str3\n other than one of the "
<< "characters in '45G' is: " << indexCh3a
<< endl;
else
cout << "Elements in str3 contain only characters "
<< " in the string '45G'. "
<< endl;
const char *cstr3b = "45G";
indexCh3b = str3.find_first_not_of ( cstr3b , indexCh3a + 1 , 2 );
if ( indexCh3b != npos )
cout << "The index of the second occurrence of an "
<< "element of '45G' in str3\n after the 0th "
<< "position is: " << indexCh3b << endl << endl;
else
cout << "Elements in str3 contain only characters "
<< " in the string '45G'. "
<< endl << endl;
// The fourth member function searches a string
// for a substring as specified by a string
string str4 ( "12-ab-12-ab" );
cout << "The original string str4 is: " << str4 << endl;
basic_string <char>::size_type indexCh4a, indexCh4b;
string str4a ( "ba3" );
indexCh4a = str4.find_first_not_of ( str4a , 5 );
if (indexCh4a != npos )
cout << "The index of the 1st non occurrence of an "
<< "element of 'ba3' in str4 after\n the 5th "
<< "position is: " << indexCh4a << endl;
else
cout << "Elements other than those in the substring"
<< " 'ba3' were not found in the string str4."
<< endl;
string str4b ( "12" );
indexCh4b = str4.find_first_not_of ( str4b );
if (indexCh4b != npos )
cout << "The index of the 1st non occurrence of an "
<< "element of '12' in str4 after\n the 0th "
<< "position is: " << indexCh4b << endl;
else
cout << "Elements other than those in the substring"
<< " '12' were not found in the string str4."
<< endl;
}
Output
The original string str1 is: xddd-1234-abcd The index of the 1st 'd' found after the 3rd position in str1 is: 4 The index of the 'non x' found in str1 is: 1 The original string str2 is: BBB-1111 Elements of the substring 'B1' were not found in str2 after the 6th position. The index of the 1st element of 'B2' after the 0th position in str2 is: 3 The original string str3 is: 444-555-GGG The index of the 1st occurrence of an element in str3 other than one of the characters in '45G' is: 3 The index of the second occurrence of an element of '45G' in str3 after the 0th position is: 7 The original string str4 is: 12-ab-12-ab The index of the 1st non occurrence of an element of 'ba3' in str4 after the 5th position is: 5 The index of the 1st non occurrence of an element of '12' in str4 after the 0th position is: 2
在字符串中搜索与指定字符串中任何元素匹配的第一个字符。
size_type find_first_of(
value_type _Ch,
size_type _Off = 0) const;
size_type find_first_of(
const value_type* ptr,
size_type _Off = 0) const;
size_type find_first_of(
const value_type* ptr,
size_type _Off,
size_type count) const;
size_type find_first_of(
const basic_string<CharType, Traits, Allocator>& str,
size_type _Off = 0) const;
参数
_Ch
成员函数要搜索的字符值。
_Off
搜索开始处的索引。
ptr
成员函数要搜索的 C 字符串。
count
在成员函数要搜索的 C 字符串中从第一个字符开始计数的字符数。
str
成员函数要搜索的字符串。
返回值
搜索成功时，则为搜索的子字符串的首个字符的索引；否则为 npos。
示例
// basic_string_find_first_of.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function
// searches for a single character in a string
string str1 ( "abcd-1234-abcd-1234" );
cout << "The original string str1 is: " << str1 << endl;
basic_string <char>::size_type indexCh1a, indexCh1b;
static const basic_string <char>::size_type npos = -1;
indexCh1a = str1.find_first_of ( "d" , 5 );
if ( indexCh1a != npos )
cout << "The index of the 1st 'd' found after the 5th"
<< " position in str1 is: " << indexCh1a << endl;
else
cout << "The character 'd' was not found in str1 ." << endl;
indexCh1b = str1.find_first_of ( "x" );
if ( indexCh1b != npos )
cout << "The index of the 'x' found in str1 is: "
<< indexCh1b << endl << endl;
else
cout << "The character 'x' was not found in str1."
<< endl << endl;
// The second member function searches a string
// for any element of a substring as specified by a C-string
string str2 ( "ABCD-1234-ABCD-1234" );
cout << "The original string str2 is: " << str2 << endl;
basic_string <char>::size_type indexCh2a, indexCh2b;
const char *cstr2 = "B1";
indexCh2a = str2.find_first_of ( cstr2 , 6 );
if ( indexCh2a != npos )
cout << "The index of the 1st occurrence of an "
<< "element of 'B1' in str2 after\n the 6th "
<< "position is: " << indexCh2a << endl;
else
cout << "Elements of the substring 'B1' were not "
<< "found in str2 after the 10th position."
<< endl;
const char *cstr2b = "D2";
indexCh2b = str2.find_first_of ( cstr2b );
if ( indexCh2b != npos )
cout << "The index of the 1st element of 'D2' "
<< "after\n the 0th position in str2 is: "
<< indexCh2b << endl << endl;
else
cout << "The substring 'D2' was not found in str2 ."
<< endl << endl << endl;
// The third member function searches a string
// for any element of a substring as specified by a C-string
string str3 ( "123-abc-123-abc-456-EFG-456-EFG" );
cout << "The original string str3 is: " << str3 << endl;
basic_string <char>::size_type indexCh3a, indexCh3b;
const char *cstr3a = "5G";
indexCh3a = str3.find_first_of ( cstr3a );
if ( indexCh3a != npos )
cout << "The index of the 1st occurrence of an "
<< "element of '5G' in str3 after\n the 0th "
<< "position is: " << indexCh3a << endl;
else
cout << "Elements of the substring '5G' were not "
<< "found in str3\n after the 0th position."
<< endl;
const char *cstr3b = "5GF";
indexCh3b = str3.find_first_of ( cstr3b , indexCh3a + 1 , 2 );
if (indexCh3b != npos )
cout << "The index of the second occurrence of an "
<< "element of '5G' in str3\n after the 0th "
<< "position is: " << indexCh3b << endl << endl;
else
cout << "Elements of the substring '5G' were not "
<< "found in str3\n after the first occurrrence."
<< endl << endl;
// The fourth member function searches a string
// for any element of a substring as specified by a string
string str4 ( "12-ab-12-ab" );
cout << "The original string str4 is: " << str4 << endl;
basic_string <char>::size_type indexCh4a, indexCh4b;
string str4a ( "ba3" );
indexCh4a = str4.find_first_of ( str4a , 5 );
if ( indexCh4a != npos )
cout << "The index of the 1st occurrence of an "
<< "element of 'ba3' in str4 after\n the 5th "
<< "position is: " << indexCh4a << endl;
else
cout << "Elements of the substring 'ba3' were not "
<< "found in str4\n after the 0th position."
<< endl;
string str4b ( "a2" );
indexCh4b = str4.find_first_of ( str4b );
if ( indexCh4b != npos )
cout << "The index of the 1st occurrence of an "
<< "element of 'a2' in str4 after\n the 0th "
<< "position is: " << indexCh4b << endl;
else
cout << "Elements of the substring 'a2' were not "
<< "found in str4\n after the 0th position."
<< endl;
}
Output
The original string str1 is: abcd-1234-abcd-1234 The index of the 1st 'd' found after the 5th position in str1 is: 13 The character 'x' was not found in str1. The original string str2 is: ABCD-1234-ABCD-1234 The index of the 1st occurrence of an element of 'B1' in str2 after the 6th position is: 11 The index of the 1st element of 'D2' after the 0th position in str2 is: 3 The original string str3 is: 123-abc-123-abc-456-EFG-456-EFG The index of the 1st occurrence of an element of '5G' in str3 after the 0th position is: 17 The index of the second occurrence of an element of '5G' in str3 after the 0th position is: 22 The original string str4 is: 12-ab-12-ab The index of the 1st occurrence of an element of 'ba3' in str4 after the 5th position is: 9 The index of the 1st occurrence of an element of 'a2' in str4 after the 0th position is: 1
在字符串中搜索不属于指定字符串中任何元素的最后一个字符。
size_type find_last_not_of(
value_type _Ch,
size_type _Off = npos) const;
size_type find_last_not_of(
const value_type* ptr,
size_type _Off = npos) const;
size_type find_last_not_of(
const value_type* ptr,
size_type _Off,
size_type count) const;
size_type find_last_not_of(
const basic_string<CharType, Traits, Allocator>& str,
size_type _Off = npos) const;
参数
_Ch
成员函数要搜索的字符值。
_Off
搜索即将完成的位置的索引。
ptr
成员函数要搜索的 C 字符串。
count
在成员函数要搜索的 C 字符串中从第一个字符开始计数的字符数。
str
成员函数要搜索的字符串。
返回值
搜索成功时，则为搜索的子字符串的首个字符的索引；否则为 npos。
示例
// basic_string_find_last_not_of.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function
// searches for a single character in a string
string str1 ( "dddd-1dd4-abdd" );
cout << "The original string str1 is: " << str1 << endl;
basic_string <char>::size_type indexCh1a, indexCh1b;
static const basic_string <char>::size_type npos = -1;
indexCh1a = str1.find_last_not_of ( "d" , 7 );
if ( indexCh1a != npos )
cout << "The index of the last non 'd'\n found before the "
<< "7th position in str1 is: " << indexCh1a << endl;
else
cout << "The non 'd' character was not found ." << endl;
indexCh1b = str1.find_last_not_of ( "d" );
if ( indexCh1b != npos )
cout << "The index of the non 'd' found in str1 is: "
<< indexCh1b << endl << endl;
else
cout << "The Character 'non x' was not found in str1."
<< endl << endl;
// The second member function searches a string
// for a substring as specified by a C-string
string str2 ( "BBB-1111" );
cout << "The original string str2 is: " << str2 << endl;
basic_string <char>::size_type indexCh2a, indexCh2b;
const char *cstr2 = "B1";
indexCh2a = str2.find_last_not_of ( cstr2 , 6 );
if ( indexCh2a != npos )
cout << "The index of the last occurrence of a "
<< "element\n not of 'B1' in str2 before the 6th "
<< "position is: " << indexCh2a << endl;
else
cout << "Elements not of the substring 'B1' were not "
<< "\n found in str2 before the 6th position."
<< endl;
const char *cstr2b = "B-1";
indexCh2b = str2.find_last_not_of ( cstr2b );
if ( indexCh2b != npos )
cout << "The index of the last element not "
<< "in 'B-1'\n is: "
<< indexCh2b << endl << endl;
else
cout << "The elements of the substring 'B-1' were "
<< "not found in str2 ."
<< endl << endl;
// The third member function searches a string
// for a substring as specified by a C-string
string str3 ( "444-555-GGG" );
cout << "The original string str3 is: " << str3 << endl;
basic_string <char>::size_type indexCh3a, indexCh3b;
const char *cstr3a = "45G";
indexCh3a = str3.find_last_not_of ( cstr3a );
if ( indexCh3a != npos )
cout << "The index of the last occurrence of an "
<< "element in str3\n other than one of the "
<< "characters in '45G' is: " << indexCh3a
<< endl;
else
cout << "Elements in str3 contain only characters "
<< " in the string '45G'. "
<< endl;
const char *cstr3b = "45G";
indexCh3b = str3.find_last_not_of ( cstr3b , 6 , indexCh3a - 1 );
if (indexCh3b != npos )
cout << "The index of the penultimate occurrence of an "
<< "element\n not in '45G' in str3 is: "
<< indexCh3b << endl << endl;
else
cout << "Elements in str3 contain only characters "
<< " in the string '45G'. "
<< endl << endl;
// The fourth member function searches a string
// for a substring as specified by a string
string str4 ( "12-ab-12-ab" );
cout << "The original string str4 is: " << str4 << endl;
basic_string <char>::size_type indexCh4a, indexCh4b;
string str4a ( "b-a" );
indexCh4a = str4.find_last_not_of ( str4a , 5 );
if ( indexCh4a != npos )
cout << "The index of the last occurrence of an "
<< "element not\n in 'b-a' in str4 before the 5th "
<< "position is: " << indexCh4a << endl;
else
cout << "Elements other than those in the substring"
<< " 'b-a' were not found in the string str4."
<< endl;
string str4b ( "12" );
indexCh4b = str4.find_last_not_of ( str4b );
if ( indexCh4b != npos )
cout << "The index of the last occurrence of an "
<< "element not in '12'\n in str4 before the end "
<< "position is: " << indexCh4b << endl;
else
cout << "Elements other than those in the substring"
<< " '12'\n were not found in the string str4."
<< endl;
}
Output
The original string str1 is: dddd-1dd4-abdd The index of the last non 'd' found before the 7th position in str1 is: 5 The index of the non 'd' found in str1 is: 11 The original string str2 is: BBB-1111 The index of the last occurrence of a element not of 'B1' in str2 before the 6th position is: 3 The elements of the substring 'B-1' were not found in str2 . The original string str3 is: 444-555-GGG The index of the last occurrence of an element in str3 other than one of the characters in '45G' is: 7 The index of the penultimate occurrence of an element not in '45G' in str3 is: 3 The original string str4 is: 12-ab-12-ab The index of the last occurrence of an element not in 'b-a' in str4 before the 5th position is: 1 The index of the last occurrence of an element not in '12' in str4 before the end position is: 10
在字符串中搜索与指定任何的字符串元素匹配的最后一个字符。
size_type find_last_of(
value_type _Ch,
size_type _Off = npos) const;
size_type find_last_of(
const value_type* ptr,
size_type _Off = npos) const;
size_type find_last_of(
const value_type* ptr,
size_type _Off,
size_type count) const;
size_type find_last_of(
const basic_string<CharType, Traits, Allocator>& str,
size_type _Off = npos) const;
参数
_Ch
成员函数要搜索的字符值。
_Off
搜索即将完成的位置的索引。
ptr
成员函数要搜索的 C 字符串。
count
在成员函数要搜索的 C 字符串中从第一个字符开始计数的字符数。
str
成员函数要搜索的字符串。
返回值
子字符串的最后一个字符的索引时成功，则搜索否则为npos。
示例
// basic_string_find_last_of.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function
// searches for a single character in a string
string str1 ( "abcd-1234-abcd-1234" );
cout << "The original string str1 is: " << str1 << endl;
basic_string <char>::size_type indexCh1a, indexCh1b;
static const basic_string <char>::size_type npos = -1;
indexCh1a = str1.find_last_of ( "d" , 14 );
if ( indexCh1a != npos )
cout << "The index of the last 'd' found before the 14th"
<< " position in str1 is: " << indexCh1a << endl;
else
cout << "The character 'd' was not found in str1 ." << endl;
indexCh1b = str1.find_first_of ( "x" );
if ( indexCh1b != npos )
cout << "The index of the 'x' found in str1 is: "
<< indexCh1b << endl << endl;
else
cout << "The character 'x' was not found in str1."
<< endl << endl;
// The second member function searches a string
// for a substring as specified by a C-string
string str2 ( "ABCD-1234-ABCD-1234" );
cout << "The original string str2 is: " << str2 << endl;
basic_string <char>::size_type indexCh2a, indexCh2b;
const char *cstr2 = "B1";
indexCh2a = str2.find_last_of ( cstr2 , 12 );
if (indexCh2a != npos )
cout << "The index of the last occurrence of an "
<< "element of 'B1' in str2 before\n the 12th "
<< "position is: " << indexCh2a << endl;
else
cout << "Elements of the substring 'B1' were not "
<< "found in str2 before the 12th position."
<< endl;
const char *cstr2b = "D2";
indexCh2b = str2.find_last_of ( cstr2b );
if ( indexCh2b != npos )
cout << "The index of the last element of 'D2' "
<< "after\n the 0th position in str2 is: "
<< indexCh2b << endl << endl;
else
cout << "The substring 'D2' was not found in str2 ."
<< endl << endl << endl;
// The third member function searches a string
// for a substring as specified by a C-string
string str3 ( "456-EFG-456-EFG" );
cout << "The original string str3 is: " << str3 << endl;
basic_string <char>::size_type indexCh3a;
const char *cstr3a = "5E";
indexCh3a = str3.find_last_of ( cstr3a , 8 , 8 );
if ( indexCh3a != npos )
cout << "The index of the last occurrence of an "
<< "element of '5E' in str3 before\n the 8th "
<< "position is: " << indexCh3a << endl << endl;
else
cout << "Elements of the substring '5G' were not "
<< "found in str3\n before the 8th position."
<< endl << endl;
// The fourth member function searches a string
// for a substring as specified by a string
string str4 ( "12-ab-12-ab" );
cout << "The original string str4 is: " << str4 << endl;
basic_string <char>::size_type indexCh4a, indexCh4b;
string str4a ( "ba3" );
indexCh4a = str4.find_last_of ( str4a , 8 );
if ( indexCh4a != npos )
cout << "The index of the last occurrence of an "
<< "element of 'ba3' in str4 before\n the 8th "
<< "position is: " << indexCh4a << endl;
else
cout << "Elements of the substring 'ba3' were not "
<< "found in str4\n after the 0th position."
<< endl;
string str4b ( "a2" );
indexCh4b = str4.find_last_of ( str4b );
if ( indexCh4b != npos )
cout << "The index of the last occurrence of an "
<< "element of 'a2' in str4 before\n the 0th "
<< "position is: " << indexCh4b << endl;
else
cout << "Elements of the substring 'a2' were not "
<< "found in str4\n after the 0th position."
<< endl;
}
Output
The original string str1 is: abcd-1234-abcd-1234 The index of the last 'd' found before the 14th position in str1 is: 13 The character 'x' was not found in str1. The original string str2 is: ABCD-1234-ABCD-1234 The index of the last occurrence of an element of 'B1' in str2 before the 12th position is: 11 The index of the last element of 'D2' after the 0th position in str2 is: 16 The original string str3 is: 456-EFG-456-EFG The index of the last occurrence of an element of '5E' in str3 before the 8th position is: 4 The original string str4 is: 12-ab-12-ab The index of the last occurrence of an element of 'ba3' in str4 before the 8th position is: 4 The index of the last occurrence of an element of 'a2' in str4 before the 0th position is: 9
返回对字符串中第一个元素的引用。
const_reference front() const; reference front();
返回值
对字符串的第一个元素的引用，必须为非空值。
备注
返回用于构造字符串的分配器对象的副本。
allocator_type get_allocator() const;
返回值
使用字符串的分配器。
备注
该成员函数将返回存储的分配器对象。
此字符串类的分配器指定类管理存储的方式。 容器类提供的默认分配器足以满足大多编程需求。 编写和使用你自己的分配器类是高级 C++ 主题。
示例
// basic_string_get_allocator.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The following lines declare objects
// that use the default allocator.
string s1;
basic_string <char> s2;
basic_string <char, char_traits< char >, allocator< char > > s3;
// s4 will use the same allocator class as s1
basic_string <char> s4( s1.get_allocator ( ) );
basic_string <char>::allocator_type xchar = s1.get_allocator( );
// You can now call functions on the allocator class xchar used by s1
}
将一个、多个或一些列元素插入字符串中的指定位置。
basic_string<CharType, Traits, Allocator>& insert(
size_type _P0,
const value_type* ptr);
basic_string<CharType, Traits, Allocator>& insert(
size_type _P0,
const value_type* ptr,
size_type count);
basic_string<CharType, Traits, Allocator>& insert(
size_type _P0,
const basic_string<CharType, Traits, Allocator>& str);
basic_string<CharType, Traits, Allocator>& insert(
size_type _P0,
const basic_string<CharType, Traits, Allocator>& str,
size_type _Off,
size_type count);
basic_string<CharType, Traits, Allocator>& insert(
size_type _P0,
size_type count,
value_type _Ch);
iterator insert(
iterator _It);
iterator insert(
iterator _It,
value_type _Ch)l
template <class InputIterator>
void insert(
iterator _It,
InputIterator first,
InputIterator last);
void insert(
iterator _It,
size_type count,
value_type _Ch);
void insert(
iterator _It,
const_pointer first,
const_pointer last);
void insert(
iterator _It,
const_iterator first,
const_iterator last);
参数
_P0
新字符插入点之后的位置的索引。
ptr
将要完全或部分插入到字符串中的 C 字符串。
count
要插入的字符数。
str
将要完全或部分插入到目标字符串中的字符串。
_Off
提供要追加的字符的源字符串部分的索引。
_Ch
要插入的元素的字符值。
_It
对要在其后插入一个字符的位置进行寻址的迭代器。
first
输入迭代器（const_pointer 或 const_iterator），用于寻址要插入的源范围中的第一个元素。
last
输入迭代器（const_pointer 或 const_iterator），用于寻址要插入的源范围中超出最后一个元素的元素的位置。
返回值
对由成员函数所分配新字符的字符串对象的引用，或者在插入单个字符的情况下，对插入字符（或无，具体取决于特定成员函数）的位置进行寻址的迭代器。
示例
// basic_string_insert.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function inserting a C-string
// at a given position
basic_string <char> str1a ( "way" );
const char *cstr1a = "a";
str1a.insert ( 0, cstr1a );
cout << "The string with a C-string inserted at position 0 is: "
<< str1a << "." << endl;
// The second member function inserting a C-string
// at a given position for a specified number of elements
basic_string <char> str2a ( "Good" );
const char *cstr2a = "Bye Bye Baby";
str2a.insert ( 4, cstr2a ,3 );
cout << "The string with a C-string inserted at the end is: "
<< str2a << "." << endl;
// The third member function inserting a string
// at a given position
basic_string <char> str3a ( "Bye" );
string str3b ( "Good" );
str3a.insert ( 0, str3b );
cout << "The string with a string inserted at position 0 is: "
<< str3a << "." << endl;
// The fourth member function inserting part of
// a string at a given position
basic_string <char> str4a ( "Good " );
string str4b ( "Bye Bye Baby" );
str4a.insert ( 5, str4b , 8 , 4 );
cout << "The string with part of a string inserted at position 4 is: "
<< str4a << "." << endl;
// The fifth member function inserts a number of characters
// at a specified position in the string
string str5 ( "The number is: ." );
str5.insert ( 15 , 3 , '3' );
cout << "The string with characters inserted is: "
<< str5 << endl;
// The sixth member function inserts a character
// at a specified position in the string
string str6 ( "ABCDFG" );
basic_string <char>::iterator str6_Iter = ( str6.begin ( ) + 4 );
str6.insert ( str6_Iter , 'e' );
cout << "The string with a character inserted is: "
<< str6 << endl;
// The seventh member function inserts a range
// at a specified position in the string
string str7a ( "ABCDHIJ" );
string str7b ( "abcdefgh" );
basic_string <char>::iterator str7a_Iter = (str7a.begin ( ) + 4 );
str7a.insert ( str7a_Iter , str7b.begin ( ) + 4 , str7b.end ( ) -1 );
cout << "The string with a character inserted from a range is: "
<< str7a << endl;
// The eigth member function inserts a number of
// characters at a specified position in the string
string str8 ( "ABCDHIJ" );
basic_string <char>::iterator str8_Iter = ( str8.begin ( ) + 4 );
str8.insert ( str8_Iter , 3 , 'e' );
cout << "The string with a character inserted from a range is: "
<< str8 << endl;
}
Output
The string with a C-string inserted at position 0 is: away. The string with a C-string inserted at the end is: GoodBye. The string with a string inserted at position 0 is: GoodBye. The string with part of a string inserted at position 4 is: Good Baby. The string with characters inserted is: The number is: 333. The string with a character inserted is: ABCDeFG The string with a character inserted from a range is: ABCDefgHIJ The string with a character inserted from a range is: ABCDeeeHIJ
提供的随机访问迭代器的类型可访问和读取const在字符串中的元素。
typedef implementation-defined iterator;
备注
一种类型迭代器可以用来修改字符的值并且用于循环访问在一个向前方向的字符串。
示例
请参阅示例开始以举例说明如何声明和使用迭代器。
返回字符串中元素的当前数目。
size_type length() const;
备注
成员函数等同于大小。
示例
// basic_string_length.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ("Hello world");
cout << "The original string str1 is: " << str1 << endl;
// The size and length member functions differ in name only
basic_string <char>::size_type sizeStr1, lenStr1;
sizeStr1 = str1.size ( );
lenStr1 = str1.length ( );
basic_string <char>::size_type capStr1, max_sizeStr1;
capStr1 = str1.capacity ( );
max_sizeStr1 = str1.max_size ( );
// Compare size, length, capacity & max_size of a string
cout << "The current size of original string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The current length of original string str1 is: "
<< lenStr1 << "." << endl;
cout << "The capacity of original string str1 is: "
<< capStr1 << "." << endl;
cout << "The max_size of original string str1 is: "
<< max_sizeStr1 << "." << endl << endl;
str1.erase ( 6, 5 );
cout << "The modified string str1 is: " << str1 << endl;
sizeStr1 = str1.size ( );
lenStr1 = str1.length ( );
capStr1 = str1.capacity ( );
max_sizeStr1 = str1.max_size ( );
// Compare size, length, capacity & max_size of a string
// after erasing part of the original string
cout << "The current size of modified string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The current length of modified string str1 is: "
<< lenStr1 << "." << endl;
cout << "The capacity of modified string str1 is: "
<< capStr1 << "." << endl;
cout << "The max_size of modified string str1 is: "
<< max_sizeStr1 << "." << endl;
}
返回字符串可包含的字符的最大数目。
size_type max_size() const;
返回值
最大字符串可包含的字符数。
备注
类型的异常length_error 类当运算生成长度大于最大大小的字符串时引发。
示例
// basic_string_max_size.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ("Hello world");
cout << "The original string str1 is: " << str1 << endl;
// The size and length member functions differ in name only
basic_string <char>::size_type sizeStr1, lenStr1;
sizeStr1 = str1.size ( );
lenStr1 = str1.length ( );
basic_string <char>::size_type capStr1, max_sizeStr1;
capStr1 = str1.capacity ( );
max_sizeStr1 = str1.max_size ( );
// Compare size, length, capacity & max_size of a string
cout << "The current size of original string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The current length of original string str1 is: "
<< lenStr1 << "." << endl;
cout << "The capacity of original string str1 is: "
<< capStr1 << "." << endl;
cout << "The max_size of original string str1 is: "
<< max_sizeStr1 << "." << endl << endl;
str1.erase ( 6, 5 );
cout << "The modified string str1 is: " << str1 << endl;
sizeStr1 = str1.size ( );
lenStr1 = str1.length ( );
capStr1 = str1.capacity ( );
max_sizeStr1 = str1.max_size ( );
// Compare size, length, capacity & max_size of a string
// after erasing part of the original string
cout << "The current size of modified string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The current length of modified string str1 is: "
<< lenStr1 << "." << endl;
cout << "The capacity of modified string str1 is: "
<< capStr1 << "." << endl;
cout << "The max_size of modified string str1 is: "
<< max_sizeStr1 << "." << endl;
}
一个初始化为 –1 的无符号整数值，这个值在搜索功能失败时指示“找不到”或“所有其余字符”。
static const size_type npos = -1;
备注
返回值时要检查的npos值，它可能不起作用除非返回值的类型size_type以及不int或unsigned。
示例
请参阅示例查找以举例说明如何声明和使用npos。
向字符串追加字符。
basic_string<CharType, Traits, Allocator>& operator+=(
value_type _Ch);
basic_string<CharType, Traits, Allocator>& operator+=(
const value_type* ptr);
basic_string<CharType, Traits, Allocator>& operator+=(
const basic_string<CharType, Traits, Allocator>& right);
参数
_Ch
要追加的字符。
ptr
要追加的 C 字符串的字符。
right
要追加的字符串的字符。
返回值
对追加成员函数所传递字符的字符串对象的引用。
备注
字符可能会追加到字符串使用operator+=或成员函数追加或push_back。 operator+=追加单一参数值时的多个参数追加成员函数允许要添加指定的字符串的特定部分。
示例
// basic_string_op_app.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function
// appending a single character to a string
string str1a ( "Hello" );
cout << "The original string str1 is: " << str1a << endl;
str1a += '!' ;
cout << "The string str1 appended with an exclamation is: "
<< str1a << endl << endl;
// The second member function
// appending a C-string to a string
string str1b ( "Hello " );
const char *cstr1b = "Out There";
cout << "The C-string cstr1b is: " << cstr1b << endl;
str1b += cstr1b;
cout << "Appending the C-string cstr1b to string str1 gives: "
<< str1b << "." << endl << endl;
// The third member function
// appending one string to another in two ways,
// comparing append and operator [ ]
string str1d ( "Hello " ), str2d ( "Wide " ), str3d ( "World" );
cout << "The string str2d is: " << str2d << endl;
str1d.append ( str2d );
cout << "The appended string str1d is: "
<< str1d << "." << endl;
str1d += str3d;
cout << "The doubly appended strig str1 is: "
<< str1d << "." << endl << endl;
}
Output
The original string str1 is: Hello The string str1 appended with an exclamation is: Hello! The C-string cstr1b is: Out There Appending the C-string cstr1b to string str1 gives: Hello Out There. The string str2d is: Wide The appended string str1d is: Hello Wide . The doubly appended strig str1 is: Hello Wide World.
对字符串的内容赋新的字符值。
basic_string<CharType, Traits, Allocator>& operator=(
value_type _Ch);
basic_string<CharType, Traits, Allocator>& operator=(
const value_type* ptr);
basic_string<CharType, Traits, Allocator>& operator=(
const basic_string<CharType, Traits, Allocator>& right);
basic_string<CharType, Traits, Allocator>& operator=(
const basic_string<CharType, Traits, Allocator>&& right);
参数
_Ch
要分配的字符值。
ptr
指向要分配给目标字符串的 C 字符串的字符的指针。
right
其字符是分配给目标字符串的源字符串。
返回值
对正在由成员函数分配新字符的字符串对象的引用。
备注
这些字符串可能会分配新的字符值。 新值可能是一个字符串和 C 字符串或单个字符。 operator=如果新值可为可能使用描述的一个参数，否则该成员函数分配，它具有多个参数，可用于指定字符串的哪一部分是要分配给目标字符串。
示例
// basic_string_op_assign.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function assigning a
// character of a certain value to a string
string str1a ( "Hello " );
str1a = '0';
cout << "The string str1 assigned with the zero character is: "
<< str1a << endl << endl;
// The second member function assigning the
// characters of a C-string to a string
string str1b;
const char *cstr1b = "Out There";
cout << "The C-string cstr1b is: " << cstr1b << "." << endl;
str1b = cstr1b;
cout << "Assigning the C-string cstr1a to string str1 gives: "
<< str1b << "." << endl << endl;
// The third member function assigning the characters
// from one string to another string in two equivalent
// ways, comparing the assign and operator =
string str1c ( "Hello" ), str2c ( "Wide" ), str3c ( "World" );
cout << "The original string str1 is: " << str1c << "." << endl;
cout << "The string str2c is: " << str2c << "." << endl;
str1c.assign ( str2c );
cout << "The string str1 newly assigned with string str2c is: "
<< str1c << "." << endl;
cout << "The string str3c is: " << str3c << "." << endl;
str1c = str3c;
cout << "The string str1 reassigned with string str3c is: "
<< str1c << "." << endl << endl;
}
Output
The string str1 assigned with the zero character is: 0 The C-string cstr1b is: Out There. Assigning the C-string cstr1a to string str1 gives: Out There. The original string str1 is: Hello. The string str2c is: Wide. The string str1 newly assigned with string str2c is: Wide. The string str3c is: World. The string str1 reassigned with string str3c is: World.
使用字符串中的指定索引提供对字符的引用。
const_reference operator[](size_type _Off) const; reference operator[](size_type _Off);
参数
_Off
要引用的元素的位置的索引。
返回值
对字符串中指定的参数索引的位置的字符的引用。
备注
该字符串的第一个元素的索引为零，并且以下元素连续方式进行索引的正整数，以便长度的字符串n具有nth 元素的数量来索引n -1。
operator[]成员函数比快在提供读取和写入访问权限字符串的元素。
operator[]不会检查作为参数传递的索引是否有效，但成员函数在未和，因此应使用有效性中不能确保。 无效的索引 (索引小于零或大于或等于字符串的大小) 传递给成员函数在引发out_of_range 类异常。 无效的索引传递给operator[]导致未定义的行为，但索引等于字符串的长度是常量字符串的有效索引，该运算符将返回 null 字符时传递此索引。
返回的引用，可能会失效字符串重新分配或修改非const字符串。
使用编译时_迭代器_调试_级别设置为 1 或 2 时，运行时将发生错误如果你尝试访问的字符串的边界以外的元素。 有关更多信息，请参见 Checked Iterators。
示例
// basic_string_op_ref.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ( "Hello world" ), str2 ( "Goodbye world" );
const string cstr1 ( "Hello there" ), cstr2 ( "Goodbye now" );
cout << "The original string str1 is: " << str1 << endl;
cout << "The original string str2 is: " << str2 << endl;
// Element access to the non-const strings
basic_string <char>::reference refStr1 = str1 [6];
basic_string <char>::reference refStr2 = str2.at ( 3 );
cout << "The character with an index of 6 in string str1 is: "
<< refStr1 << "." << endl;
cout << "The character with an index of 3 in string str2 is: "
<< refStr2 << "." << endl;
// Element access to the const strings
basic_string <char>::const_reference crefStr1 = cstr1 [ cstr1.length ( ) ];
basic_string <char>::const_reference crefStr2 = cstr2.at ( 8 );
if ( crefStr1 == '\0' )
cout << "The null character is returned as a valid reference."
<< endl;
else
cout << "The null character is not returned." << endl;
cout << "The character with index of 8 in the const string cstr2 is: "
<< crefStr2 << "." << endl;
}
提供指向字符串中或字符数组中字符元素的指针的类型。
typedef typename allocator_type::pointer pointer;
备注
类型为同义词allocator_type::pointer。
类型为字符串，它等效于char*。
示例
// basic_string_pointer.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
basic_string<char>::pointer pstr1a = "In Here";
char *cstr1b = "Out There";
cout << "The string pstr1a is: " << pstr1a << "." << endl;
cout << "The C-string cstr1b is: " << cstr1b << "." << endl;
}
Output
The string pstr1a is: In Here. The C-string cstr1b is: Out There.
删除字符串的最后一个元素。
void pop_back();
备注
此成员函数可有效地调用 erase(size() - 1)，以清除序列（必须为非空）的最后一个元素。
在字符串的末尾处添加一个元素。
void push_back(value_type _Ch);
参数
_Ch
要添加到字符串结尾的字符。
备注
示例
// basic_string_push_back.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ( "abc" );
basic_string <char>::iterator str_Iter, str1_Iter;
cout << "The original string str1 is: ";
for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
cout << *str_Iter;
cout << endl;
// str1.push_back ( 'd' );
str1_Iter = str1.end ( );
str1_Iter--;
cout << "The last character-letter of the modified str1 is now: "
<< *str1_Iter << endl;
cout << "The modified string str1 is: ";
for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
cout << *str_Iter;
cout << endl;
}
Output
The original string str1 is: abc The last character-letter of the modified str1 is now: c The modified string str1 is: abc
返回指向反向字符串中第一个元素的迭代器。
const_reverse_iterator rbegin() const; reverse_iterator rbegin();
返回值
在发现反向字符串中，处理将在相应的非反向字符串中的最后一个元素的内容的第一个元素返回随机访问迭代器。
备注
rbegin用于发现反向字符串就像开始与字符串一起使用。
如果返回值为rbegin分配给const_reverse_iterator，不能修改字符串对象。 如果返回值为rbegin分配给reverse_iterator，可以修改字符串对象。
rbegin可以用于向后初始化循环访问字符串。
示例
// basic_string_rbegin.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ( "Able was I ere I saw Elba" ), str2;
basic_string <char>::reverse_iterator str_rIter, str1_rIter, str2_rIter;
basic_string <char>::const_reverse_iterator str1_rcIter;
str1_rIter = str1.rbegin ( );
// str1_rIter--;
cout << "The first character-letter of the reversed string str1 is: "
<< *str1_rIter << endl;
cout << "The full reversed string str1 is:\n ";
for ( str_rIter = str1.rbegin( ); str_rIter != str1.rend( ); str_rIter++ )
cout << *str_rIter;
cout << endl;
// The dereferenced iterator can be used to modify a character
*str1_rIter = 'A';
cout << "The first character-letter of the modified str1 is now: "
<< *str1_rIter << endl;
cout << "The full modified reversed string str1 is now:\n ";
for ( str_rIter = str1.rbegin( ); str_rIter != str1.rend( ); str_rIter++ )
cout << *str_rIter;
cout << endl;
// The following line would be an error because iterator is const
// *str1_rcIter = 'A';
// For an empty string, begin is equivalent to end
if ( str2.rbegin( ) == str2.rend ( ) )
cout << "The string str2 is empty." << endl;
else
cout << "The stringstr2 is not empty." << endl;
}
Output
The first character-letter of the reversed string str1 is: a The full reversed string str1 is: ablE was I ere I saw elbA The first character-letter of the modified str1 is now: A The full modified reversed string str1 is now: AblE was I ere I saw elbA The string str2 is empty.
提供对存储在字符串中的元素的引用的类型。
typedef typename allocator_type::reference reference;
备注
一种类型引用可以用于修改元素的值。
类型为同义词allocator_type::reference。
类型为字符串，它等效于chr.。
示例
请参阅示例在以举例说明如何声明和使用引用。
返回发现反向字符串中的最后一个元素之后的位置的迭代器。
const_reverse_iterator rend() const; reverse_iterator rend();
返回值
一个反向随机访问迭代器用于发现反向字符串中的最后一个元素之后的位置。
备注
rend用于发现反向字符串就像结束与字符串一起使用。
如果返回值为rend分配给const_reverse_iterator，不能修改字符串对象。 如果返回值为rend分配给reverse_iterator，可以修改字符串对象。
rend可以用于测试是否反向迭代器已到达其字符串的末尾。
不应对 rend 返回的值取消引用。
示例
// basic_string_rend.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ("Able was I ere I saw Elba"), str2;
basic_string <char>::reverse_iterator str_rIter, str1_rIter, str2_rIter;
basic_string <char>::const_reverse_iterator str1_rcIter;
str1_rIter = str1.rend ( );
str1_rIter--;
cout << "The last character-letter of the reversed string str1 is: "
<< *str1_rIter << endl;
cout << "The full reversed string str1 is:\n ";
for ( str_rIter = str1.rbegin( ); str_rIter != str1.rend( ); str_rIter++ )
cout << *str_rIter;
cout << endl;
// The dereferenced iterator can be used to modify a character
*str1_rIter = 'o';
cout << "The last character-letter of the modified str1 is now: "
<< *str1_rIter << endl;
cout << "The full modified reversed string str1 is now:\n ";
for ( str_rIter = str1.rbegin( ); str_rIter != str1.rend( ); str_rIter++ )
cout << *str_rIter;
cout << endl;
// The following line would be an error because iterator is const
// *str1_rcIter = 'T';
// For an empty string, end is equivalent to begin
if ( str2.rbegin( ) == str2.rend ( ) )
cout << "The string str2 is empty." << endl;
else
cout << "The stringstr2 is not empty." << endl;
}
Output
The last character-letter of the reversed string str1 is: A The full reversed string str1 is: ablE was I ere I saw elbA The last character-letter of the modified str1 is now: o The full modified reversed string str1 is now: ablE was I ere I saw elbo The string str2 is empty.
用指定字符或者从其他范围、字符串或 C 字符串复制的字符来替代字符串中指定位置的元素。
basic_string<CharType, Traits, Allocator>& replace(
size_type _Pos1,
size_type _Num1,
const value_type* ptr);
basic_string<CharType, Traits, Allocator>& replace(
size_type _Pos1,
size_type _Num1,
const basic_string<CharType, Traits, Allocator>& str);
basic_string<CharType, Traits, Allocator>& replace(
size_type _Pos1,
size_type _Num1,
const value_type* ptr,
size_type _Num2);
basic_string<CharType, Traits, Allocator>& replace(
size_type _Pos1,
size_type _Num1,
const basic_string<CharType, Traits, Allocator>& str,
size_type _Pos2,
size_type _Num2);
basic_string<CharType, Traits, Allocator>& replace(
size_type _Pos1,
size_type _Num1,
size_type count,
value_type _Ch);
basic_string<CharType, Traits, Allocator>& replace(
iterator first0,
iterator last0,
const value_type* ptr);
basic_string<CharType, Traits, Allocator>& replace(
iterator first0,
iterator last0,
const basic_string<CharType, Traits, Allocator>& str);
basic_string<CharType, Traits, Allocator>& replace(
iterator first0,
iterator last0,
const value_type* ptr,
size_type _Num2);
basic_string<CharType, Traits, Allocator>& replace(
iterator first0,
iterator last0,
size_type _Num2,
value_type _Ch);
template <class InputIterator>
basic_string<CharType, Traits, Allocator>& replace(
iterator first0,
iterator last0,
InputIterator first,
InputIterator last);
basic_string<CharType, Traits, Allocator>& replace(
iterator first0,
iterator last0,
const_pointer first,
const_pointer last);
basic_string<CharType, Traits, Allocator>& replace(
iterator first0,
iterator last0,
const_iterator first,
const_iterator last);
参数
str
将是操作数字符串的字符的源字符串。
_Pos1
操作数字符串替换开始的索引。
_Num1
最大操作数字符串中要替换的字符数。
_Pos2
参数字符串在其开始复制的索引。
_Num2
最大参数 C 字符串中使用的字符数。
ptr
C 字符串，它将是操作数字符串的字符的源。
_Ch
要复制到操作数字符串的字符。
first0 *
发现的迭代器的第一个字符在操作数字符串中删除。last0 *
发现的迭代器的最后一个字符在操作数字符串中删除。
first
迭代器、 const_pointer 或 const_iterator 寻址的第一个字符在参数字符串中复制。
last
迭代器、 const_pointer 或 const_iterator 寻址的最后一个字符在参数字符串中复制。
count
次数_Ch复制到操作数字符串。
返回值
操作数进行替换字符串。
示例
// basic_string_replace.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first two member functions replace
// part of the operand string with
// characters from a parameter string or C-string
string result1a, result1b;
string s1o ( "AAAAAAAA" );
string s1p ( "BBB" );
const char* cs1p = "CCC";
cout << "The operand string s1o is: " << s1o << endl;
cout << "The parameter string s1p is: " << s1p << endl;
cout << "The parameter C-string cs1p is: " << cs1p << endl;
result1a = s1o.replace ( 1 , 3 , s1p );
cout << "The result of s1o.replace ( 1 , 3 , s1p )\n is "
<< "the string: " << result1a << "." << endl;
result1b = s1o.replace ( 5 , 3 , cs1p );
cout << "The result of s1o.replace ( 5 , 3 , cs1p )\n is "
<< "the string: " << result1b << "." << endl;
cout << endl;
// The third & fourth member function replace
// part of the operand string with characters
// form part of a parameter string or C-string
string result2a, result2b;
string s2o ( "AAAAAAAA" );
string s2p ( "BBB" );
const char* cs2p = "CCC";
cout << "The operand string s2o is: " << s2o << endl;
cout << "The parameter string s1p is: " << s2p << endl;
cout << "The parameter C-string cs2p is: " << cs2p << endl;
result2a = s2o.replace ( 1 , 3 , s2p , 1 , 2 );
cout << "The result of s2o.replace (1, 3, s2p, 1, 2)\n is "
<< "the string: " << result2a << "." << endl;
result2b = s2o.replace ( 4 , 3 , cs2p , 1 );
cout << "The result of s2o.replace (4 ,3 ,cs2p)\n is "
<< "the string: " << result2b << "." << endl;
cout << endl;
// The fifth member function replaces
// part of the operand string with characters
string result3a;
string s3o ( "AAAAAAAA" );
char ch3p = 'C';
cout << "The operand string s3o is: " << s3o << endl;
cout << "The parameter character c1p is: " << ch3p << endl;
result3a = s3o.replace ( 1 , 3 , 4 , ch3p );
cout << "The result of s3o.replace(1, 3, 4, ch3p)\n is "
<< "the string: " << result3a << "." << endl;
cout << endl;
// The sixth & seventh member functions replace
// part of the operand string, delineated with iterators,
// with a parameter string or C-string
string s4o ( "AAAAAAAA" );
string s4p ( "BBB" );
const char* cs4p = "CCC";
cout << "The operand string s4o is: " << s4o << endl;
cout << "The parameter string s4p is: " << s4p << endl;
cout << "The parameter C-string cs4p is: " << cs4p << endl;
basic_string<char>::iterator IterF0, IterL0;
IterF0 = s4o.begin ( );
IterL0 = s4o.begin ( ) + 3;
string result4a, result4b;
result4a = s4o.replace ( IterF0 , IterL0 , s4p );
cout << "The result of s1o.replace (IterF0, IterL0, s4p)\n is "
<< "the string: " << result4a << "." << endl;
result4b = s4o.replace ( IterF0 , IterL0 , cs4p );
cout << "The result of s4o.replace (IterF0, IterL0, cs4p)\n is "
<< "the string: " << result4b << "." << endl;
cout << endl;
// The 8th member function replaces
// part of the operand string delineated with iterators
// with a number of characters from a parameter C-string
string s5o ( "AAAAAAAF" );
const char* cs5p = "CCCBB";
cout << "The operand string s5o is: " << s5o << endl;
cout << "The parameter C-string cs5p is: " << cs5p << endl;
basic_string<char>::iterator IterF1, IterL1;
IterF1 = s5o.begin ( );
IterL1 = s5o.begin ( ) + 4;
string result5a;
result5a = s5o.replace ( IterF1 , IterL1 , cs5p , 4 );
cout << "The result of s5o.replace (IterF1, IterL1, cs4p ,4)\n is "
<< "the string: " << result5a << "." << endl;
cout << endl;
// The 9th member function replaces
// part of the operand string delineated with iterators
// with specified characters
string s6o ( "AAAAAAAG" );
char ch6p = 'q';
cout << "The operand string s6o is: " << s6o << endl;
cout << "The parameter character ch6p is: " << ch6p << endl;
basic_string<char>::iterator IterF2, IterL2;
IterF2 = s6o.begin ( );
IterL2 = s6o.begin ( ) + 3;
string result6a;
result6a = s6o.replace ( IterF2 , IterL2 , 4 , ch6p );
cout << "The result of s6o.replace (IterF1, IterL1, 4, ch6p)\n is "
<< "the string: " << result6a << "." << endl;
cout << endl;
// The 10th member function replaces
// part of the operand string delineated with iterators
// with part of a parameter string delineated with iterators
string s7o ( "OOOOOOO" );
string s7p ( "PPPP" );
cout << "The operand string s7o is: " << s7o << endl;
cout << "The parameter string s7p is: " << s7p << endl;
basic_string<char>::iterator IterF3, IterL3, IterF4, IterL4;
IterF3 = s7o.begin ( ) + 1;
IterL3 = s7o.begin ( ) + 3;
IterF4 = s7p.begin ( );
IterL4 = s7p.begin ( ) + 2;
string result7a;
result7a = s7o.replace ( IterF3 , IterL3 , IterF4 , IterL4 );
cout << "The result of s7o.replace (IterF3 ,IterL3 ,IterF4 ,IterL4)\n is "
<< "the string: " << result7a << "." << endl;
cout << endl;
}
Output
The operand string s1o is: AAAAAAAA The parameter string s1p is: BBB The parameter C-string cs1p is: CCC The result of s1o.replace ( 1 , 3 , s1p ) is the string: ABBBAAAA. The result of s1o.replace ( 5 , 3 , cs1p ) is the string: ABBBACCC. The operand string s2o is: AAAAAAAA The parameter string s1p is: BBB The parameter C-string cs2p is: CCC The result of s2o.replace (1, 3, s2p, 1, 2) is the string: ABBAAAA. The result of s2o.replace (4 ,3 ,cs2p) is the string: ABBAC. The operand string s3o is: AAAAAAAA The parameter character c1p is: C The result of s3o.replace(1, 3, 4, ch3p) is the string: ACCCCAAAA. The operand string s4o is: AAAAAAAA The parameter string s4p is: BBB The parameter C-string cs4p is: CCC The result of s1o.replace (IterF0, IterL0, s4p) is the string: BBBAAAAA. The result of s4o.replace (IterF0, IterL0, cs4p) is the string: CCCAAAAA. The operand string s5o is: AAAAAAAF The parameter C-string cs5p is: CCCBB The result of s5o.replace (IterF1, IterL1, cs4p ,4) is the string: CCCBAAAF. The operand string s6o is: AAAAAAAG The parameter character ch6p is: q The result of s6o.replace (IterF1, IterL1, 4, ch6p) is the string: qqqqAAAAG. The operand string s7o is: OOOOOOO The parameter string s7p is: PPPP The result of s7o.replace (IterF3 ,IterL3 ,IterF4 ,IterL4) is the string: OPPOOOO.
将字符串的容量设置为一个数目，这个数目至少应与指定数目一样大。
void reserve(size_type count = 0);
参数
count
为其保留内存的字符数。
备注
具有足够的容量很重要，因为重新分配是一个耗时的过程，使所有引用、 指针和引用字符串中字符的迭代器都失效。
对象的类型字符串的概念是向量的容量的相同的类型对象。 与不同的是矢量，成员函数保留可能调用收缩对象的容量。 该请求是 nonbinding 和可能或可能不会发生。 为默认值为参数的值为零，调用保留是缩小字符串的容量，以适合的字符数当前字符串中的非绑定请求。 容量是永远不会减少为小于当前的字符数。
调用reserve是缩小字符串的容量的唯一可能方法。 但是，如上文所述，此请求是 nonbinding 和可能不会发生。
示例
// basic_string_reserve.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ("Hello world");
cout << "The original string str1 is: " << str1 << endl;
basic_string <char>::size_type sizeStr1, sizerStr1;
sizeStr1 = str1.size ( );
basic_string <char>::size_type capStr1, caprStr1;
capStr1 = str1.capacity ( );
// Compare size & capacity of the original string
cout << "The current size of original string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The capacity of original string str1 is: "
<< capStr1 << "." << endl << endl;
// Compare size & capacity of the string
// with added capacity
str1.reserve ( 40 );
sizerStr1 = str1.size ( );
caprStr1 = str1.capacity ( );
cout << "The string str1with augmented capacity is: "
<< str1 << endl;
cout << "The current size of string str1 is: "
<< sizerStr1 << "." << endl;
cout << "The new capacity of string str1 is: "
<< caprStr1 << "." << endl << endl;
// Compare size & capacity of the string
// with downsized capacity
str1.reserve ( );
basic_string <char>::size_type sizedStr1;
basic_string <char>::size_type capdStr1;
sizedStr1 = str1.size ( );
capdStr1 = str1.capacity ( );
cout << "The string str1 with downsized capacity is: "
<< str1 << endl;
cout << "The current size of string str1 is: "
<< sizedStr1 << "." << endl;
cout << "The reduced capacity of string str1 is: "
<< capdStr1 << "." << endl << endl;
}
Output
The original string str1 is: Hello world The current size of original string str1 is: 11. The capacity of original string str1 is: 15. The string str1with augmented capacity is: Hello world The current size of string str1 is: 11. The new capacity of string str1 is: 47. The string str1 with downsized capacity is: Hello world The current size of string str1 is: 11. The reduced capacity of string str1 is: 47.
根据要求追加或删除元素，为字符串指定新的大小。
void resize(
size_type count,);
void resize(
size_type count,
_Elem _Ch);
参数
count
字符串的新大小。
_Ch
如果其他元素是必需的使用追加的字符的值进行初始化。
备注
如果所生成的大小超过最大字符数，将引发该窗体length_error。
示例
// basic_string_resize.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ( "Hello world" );
cout << "The original string str1 is: " << str1 << endl;
basic_string <char>::size_type sizeStr1;
sizeStr1 = str1.size ( );
basic_string <char>::size_type capStr1;
capStr1 = str1.capacity ( );
// Compare size & capacity of the original string
cout << "The current size of original string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The capacity of original string str1 is: "
<< capStr1 << "." << endl << endl;
// Use resize to increase size by 2 elements: exclamations
str1.resize ( str1.size ( ) + 2 , '!' );
cout << "The resized string str1 is: " << str1 << endl;
sizeStr1 = str1.size ( );
capStr1 = str1.capacity ( );
// Compare size & capacity of a string after resizing
cout << "The current size of resized string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The capacity of resized string str1 is: "
<< capStr1 << "." << endl << endl;
// Use resize to increase size by 20 elements:
str1.resize ( str1.size ( ) + 20 );
cout << "The resized string str1 is: " << str1 << endl;
sizeStr1 = str1.size ( );
capStr1 = str1.capacity ( );
// Compare size & capacity of a string after resizing
// note capacity increases automatically as required
cout << "The current size of modified string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The capacity of modified string str1 is: "
<< capStr1 << "." << endl << endl;
// Use resize to downsize by 28 elements:
str1.resize ( str1.size ( ) - 28 );
cout << "The downsized string str1 is: " << str1 << endl;
sizeStr1 = str1.size ( );
capStr1 = str1.capacity ( );
// Compare size & capacity of a string after downsizing
cout << "The current size of downsized string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The capacity of downsized string str1 is: "
<< capStr1 << "." << endl;
}
Output
The original string str1 is: Hello world The current size of original string str1 is: 11. The capacity of original string str1 is: 15. The resized string str1 is: Hello world!! The current size of resized string str1 is: 13. The capacity of resized string str1 is: 15. The resized string str1 is: Hello world!! The current size of modified string str1 is: 33. The capacity of modified string str1 is: 47. The downsized string str1 is: Hello The current size of downsized string str1 is: 5. The capacity of downsized string str1 is: 47.
提供对存储在字符串中的元素的引用的类型。
typedef std::reverse_iterator<iterator> reverse_iterator;
备注
一种类型reverse_iterator可以用于修改字符的值，用于循环访问字符串按相反的顺序。
示例
请参阅示例rbegin以举例说明如何声明和使用reverse_iterator。
向后搜索字符串，搜索与指定字符序列匹配的第一个子字符串。
size_type rfind(
value_type _Ch,
size_type _Off = npos) const;
size_type rfind(
const value_type* ptr,
size_type _Off = npos) const;
size_type rfind(
const value_type* ptr,
size_type _Off,
size_type count) const;
size_type rfind(
const basic_string<CharType, Traits, Allocator>& str,
size_type _Off = npos) const;
参数
_Ch
成员函数要搜索的字符值。
_Off
搜索开始处的索引。
ptr
成员函数要搜索的 C 字符串。
count
在成员函数要搜索的 C 字符串中从第一个字符开始计数的字符数。
str
成员函数要搜索的字符串。
返回值
最后一个匹配项时向后搜索的子字符串时成功，则第一个字符的索引否则为npos。
示例
// basic_string_rfind.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// The first member function
// searches for a single character in a string
string str1 ( "Hello Everyone" );
cout << "The original string str1 is: " << str1 << endl;
basic_string <char>::size_type indexCh1a, indexCh1b;
static const basic_string <char>::size_type npos = -1;
indexCh1a = str1.rfind ( "e" , 9 );
if ( indexCh1a != npos )
cout << "The index of the 1st 'e' found before the 9th"
<< " position in str1 is: " << indexCh1a << endl;
else
cout << "The character 'e' was not found in str1 ." << endl;
indexCh1b = str1.rfind ( "x" );
if ( indexCh1b != npos )
cout << "The index of the 'x' found in str1 is: "
<< indexCh1b << endl << endl;
else
cout << "The character 'x' was not found in str1."
<< endl << endl;
// The second member function searches a string
// for a substring as specified by a C-string
string str2 ( "Let me make this perfectly clear." );
cout << "The original string str2 is: " << str2 << endl;
basic_string <char>::size_type indexCh2a, indexCh2b;
const char *cstr2 = "perfect";
indexCh2a = str2.rfind ( cstr2 , 30 );
if ( indexCh2a != npos )
cout << "The index of the 1st element of 'perfect' "
<< "before\n the 30th position in str2 is: "
<< indexCh2a << endl;
else
cout << "The substring 'perfect' was not found in str2 ."
<< endl;
const char *cstr2b = "imperfectly";
indexCh2b = str2.rfind ( cstr2b , 30 );
if ( indexCh2b != npos )
cout << "The index of the 1st element of 'imperfect' "
<< "before\n the 5th position in str3 is: "
<< indexCh2b << endl;
else
cout << "The substring 'imperfect' was not found in str2 ."
<< endl << endl;
// The third member function searches a string
// for a substring as specified by a C-string
string str3 ( "It is a nice day. I am happy." );
cout << "The original string str3 is: " << str3 << endl;
basic_string <char>::size_type indexCh3a, indexCh3b;
const char *cstr3a = "nice";
indexCh3a = str3.rfind ( cstr3a );
if ( indexCh3a != npos )
cout << "The index of the 1st element of 'nice' "
<< "in str3 is: " << indexCh3a << endl;
else
cout << "The substring 'nice' was not found in str3 ."
<< endl;
const char *cstr3b = "am";
indexCh3b = str3.rfind ( cstr3b , indexCh3a + 25 , 2 );
if ( indexCh3b != npos )
cout << "The index of the next occurrance of 'am' in "
<< "str3 begins at: " << indexCh3b << endl << endl;
else
cout << "There is no next occurrence of 'am' in str3 ."
<< endl << endl;
// The fourth member function searches a string
// for a substring as specified by a string
string str4 ( "This perfectly unclear." );
cout << "The original string str4 is: " << str4 << endl;
basic_string <char>::size_type indexCh4a, indexCh4b;
string str4a ( "clear" );
indexCh4a = str4.rfind ( str4a , 15 );
if (indexCh4a != npos )
cout << "The index of the 1st element of 'clear' "
<< "before\n the 15th position in str4 is: "
<< indexCh4a << endl;
else
cout << "The substring 'clear' was not found in str4 "
<< "before the 15th position." << endl;
string str4b ( "clear" );
indexCh4b = str4.rfind ( str4b );
if ( indexCh4b != npos )
cout << "The index of the 1st element of 'clear' "
<< "in str4 is: "
<< indexCh4b << endl;
else
cout << "The substring 'clear' was not found in str4 ."
<< endl << endl;
}
Output
The original string str1 is: Hello Everyone The index of the 1st 'e' found before the 9th position in str1 is: 8 The character 'x' was not found in str1. The original string str2 is: Let me make this perfectly clear. The index of the 1st element of 'perfect' before the 30th position in str2 is: 17 The substring 'imperfect' was not found in str2 . The original string str3 is: It is a nice day. I am happy. The index of the 1st element of 'nice' in str3 is: 8 The index of the next occurrance of 'am' in str3 begins at: 20 The original string str4 is: This perfectly unclear. The substring 'clear' was not found in str4 before the 15th position. The index of the 1st element of 'clear' in str4 is: 17
放弃字符串的超出容量。
void shrink_to_fit();
备注
此成员函数可以消除容器中任何不必要的存储。
返回字符串中元素的当前数目。
size_type size() const;
返回值
字符串的长度。
示例
// basic_string_size.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ("Hello world");
cout << "The original string str1 is: " << str1 << endl;
// The size and length member functions differ in name only
basic_string <char>::size_type sizeStr1, lenStr1;
sizeStr1 = str1.size ( );
lenStr1 = str1.length ( );
basic_string <char>::size_type capStr1, max_sizeStr1;
capStr1 = str1.capacity ( );
max_sizeStr1 = str1.max_size ( );
// Compare size, length, capacity & max_size of a string
cout << "The current size of original string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The current length of original string str1 is: "
<< lenStr1 << "." << endl;
cout << "The capacity of original string str1 is: "
<< capStr1 << "." << endl;
cout << "The max_size of original string str1 is: "
<< max_sizeStr1 << "." << endl << endl;
str1.erase ( 6, 5 );
cout << "The modified string str1 is: " << str1 << endl;
sizeStr1 = str1.size ( );
lenStr1 = str1.length ( );
capStr1 = str1.capacity ( );
max_sizeStr1 = str1.max_size ( );
// Compare size, length, capacity & max_size of a string
// after erasing part of the original string
cout << "The current size of modified string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The current length of modified string str1 is: "
<< lenStr1 << "." << endl;
cout << "The capacity of modified string str1 is: "
<< capStr1 << "." << endl;
cout << "The max_size of modified string str1 is: "
<< max_sizeStr1 << "." << endl;
}
无符号的整数类型可表示的元素数、 字符串中的索引。
typedef typename allocator_type::size_type size_type;
备注
它等效于allocator_type::size_type。
类型为字符串，它等效于size_t。
示例
// basic_string_size_type.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ( "Hello world" );
basic_string <char>::size_type sizeStr1, capStr1;
sizeStr1 = str1.size ( );
capStr1 = str1.capacity ( );
cout << "The current size of string str1 is: "
<< sizeStr1 << "." << endl;
cout << "The capacity of string str1 is: " << capStr1
<< "." << endl;
}
Output
The current size of string str1 is: 11. The capacity of string str1 is: 15.
从字符串起始处的指定位置复制最多某个数目的字符的子字符串。
basic_string<CharType, Traits, Allocator> substr(
size_type _Off = 0,
size_type count = npos) const;
参数
_Off
查找从该字符串的副本进行，默认值为 0 的位置处的元素索引。
count
如果它们存在要复制的字符数。
返回值
子字符串对象，第一个参数指定的位置开始的字符串操作数中的元素的副本。
示例
// basic_string_substr.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
string str1 ("Heterological paradoxes are persistent.");
cout << "The original string str1 is: \n " << str1
<< endl << endl;
basic_string <char> str2 = str1.substr ( 6 , 7 );
cout << "The substring str1 copied is: " << str2
<< endl << endl;
basic_string <char> str3 = str1.substr ( );
cout << "The default substring str3 is: \n " << str3
<< "\n which is the entire original string." << endl;
}
Output
The original string str1 is: Heterological paradoxes are persistent. The substring str1 copied is: logical The default substring str3 is: Heterological paradoxes are persistent. which is the entire original string.
交换两个字符串的内容。
void swap(
basic_string<CharType, Traits, Allocator>& str);
参数
str
其元素将要与那些与目标字符串中交换的源字符串。
备注
如果被交换的字符串具有相同的分配器对象，swap成员函数︰
在常量时间内发生。
不引发异常。
没有引用、 指针或指定两个字符串中的元素的迭代器失效。
否则，它所执行的元素分配和构造函数调用数量会与两个受控序列中的元素数量成正比。
示例
// basic_string_swap.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
// Declaring an objects of type basic_string<char>
string s1 ( "Tweedledee" );
string s2 ( "Tweedledum" );
cout << "Before swapping string s1 and s2:" << endl;
cout << " The basic_string s1 = " << s1 << "." << endl;
cout << " The basic_string s2 = " << s2 << "." << endl;
s1.swap ( s2 );
cout << "After swapping string s1 and s2:" << endl;
cout << " The basic_string s1 = " << s1 << "." << endl;
cout << " The basic_string s2 = " << s2 << "." << endl;
}
Output
Before swapping string s1 and s2: The basic_string s1 = Tweedledee. The basic_string s2 = Tweedledum. After swapping string s1 and s2: The basic_string s1 = Tweedledum. The basic_string s2 = Tweedledee.
存储在字符串中的元素的字符特征的一个类型。
typedef Traits traits_type;
备注
类型是第二个模板参数的同义词特征。
类型为字符串，它等效于char_traits<>>。
示例
请参阅示例副本以举例说明如何声明和使用traits_type。
表示存储在字符串中的字符的类型的类型。
typedef typename allocator_type::value_type value_type;
备注
它等效于traits_type::char_type ，等同于char类型的对象字符串。
示例
// basic_string_value_type.cpp
// compile with: /EHsc
#include <string>
#include <iostream>
int main( )
{
using namespace std;
basic_string<char>::value_type ch1 = 'G';
char ch2 = 'H';
cout << "The character ch1 is: " << ch1 << "." << endl;
cout << "The character ch2 is: " << ch2 << "." << endl;
}
Output
The character ch1 is: G. The character ch2 is: H.
541
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
