rope<T, Alloc>


类别：容器	组件类型：类型

描述

Rope是一种可伸缩的字符串实现：它们被设计为高效地操作整个字符串。诸如赋值、连接和子字符串之类的操作所花费的时间几乎与字符串的长度无关。与 C 字符串不同，rope对于非常长的字符串（如编辑缓冲区或邮件消息）来说，是一种合理的表示形式。[1]

尽管rope可以将 rope 视为字符的容器，并且几乎是序列，但这很少是完成任务的最有效方法。替换一个rope中的单个字符是很慢的：每次字符替换基本上都由两个子字符串操作和两个连接操作组成。Roperope

主要针对更函数式的编程风格。vector<char>或引用计数的字符串实现在以下方面有所不同。

优点

涉及长字符串的连接和子字符串操作速度快得多。在 10 兆字节的 rope 中间插入一个字符应该花费大约 10 微秒的时间，即使保留原始字符串的副本，例如，作为编辑历史的一部分。相比之下，对于传统的“扁平”字符串表示形式，这将花费大约一秒钟的时间。对于大多数应用程序，连接所需的时间可以视为常数。使用rope作为文本编辑器中文件的表示形式是完全合理的。
潜在地具有更好的空间性能。rope的微小修改可以与原始字符串共享内存。Rope以小块分配，显著减少了大块内存引入的内存碎片问题。
赋值只是一个（可能是引用计数的）指针赋值。与引用计数的写时复制实现不同，即使其中一个副本随后略作修改，这仍然在很大程度上成立。检查字符串的旧版本非常便宜，例如，在编辑历史记录中。
可以将生成字符的函数视为rope。因此，一段 rope 可能是一个 100MB 的文件，该文件仅在检查字符串的该部分时才读取。将字符串连接到此类文件的末尾不会涉及读取文件。（目前，此功能的实现尚不完整。）

缺点

在rope中的单个字符替换开销很大。字符更新需要的时间大致与字符串长度的对数成正比。它被实现为两个子字符串操作，后跟两个连接操作。
可以通过rope的const_iterator以均摊常数时间逐个字符地检查，就像对于vector<char>一样。然而，对于vector<char>慢了一个显著的常数因子（如果对每个字符的处理很少且字符串很长，则大约为 5 或 10 的因子）。非常量迭代器涉及额外的检查，因此仍然会稍微慢一些。（我们期望最终某些通用算法将被专门化，以便不会遇到这种成本。目前，仅以这种方式处理输出、转换为 C 字符串和单字符查找成员函数。）
迭代器的大小大约为十几个字。这意味着复制它们虽然不是非常昂贵，但也不是一项微不足道的操作。避免使用后增量迭代器；尽可能使用前增量。（该接口还提供了使用整数字符位置索引到字符串中的原语。传递位置显然便宜得多，但这使得索引操作开销很大，再次与 rope 的长度大致成对数关系。）

在其他编程语言中先前实现的经验表明，rope作为程序中字符串的正常或默认表示形式是一个不错的选择。在对遍历或就地更新的性能特别敏感的地方，偶尔需要使用某种类型的字符数组，例如vector<char>。但是，使用rope可以最大程度地减少由于意外的长字符串输入而导致程序运行时间变得无法容忍的情况。

可以通过rope几乎但不完全是序列。它支持随机访问 const_iterators。向前或向后遍历每次操作花费常数时间。还提供了非常量迭代器。但是，通过非常量迭代器进行赋值是一项开销很大的操作（基本上是对数时间，但具有很大的常数）。应在频繁执行的代码中避免这种情况。

为了阻止意外使用开销很大的操作，begin和endrope 上的成员函数返回const_iterator。如果需要非常量迭代器，则应使用成员函数mutable_begin和mutable_end。

对rope的任何修改都会使引用该 rope 的常量迭代器失效。在更新后，可变迭代器引用同一rope中的相同位置。（如果迭代器引用插入点之后的位置，这可能会令人惊讶。）它们保持有效，除非迭代器引用的位置超过结果rope.

末尾的一个位置。

定义rope类和 rope 头文件是 SGI 扩展；它们不是 C++ 标准的一部分。

示例

crope r(1000000, 'x');          // crope is rope<char>. wrope is rope<wchar_t>
                                // Builds a rope containing a million 'x's.
                                // Takes much less than a MB, since the
                                // different pieces are shared.
crope r2 = r + "abc" + r;       // concatenation; takes on the order of 100s
                                // of machine instructions; fast
crope r3 = r2.substr(1000000, 3);       // yields "abc"; fast.
crope r4 = r2.substr(1000000, 1000000); // also fast.
reverse(r2.mutable_begin(), r2.mutable_end());
                                // correct, but slow; may take a
                                // minute or more.

模板参数

参数	描述	默认
`T`	的`rope`值类型：通常为`char`或`wchar_t`. [2]
`Alloc`	的`rope`的分配器，用于所有内部内存管理。	`alloc`

模型

随机访问容器。几乎但不完全是前插入序列和后插入序列的模型。

类型要求

无，除非随机访问容器的要求施加的要求。

公共基类

无。

成员

成员	定义位置	描述
`value_type`	容器	的`rope`的值类型，通常`T`为`char`或`wchar_t`.
`difference_type`	容器	带符号的整数类型。
`size_type`	容器	无符号整数类型。
`reference`	容器	对`rope`元素的引用。[3]
`const_reference`	容器	对`T`. [3]
`的常量引用`	容器	pointer`T`. [3]
`指向`	容器	const_pointer`T`. [3]
`指向`	的常量指针	const_reverse_iterator`rope`.
`可逆容器`	的常量指针	的常量迭代器`rope`.
`reverse_iterator`	容器	的可变迭代器`rope`.
`const_iterator`	容器	iterator`rope`.
`用于遍历`	`rope`.	的可变随机访问迭代器`rope`用于遍历
`的常量随机访问迭代器`	`rope`.	的可变随机访问迭代器`rope`rope(const charT* s)`从 C 字符串构造`.
`。`	rope(const charT* s, size_t n)	从`rope`（不一定是空终止的）
`的数组构造`	rope(const charT* s, size_t n)	从`rope`（不一定是空终止的）
`charT`	rope(const charT* s, size_t n)	从`rope`（不一定是空终止的）
`rope(const const_iterator& f, const const_iterator& l)`	`rope`.	序列
`使用范围的副本创建`	容器	。
`rope(const iterator& f, const iterator& l)`	`rope`	rope(const charT* f, const charT* l)
`rope(charT c)`	容器	单字符构造函数。
`rope()`	容器	默认构造函数。
`rope(char_producer<charT>*, size_t, bool)`	容器	见下文。
`rope(const rope& x)`	容器	复制构造函数。`rope`~rope()
`析构函数。`	容器	rope& operator=(const rope&x)`rope`.
`赋值运算符。`	`rope`	void swap(rope& x)`交换两个`
`的内容。`	容器	size_type size() const`rope`返回
`的大小`	容器	size_type length() const`与`.
`相同`	容器	size`const_iterator`size_type max_size() const`rope`.
`保证可表示的最长`	容器	size`const_iterator`的大小。`rope`.
`bool empty() const`	`rope`	size`reverse_iterator`size_type max_size() const`rope`.
`等效于`	`rope`	size`reverse_iterator`的大小。`rope`.
`size() == 0`	的常量指针	const_iterator begin() const`指向`返回一个指向`rope`
`开头的`	的常量指针	const_iterator begin() const`指向`const_iterator end() const`rope`
`指向`	`rope`	const_iterator begin() const`可逆容器`返回一个指向`rope`.
`末尾的`	`rope`	const_iterator begin() const`可逆容器`const_iterator end() const`rope`.
`iterator mutable_begin()`	iterator mutable_end()	const_reverse_iterator rbegin() const`返回一个指向反转`开头的
`const_reverse_iterator rend() const`	iterator mutable_end()	const_reverse_iterator rbegin() const`返回一个指向反转`开头的
`指向反转`	`rope`	const_iterator begin() const`reference`末尾的`返回一个指向反转`iterator mutable_rbegin()
`iterator mutable_rend()`	`rope`.	charT operator[](size_type n) const
`随机访问容器`	rope(const charT* s, size_t n)	返回第
`n`	个元素。	charT at(size_type pos) const
`reference mutable_reference_at(size_type n)`	指向第	n
`个元素的`	个元素。	int compare(const rope&) const
`三向比较。见下文。`	指向第	charT front() const
`返回第一个元素。`	个元素。	charT back() const
`后插入序列`	`rope`	返回最后一个元素。`void push_front()`前插入序列`在前面插入一个新元素。`.
`void push_back(charT)`	rope(const charT* s, size_t n)	在末尾插入一个新元素。`void pop_front()`前插入序列`在前面插入一个新元素。`.
`删除第一个元素。`	rope(const charT* s, size_t n)	在末尾插入一个新元素。`void pop_back()`前插入序列`在前面插入一个新元素。`.
`删除最后一个元素。`	rope(const charT* s, size_t n)	在末尾插入一个新元素。`返回一个指向反转`iterator insert(const iterator& p, const rope& x)`void pop_front()`前插入序列`在前面插入一个新元素。`.
`在`	`rope`	p`在前面插入一个新元素。`.
`之前插入`	`rope`	的内容`从 C 字符串构造`前插入序列`在前面插入一个新元素。`.
`x`	rope(const charT* s, size_t n)	iterator insert(const iterator& p, charT c)`插入`前插入序列`在前面插入一个新元素。`.
iterator insert(const iterator& p, const const_iterator& f, const const_iterator& l)	rope(const charT* s, size_t n)	iterator insert(const iterator& p, charT c)`插入`前插入序列`在前面插入一个新元素。`.
iterator insert(const iterator& p, const iterator& f, const iterator& l)	rope(const charT* s, size_t n)	iterator insert(const iterator& p, charT c)`插入`前插入序列`在前面插入一个新元素。`.
`c`	`rope`	返回最后一个元素。`void push_front()`iterator insert(const iterator& p)`插入`iterator mutable_rbegin()
`charT()`	`rope`	iterator insert(const iterator& p, size_t n, charT c)`void pop_front()`iterator insert(const iterator& p)`插入`iterator mutable_rbegin()
`的`	`rope`	iterator insert(const iterator& p, size_t n, charT c)`void pop_back()`iterator insert(const iterator& p)`插入`iterator mutable_rbegin()
`个副本`	`rope`	在末尾插入一个新元素。`返回一个指向反转`iterator insert(const iterator& p, const rope& x)`void pop_front()`iterator insert(const iterator& p)`插入`iterator mutable_rbegin()
`iterator insert(const iterator& p, const charT* s)`	`rope`	在`插入`iterator mutable_rbegin()
`之前插入 C 字符串`	`rope`	的内容`从 C 字符串构造`iterator insert(const iterator& p)`插入`iterator mutable_rbegin()
`iterator insert(const iterator& p, const charT* s, size_t n)`	`rope`	iterator insert(const iterator& p, charT c)`插入`iterator insert(const iterator& p)`插入`iterator mutable_rbegin()
void insert(size_t i, const const_iterator& f, const const_iterator& l)	`rope`	iterator insert(const iterator& p, charT c)`插入`iterator insert(const iterator& p)`插入`iterator mutable_rbegin()
void insert(size_t i, const iterator& f, const iterator& l)	`rope`	iterator insert(const iterator& p, charT c)`插入`iterator insert(const iterator& p)`插入`iterator mutable_rbegin()
`插入（不一定是空终止的）`	rope(const charT* s, size_t n)	的数组`在前面插入一个新元素。`.
`iterator insert(const iterator& p, const charT* f, const char* l)`	rope(const charT* s, size_t n)	插入范围`插入`.
`[f, l)`	`rope`	void insert(size_t i, const rope& x)`返回一个指向反转`在`插入`iterator mutable_rbegin()
`之前`	`rope`	i
`插入`	`rope`	void insert(size_t i, charT c)`从 C 字符串构造`.
`插入字符`	`rope`	void insert(size_t i)
`插入`	`rope`	charT()`void pop_front()`.
`void insert(size_t i, size_t n, charT c)`	`rope`	charT()`void pop_back()`.
`void insert(size_t i, const charT* s)`	`rope`	在`返回一个指向反转`iterator insert(const iterator& p, const rope& x)`void pop_front()`.
`之前插入 C 字符串`	`rope`	void insert(size_t i, const charT* s, size_t n)`void push_front()`.
`void insert(size_t i, const charT* f, const charT* l)`	`rope`	rope(const charT* f, const charT* l)
`void erase(const iterator& p)`	`rope`	rope(const charT* f, const charT* l)
`擦除`	`rope`	rope(const charT* f, const charT* l)
void replace(const iterator& f, const iterator& l, const charT* s, size_t n)	`rope`	rope(const charT* f, const charT* l)
void replace(const iterator& f1, const iterator& l1, const charT* f2, const charT* l2)	`rope`	rope(const charT* f, const charT* l)
void replace(const iterator& f1, const iterator& l1, const const_iterator& f2, const const_iterator& l2)	`rope`	rope(const charT* f, const charT* l)
void replace(const iterator& f1, const iterator& l1, const iterator& f2, const iterator& l2)	`rope`	rope(const charT* f, const charT* l)
`指向的元素`	`rope`	rope(const charT* f, const charT* l)
`p`	`rope`	rope(const charT* f, const charT* l)
`void erase(const iterator& f, const iterator& l)`	`rope`	rope(const charT* f, const charT* l)
`擦除范围`	`rope`	rope(const charT* f, const charT* l)
void replace(const iterator& p, const charT* f, const charT* l)	`rope`	rope(const charT* f, const charT* l)
void replace(const iterator& p, const_iterator f, const_iterator l)	`rope`	rope(const charT* f, const charT* l)
void replace(const iterator& p, iterator f, iterator l)	`rope`	rope(const charT* f, const charT* l)
`void erase(size_t i, size_t n)`	`rope`	rope(const charT* f, const charT* l)
`擦除从第`	`rope`	rope(const charT* f, const charT* l)
`个元素开始的`	`rope`	rope(const charT* f, const charT* l)
`个元素`	`rope`	rope(const charT* f, const charT* l)
void replace(size_t i, size_t n, const charT* f, const charT* l)	`rope`	rope(const charT* f, const charT* l)
void replace(size_t i, size_t n, const const_iterator& f, const const_iterator& l)	`rope`	rope(const charT* f, const charT* l)
void replace(size_t i, size_t n, const iterator& f, const iterator& l)	`rope`	rope(const charT* f, const charT* l)
`append(const charT* s)`	`rope`	rope(const charT* f, const charT* l)
`追加 C 字符串。`	`rope`	rope(const charT* f, const charT* l)
`append(const charT* s, size_t)`	`rope`	rope(const charT* f, const charT* l)
`追加（不一定是空终止的）`	`rope`	rope(const charT* f, const charT* l)
`的数组`	`rope`	rope(const charT* f, const charT* l)
void replace(size_t i, const const_iterator& f, const const_iterator& l)	`rope`	rope(const charT* f, const charT* l)
void replace(size_t i, const iterator& f, const iterator& l)	`rope`	rope(const charT* f, const charT* l)
`append(const charT* f, const charT* l)`	`rope`	rope(const charT* f, const charT* l)
`追加一个范围。`	`rope`	rope(const charT* f, const charT* l)
`rope substr(迭代器 f, 迭代器 l) const`	`rope`	rope(const charT* f, const charT* l)
`rope substr(常量迭代器 f, 常量迭代器 l) const`	`rope`	rope(const charT* f, const charT* l)
`rope substr(size_t i, size_t n = 1) const`	`rope`	rope(const charT* f, const charT* l)
`void copy(charT* buf) const`	`rope`	将绳 (rope) 复制到字符数组中`从 C 字符串构造`.
size_type copy(size_type pos, size_type n, charT* buf)	`rope`	将绳 (rope) 复制到字符数组中`从 C 字符串构造`.
`const charT* c_str() const`	`rope`	rope(const charT* f, const charT* l)
`void delete_c_str()`	`rope`	rope(const charT* f, const charT* l)
`rope operator+(const rope& L, const rope&R)`	`rope`	连接`L`和`R`。这是一个全局函数，不是成员函数。
`rope& operator+=(rope& L, const rope& R)`	`rope`	在`R`将 R 连接到 L`L`。这是一个全局函数，不是成员函数。
`rope operator+(const rope& L, const charT* s)`	`rope`	连接`L`和`s`。这是一个全局函数，不是成员函数。
`rope& operator+=(rope& L, const charT* s)`	`rope`	在`s`将 R 连接到 L`L`。这是一个全局函数，不是成员函数。
`rope operator+(const rope& L, charT c)`	`rope`	连接`L`和`void pop_front()`。这是一个全局函数，不是成员函数。
`rope& operator+=(rope& L, charT c)`	`rope`	在`void pop_front()`将 R 连接到 L`L`。这是一个全局函数，不是成员函数。
`bool operator<(const rope&, const rope&)`	前向容器	字典序比较。这是一个全局函数，不是成员函数。
`bool operator==(const rope&, const rope*)`	前向容器	测试两个绳 (rope)`rope`是否相等。这是一个全局函数，不是成员函数。
`ostream& operator<<(ostream& os, rope x)`	`rope`	将 x 输出`void push_front()`到流`os`。这是一个全局函数，不是成员函数。

新成员

这些成员没有在随机访问容器要求中定义，而是特定于 rope 的rope:

函数	描述
`用于遍历`	的可变随机访问迭代器`rope`从 C 字符串构造。绳 (rope) 由以`*s`开始，直到但不包括第一个空字符的字符序列组成。
`的常量随机访问迭代器`	的可变随机访问迭代器`rope`从字符数组`从 C 字符串构造`构造。绳 (rope) 由范围`[s, s + n)`中的字符组成。请注意，此范围允许包含嵌入的空字符。
`rope(const const_iterator& f, const const_iterator& l)`	构造一个由单个字符组成的绳 (rope)`void pop_front()`.
`rope(char_producer<charT>* cp, size_t n, bool destroy)`	构造一个大小为 n 的绳 (rope)`返回一个指向反转`，其字符由`cp`按需计算。对象`cp`必须在对结果`rope`绳 (rope)的任何引用，或`rope`从它派生的对象有效时保持有效。如果`destroy`是`true`，那么`delete cp`一旦`cp`不再需要，将自动执行。通常`destroy`将是 true`true`，除非`cp`是指向静态分配存储的指针。在栈上分配`cp`是很少安全的。
`赋值运算符。`	等效于`交换两个`
`bool empty() const`	size`reverse_iterator`size_type max_size() const`rope`。之所以存在此成员函数，是因为可变`rope`迭代器比常量`rope`迭代器开销更大。
`等效于`	size`reverse_iterator`的大小。`rope`。之所以存在此成员函数，是因为可变`rope`迭代器比常量`rope`迭代器开销更大。
`指向`	const_iterator begin() const`可逆容器`返回一个指向`rope`。之所以存在此成员函数，是因为可变`rope`迭代器比常量`rope`迭代器开销更大。
`末尾的`	const_iterator begin() const`可逆容器`const_iterator end() const`rope`。之所以存在此成员函数，是因为可变`rope`迭代器比常量`rope`迭代器开销更大。
`指向反转`	const_iterator begin() const`reference`末尾的`返回一个指向反转`第 i 个元素。之所以存在此成员函数，是因为对`rope`元素的非常量引用开销相当高。
`int compare(const rope& x)`	三向比较，很像标准 C 库中的函数`strcmp`。如果`this`按字典顺序小于`void push_front()`，则返回一个负数；如果`this`按字典顺序大于`void push_front()`，则返回一个正数；如果两者`rope`都不是按字典顺序小于另一个，则返回零。
`后插入序列`	在位置`rope` `void push_front()`之前立即插入`在前面插入一个新元素。`.
`在`	的内容。在位置`在前面插入一个新元素。`之前立即插入 C 字符串。插入的元素是以`*s`开始，直到但不包括第一个空字符的字符序列。
`之前插入`	插入一个字符数组`从 C 字符串构造`。插入的元素是范围`[s, s + n)`中的字符组成。请注意，此范围允许包含嵌入的空字符。
`c`	在位置`rope`x 紧接在位置`插入`iterator mutable_rbegin()
`个副本`	在末尾插入一个新元素。`返回一个指向反转`iterator insert(const iterator& p, const rope& x)`void pop_front()`之前。紧接在`插入`iterator mutable_rbegin()
`iterator insert(const iterator& p, const charT* s)`	之前插入一个 C 字符串。`插入`第 i 个元素之前插入 C 字符串。插入的元素是以`*s`开始，直到但不包括第一个空字符的字符序列。
`之前插入 C 字符串`	插入一个字符数组`从 C 字符串构造`之前。紧接在`插入`第 i 个元素之前插入。插入的元素是范围`[s, s + n)`中的字符组成。请注意，此范围允许包含嵌入的空字符。
`charT()`	iterator insert(const iterator& p, size_t n, charT c)`void pop_front()`之前。紧接在`插入`iterator mutable_rbegin()
`的`	iterator insert(const iterator& p, size_t n, charT c)`void pop_back()`之前。紧接在`插入`iterator mutable_rbegin()
`iterator insert(const iterator& p, const charT* s, size_t n)`	iterator insert(const iterator& p, charT c)`插入`之前。紧接在`插入`iterator mutable_rbegin()
void insert(size_t i, const const_iterator& f, const const_iterator& l)	iterator insert(const iterator& p, charT c)`插入`之前。紧接在`插入`iterator mutable_rbegin()
void insert(size_t i, const iterator& f, const iterator& l)	iterator insert(const iterator& p, charT c)`插入`之前。紧接在`插入`iterator mutable_rbegin()
`[f, l)`	void insert(size_t i, const rope& x)`返回一个指向反转`在`插入`iterator mutable_rbegin()
`之前`	在 rope 的末尾添加 C 字符串。`rope`之前立即插入 C 字符串。插入的元素是以`*s`开始，直到但不包括第一个空字符的字符序列。
`append(const charT* s, size_ nt)`	在 rope 的末尾添加字符数组`从 C 字符串构造`。`rope`。插入的元素是范围`[s, s + n)`中的字符组成。请注意，此范围允许包含嵌入的空字符。
`插入字符`	在末尾添加范围`插入`。`rope`.
`插入`	中的元素。`void pop_front()`。`rope`.
`void insert(size_t i, size_t n, charT c)`	中的元素。`void pop_back()`在 rope 的末尾添加字符
`之前插入 C 字符串`	。`void push_front()`在`*this`.
`void insert(size_t i, const charT* s)`	的末尾添加绳 (rope)`返回一个指向反转`iterator insert(const iterator& p, const rope& x)`void pop_front()`在`*this`.
`void replace(const iterator& f, const iterator& l, const rope& x)`	用`插入`中的元素替换范围`void push_front()`.
`void replace(const iterator& f, const iterator& l, charT c)`	用`插入`用单个字符`void pop_front()`.
`擦除`	用`插入`替换。用 C 字符串替换：以`*s`开始，直到但不包括第一个空字符的字符序列。
void replace(const iterator& f, const iterator& l, const charT* s, size_t n)	用`插入`开始的字符序列。用范围`[s, s + n)`.
void replace(const iterator& f1, const iterator& l1, const charT* f2, const charT* l2)	用`[f1, l1)`开始的字符序列。用范围`[f2, l2)`.
void replace(const iterator& f1, const iterator& l1, const const_iterator& f2, const const_iterator& l2)	用`[f1, l1)`开始的字符序列。用范围`[f2, l2)`.
void replace(const iterator& f1, const iterator& l1, const iterator& f2, const iterator& l2)	用`[f1, l1)`开始的字符序列。用范围`[f2, l2)`.
`指向的元素`	中的元素替换范围。`在前面插入一个新元素。`中的元素替换范围`void push_front()`.
`p`	中的元素替换范围。`在前面插入一个新元素。`用单个字符`void pop_front()`.
`void erase(const iterator& f, const iterator& l)`	中的元素替换范围。`在前面插入一个新元素。`替换。用 C 字符串替换：以`*s`开始，直到但不包括第一个空字符的字符序列。
`擦除范围`	中的元素替换范围。`在前面插入一个新元素。`开始的字符序列。用范围`[s, s + n)`.
void replace(const iterator& p, const charT* f, const charT* l)	中的元素替换范围。`在前面插入一个新元素。`开始的字符序列。用范围`插入`.
void replace(const iterator& p, const_iterator f, const_iterator l)	中的元素替换范围。`在前面插入一个新元素。`开始的字符序列。用范围`插入`.
void replace(const iterator& p, iterator f, iterator l)	中的元素替换范围。`在前面插入一个新元素。`开始的字符序列。用范围`插入`.
`void erase(size_t i, size_t n)`	替换`返回一个指向反转`元素，从第`插入`个元素开始，使用`void push_front()`.
`个元素开始的`	替换`返回一个指向反转`元素，从第`插入`中的元素替换。用单个字符替换第`void pop_front()`.
`个元素`	替换`返回一个指向反转`元素，从第`插入`个元素。用字符数组`从 C 字符串构造`替换第 i 个元素：以`*s`开始，直到但不包括第一个空字符的字符序列。
`void replace(size_t i, size_t n1, const charT* s, size_t n2)`	替换`n1`元素，从第`插入`个元素，从第`[s, s + n2)`.
void replace(size_t i, size_t n, const charT* f, const charT* l)	替换`返回一个指向反转`元素，从第`插入`个元素开始，用范围`插入`.
void replace(size_t i, size_t n, const const_iterator& f, const const_iterator& l)	替换`返回一个指向反转`元素，从第`插入`个元素开始，用范围`插入`.
void replace(size_t i, size_t n, const iterator& f, const iterator& l)	替换`返回一个指向反转`元素，从第`插入`个元素开始，用范围`插入`.
`append(const charT* s)`	替换`插入`的字符替换第 i 个元素。`void pop_front()`.
`追加 C 字符串。`	替换`插入`用`rope`中的元素替换第 i 个元素。
`append(const charT* s, size_t)`	替换`插入`用 C 字符串替换第 i 个元素：以`*s`开始，直到但不包括第一个空字符的字符序列。
`追加（不一定是空终止的）`	替换`插入`个元素，从第`[s, s + n)`.
`的数组`	替换`插入`开始的字符序列。用范围`插入`.
void replace(size_t i, const const_iterator& f, const const_iterator& l)	替换`插入`开始的字符序列。用范围`插入`.
void replace(size_t i, const iterator& f, const iterator& l)	替换`插入`开始的字符序列。用范围`插入`.
`append(const charT* f, const charT* l)`	返回一个新`rope`，其中包含单个元素，`*f`. [4]
`追加一个范围。`	返回一个新`rope`，其中包含单个元素，`*f`. [4]
`rope substr(迭代器 f, 迭代器 l) const`	返回一个新`rope`，由范围`插入`. [4]
`rope substr(常量迭代器 f, 常量迭代器 l) const`	返回一个新`rope`，由范围`插入`. [4]
`rope substr(size_t i, size_t n = 1) const`	返回一个新`rope`组成，其元素是从位置`返回一个指向反转`开始的`插入`. [4].
`void copy(charT* buf) const`	个字符。`rope`将`中的字符复制到`.
size_type copy(size_type pos, size_type n, charT* buf)	buf`返回一个指向反转`中，从位置`pos`开始`rope`的`中的字符复制到`中。如果`rope`包含少于`pos + n`个字符，则仅复制`size() - pos`个字符。
`const charT* c_str() const`	返回一个指向以 null 结尾的字符序列的指针，其中包含`rope`中的所有字符。 [5] [6] 只要`rope`保持有效且未更改，则生成的字符序列至少有效。请注意，首次对此操作调用长字符串时速度较慢：它与`rope`.
`void delete_c_str()`	的长度呈线性关系。`回收`使用的内部存储空间。请注意，这会使`回收`返回的指针无效。
`rope operator+(const rope& L, const rope& R)`	返回一个新`rope`，由`L`和`R`。这是一个全局函数，不是成员函数。
`rope& operator+=(rope& L, const rope& R)`	的串联组成。`L`修改`R`，通过附加`L`。这是一个全局函数，不是成员函数。
`rope operator+(const rope& L, const charT* s)`	返回一个新`rope`，由`L`，并返回`s`。以及
`rope& operator+=(rope& L, const charT* s)`	的串联组成。`L`所有字符，直到但不包括第一个空字符。这是一个全局函数，不是成员函数。`s`，通过附加`L`。这是一个全局函数，不是成员函数。
`rope operator+(const rope& L, charT c)`	返回一个新`rope`的字符，直到但不包括第一个空字符。返回值为`L`，由`void pop_front()`和字符
`rope& operator+=(rope& L, charT c)`	的串联组成。`L`附加到其末尾构成。这是一个全局函数，不是成员函数。`void pop_front()`。这是一个全局函数，不是成员函数。
`ostream& operator<<(ostream& os, rope x)`	将 x 输出`void push_front()`到流`os`。这是一个全局函数，不是成员函数。

，通过附加字符

注释rope[1] 有关

数据结构的详细讨论，请参阅 H.-J. Boehm、R. Atkinson 和 M. Plass 的 “Ropes: An Alternative to Strings”，《软件实践与经验》25(12):1315, 1995。char或wchar_t[2] 由于值类型通常是，因此该库引入了两个缩写crope是一个typedef为rope<char>，并且crope是一个typedefwrope.

[3] rope<wchar_t>Rope::reference不是value_type&referencecrope是一个，而是一个代理类型。事实上，是指嵌套类. charT_ref_proxyConst_reference，但仅仅是const value_type&指向。类似地，仅仅是const value_type*的常量引用，但是一个代理类型。如果rreference，那么是类型为&r的常量引用.

的对象，则类型为[4] 请注意，substrrope的返回值在概念上是一个不同的roperope：两个绳 (rope) 可能共享存储空间，但这是一个隐藏的实现细节。如果修改由rope返回的[4] 请注意，，则不会更改原始rope.

[5] 成员函数const限定符c_str()为了与 C++ 标准草案中的basic_string 接口保持一致，概念上略有不准确；绳 (rope) 会更新以缓存转换后的字符串。

[6] 允许并发调用c_str()；缓存是原子更新的。

另请参阅

随机访问容器，序列，vector, sequence_buffer