字符串(fastring)

include: co/fastring.h.

#fastring

fastring 是 coost 提供的字符串类型，它实现了 std::string 中的大部分方法，同时也提供了一些 std::string 没有的方法。

#constructor

1.  constexpr fastring() noexcept;
2.  explicit fastring(size_t cap);
3.  fastring(const void* s, size_t n);
4.  fastring(const char* s);
5.  fastring(const std::string& s);
6.  fastring(size_t n, char c);
7.  fastring(char c, size_t n);
8.  fastring(const fastring& s);
9.  fastring(fastring&& s) noexcept;

  • 1, 默认构造函数，创建一个空的 fastring 对象，不会分配任何内存。

  • 2, 创建一个空的 fastring 对象，但用参数 cap 指定初始容量，即预分配 cap 字节的内存。

  • 3, 用给定的字节序列创建 fastring 对象，参数 n 是序列长度。

  • 4, 用 C 风格的字符串创建 fastring 对象，s 必须是 ‘\0’ 结尾的字符串。

  • 5, 用 std::string 创建一个 fastring 对象。

  • 6-7, 将 fastring 对象初始化为 n 个字符 c 构成的字符串。

  • 8, 拷贝构造函数，内部会进行内存拷贝。

  • 9, 移动构造函数，不会进行内存拷贝。

  • 示例

fastring s;                // 空字符串，无内存分配
fastring s(32);            // 空字符串，预分配内存(容量为32)
fastring s("hello");       // 初始化 s 为 "hello"
fastring s("hello", 3);    // 初始化 s 为 "hel"
fastring s(88, 'x');       // 初始化 s 为 88 个 'x'
fastring s('x', 88);       // 初始化 s 为 88 个 'x'
fastring t(s);             // 拷贝构造
fastring x(std::move(s));  // 移动构造，s 自身变成空字符串

#operator=

1. fastring& operator=(const char* s);
2. fastring& operator=(const std::string& s);
3. fastring& operator=(const fastring& s);
4. fastring& operator=(fastring&& s) noexcept;

  • 1, 用 ‘\0’ 结尾的字符串进行赋值，s 可以是进行赋值操作的 fastring 的一部分。

  • 2, 用 std::string 进行赋值。

  • 3, 拷贝赋值操作。

  • 4, 移动赋值操作，s 自身会变成空字符串。

  • 示例

fastring s;
fastring t;
s = "hello";           // s -> "hello"
s = s;                 // nothing will be done
s = s.c_str() + 2;     // s -> "llo"
s = std::string("x");  // s -> "x"
t = s;                 // t -> "x"
t = std::move(s);      // t -> "x", s -> ""

#assign

1. fastring& assign(const void* s, size_t n);
2. template<typename S> fastring& assign(S&& s);
  • 对 fastring 进行赋值，v3.0.1 新增。
  • 1 中 n 是字节序列的长度，2 与 operator= 等价。

#———————————

#back

char& back();
const char& back() const;
  • 此方法返回 fastring 中最后一个字符的引用。
若 fastring 为空，调用此方法会导致未定义的行为。
  • 示例
fastring s("hello");
char c = s.back();   // c = 'o'
s.back() = 'x';      // s -> "hellx"

#front

char& front();
const char& front() const;
  • 此方法返回 fastring 中第一个字符的引用。
若 fastring 为空，调用此方法会导致未定义的行为。
  • 示例
fastring s("hello");
char c = s.front();  // c = 'h'
s.front() = 'x';     // s -> "xello"

#operator[]

char& operator[](size_t n);
const char& operator[](size_t n) const;
  • 此方法返回 fastring 中第 n 个字符的引用。
若 n 超出合理的范围，调用此方法会导致未定义的行为。
  • 示例
fastring s("hello");
char c = s[1];       // c = 'e'
s[1] = 'x';          // s -> "hxllo"

#———————————

#capacity

size_t capacity() const noexcept;
  • 此方法返回 fastring 的容量。

#c_str

const char* c_str() const;
  • 此方法获取等效的 C 字符串。
  • 此方法在 fastring 末尾加上一个 ‘\0’，它不会改变 fastring 的 size 及内容，但有可能导致内部重新分配内存。

#data

const char* data() const noexcept;
  • 此方法与 c_str() 类似，但不保证字符串以 ‘\0’ 结尾。

#empty

bool empty() const noexcept;
  • 此方法判断 fastring 是否为空。

#size

size_t size() const noexcept;
  • 此方法返回 fastring 的长度。

#———————————

#clear

1. void clear();
2. void clear(char c);
  • 此方法仅将 fastring 的 size 置为 0，capacity 保持不变。
  • 2 与 1 类似，只是 size 置为 0 前会用字符 c 填充内部内存。
2 是 v3.0.1 新增，可用于清除内存中的敏感信息。

#ensure

void ensure(size_t n);
  • 此方法确保 fastring 剩余的内存能容纳至少 n 个字符。

#reserve

void reserve(size_t n);
  • 此方法调整 fastring 的容量，确保容量至少是 n。
  • 当 n 小于原来的容量时，则保持容量不变。

#reset

void reset();
  • v2.0.3 新增。清空 fastring 并释放内存。

#resize

void resize(size_t n);

  • 此方法将 fastring 的 size 设置为 n。

  • 当 n 大于原来的 size 时，此操作将 size 扩大到 n，但不会用 ‘\0’ 填充扩展的部分。

  • 示例

fastring s("hello");
s.resize(3);    // s -> "hel"
s.resize(6);
char c = s[5];  // c 是不确定的随机值

#shrink

void shrink();

  • 释放 fastring 中多余的内存。

  • 示例

fastring s("hello");
s.reserve(32);  // capacity -> 32
s.shrink();     // capacity -> 6

#swap

void swap(fastring& s) noexcept;
void swap(fastring&& s) noexcept;

  • 交换两个 fastring，仅交换内部指针、容量、大小。

  • 示例

fastring s("hello");
fastring x("world");
s.swap(x);  // s -> "world", x -> "hello"

#———————————

#append

1. fastring& append(const void* s, size_t n);
2. fastring& append(const char* s);
3. fastring& append(const fastring& s);
4. fastring& append(const std::string& s);
5. fastring& append(size_t n, char c);
6. fastring& append(char c, size_t n);
7. fastring& append(char c);

  • 1, 追加指定长度的字节序列，n 为序列长度。

  • 2, 追加 ‘\0’ 结尾的字符串，s 可以是执行 append 操作的 fastring 的一部分。

  • 3, 追加 fastring 对象，s 可以是执行 append 操作的 fastring 对象本身。

  • 4, 追加 std::string 对象。

  • 5-6, 追加 n 个字符 c。

  • 7, 追加单个字符 c。

  • 示例

fastring s;
s.append('c');                 // s -> "c"
s.append(2, 'c');              // s -> "ccc"
s.append('c', 2);              // s -> "ccccc"
s.clear();
s.append('c').append(2, 'x');  // s -> "cxx"
s.append(s.c_str() + 1);       // s -> "cxxxx"
s.append(s.data(), 3);         // s -> "cxxxxcxx"

#append_nomchk

fastring& append_nomchk(const void* s, size_t n);
fastring& append_nomchk(const char* s)
  • 与 append() 类似，但不会检查 s 是否与内部内存重叠。
若 s 与 fastring 内部内存可能重叠，则不能使用此方法。

#cat

template<typename X, typename ...V>
fastring& cat(X&& x, V&& ... v);

  • v2.0.3 新增。将任意数量的元素连接到 fastring 中。

  • 此方法调用 operator<< 操作，将参数中的元素逐个追加到 fastring 中。

  • 示例

fastring s("hello");
s.cat(' ', 23, "xx", false); // s -> "hello 23xxfalse"

#operator«

fastring& operator<<(bool v);

fastring& operator<<(char v);
fastring& operator<<(signed char v);
fastring& operator<<(unsigned char v);

fastring& operator<<(short v);
fastring& operator<<(unsigned short v);
fastring& operator<<(int v);
fastring& operator<<(unsigned int v);
fastring& operator<<(long v);
fastring& operator<<(unsigned long v);
fastring& operator<<(long long v);
fastring& operator<<(unsigned long long v);

fastring& operator<<(double v);
fastring& operator<<(float v);
fastring& operator<<(const dp::_fpt& v);

fastring& operator<<(const void* v);
fastring& operator<<(std::nullptr_t);

fastring& operator<<(const char* s);
fastring& operator<<(const signed char* s);
fastring& operator<<(const unsigned char* s);
fastring& operator<<(const fastring& s);
fastring& operator<<(const std::string& s);

  • 将 bool、char、整数类型、浮点数类型、指针类型、字符串类型的值格式化后追加到 fastring 中。

  • operator<<(const dp::_fpt&) 用于格式化输出浮点数，可指定有效小数位数。

  • 示例

fastring s;
s << 'x';             // s -> "x"
s << s;               // s -> "xx"           (append itself)
s << false;           // s -> "xxfalse"

s.clear();
s << "hello " << 23;  // s -> "hello 23"
s << (s.c_str() + 6); // s -> "hello 2323"   (append part of s)

s.clear();
s << 3.1415;          // s -> "3.1415"

s.clear();
s << (void*)32;       // s -> "0x20"

指定有效小数的位数
coost 提供 dp::_1, dp::_2, ..., dp::_16, dp::_n，用于设置浮点数的有效小数位数。

fastring s;
s << dp::_2(3.1415);   // "3.14
s << dp::_3(3.1415);   // "3.141"
s << dp::_n(3.14, 1);  // "3.1", 与 dp::_1(3.14) 等价

#operator+=

fastring& operator+=(const char* s);
fastring& operator+=(const fastring& s);
fastring& operator+=(const std::string& s);
fastring& operator+=(char c);

  • 此方法等价于 append() 方法。

  • 示例

fastring s;
s += 'c';   // s -> "c"
s += "xx";  // s -> "cxx"

#push_back

fastring& push_back(char c);
  • 追加单个字符到 fastring 尾部，与 append(c) 等价。

#pop_back

char pop_back();
  • 取出并返回 fastring 最后的一个字符。
若 fastring 为空，调用此方法会导致未定义的行为。

#———————————

#compare

 1. int compare(const char* s, size_t n) const;
 2. int compare(const char* s) const;
 3. int compare(const fastring& s) const noexcept;
 4. int compare(const std::string& s) const noexcept;

 5. int compare(size_t pos, size_t len, const char* s, size_t n) const;
 6. int compare(size_t pos, size_t len, const char* s) const;
 7. int compare(size_t pos, size_t len, const fastring& s) const;
 8. int compare(size_t pos, size_t len, const std::string& s) const;

 9. int compare(size_t pos, size_t len, const fastring& s, size_t spos, size_t n=npos) const;
10. int compare(size_t pos, size_t len, const std::string& s, size_t spos, size_t n=npos) const;
  • 比较 fastring 与指定的字符串。
  • 1-4, 将 fastring 与 s 比较，n 是 s 的长度。
  • 5-8, 将 fastring 的 [pos, pos+len) 部分与 s 进行比较，n 是 s 的长度。
  • 9-10, 将 fastring 的 [pos, pos+len) 部分与 s 的 [spos, spos+n) 部分进行比较。

#contains

bool contains(char c) const;
bool contains(const char* s) const;
bool contains(const fastring& s) const;
bool contains(const std::string& s) const;
  • 判断 fastring 中是否包含指定的字符或字符串。

#find

1. size_t find(char c) const;
2. size_t find(char c, size_t pos) const;
3. size_t find(char c, size_t pos, size_t len) const;
4. size_t find(const char* s) const;
5. size_t find(const char* s, size_t pos) const;
6. size_t find(const char* s, size_t pos, size_t n) const;
7. size_t find(const fastring& s, size_t pos=0) const;
8. size_t find(const std::string& s, size_t pos=0) const;
  • 1, 从位置 0 开始查找字符 c。
  • 2, 从位置 pos 开始查找字符 c。
  • 3, v3.0 新增，在 [pos, pos + len) 范围内查找字符 c。
  • 4, 从位置 0 开始查找子串 s。
  • 5, 从位置 pos 开始查找子串 s。
  • 6, 从位置 pos 开始查找子串 s，s 长度为 n。
  • 7-8, 从位置 pos 开始查找子串 s。
  • 此方法查找成功时，返回所查找字符或子串的位置，否则返回 npos。
v3.0.1 新增上述 6-8，并支持二进制字符串的查找。
  • 示例
fastring s("hello");
s.find('l');      // return 2
s.find('l', 3);   // return 3
s.find("ll");     // return 2
s.find("ll", 3);  // return s.npos

#ifind

size_t ifind(char c, size_t pos=0) const;
size_t ifind(const char* s) const;
size_t ifind(const char* s, size_t pos) const
size_t ifind(const char* s, size_t pos, size_t n) const;
size_t ifind(const fastring& s, size_t pos=0) const;
size_t ifind(const std::string& s, size_t pos=0) const;

  • v3.0.1 新增，与 find 类似，但是忽略大小写。

  • 示例

fastring s("hello");
s.ifind('L');      // return 2
s.ifind('L', 3);   // return 3
s.ifind("Ll");     // return 2

#rfind

1. size_t rfind(char c) const;
2. size_t rfind(char c, size_t pos) const;
3. size_t rfind(const char* s) const;
4. size_t rfind(const char* s, size_t pos) const;
5. size_t rfind(const char* s, size_t pos, size_t n) const;
6. size_t rfind(const fastring& s, size_t pos=npos) const;
7. size_t rfind(const std::string& s, size_t pos=npos) const;
  • 与 find 类似，只是从反向开始查找。
v3.0.1 新增上述 2, 4-7，并支持二进制字符串的反向查找。
  • 示例
fastring s("hello");
s.rfind('l');    // return 3
s.rfind('l', 2); // return 2
s.rfind("ll");   // return 2
s.rfind("le");   // return s.npos

#find_first_of

1. size_t find_first_of(const char* s, size_t pos=0) const;
2. size_t find_first_of(const char* s, size_t pos, size_t n) const;
3. size_t find_first_of(const fastring& s, size_t pos=0) const;
4. size_t find_first_of(const std::string& s, size_t pos=0) const;
  • 查找第一个出现的指定字符集 s 中的字符, n 是 s 的长度。
  • 此方法从位置 pos(默认为0) 开始查找，遇到 s 中的任意字符时，即返回该字符的位置，否则返回 npos。
v3.0.1 新增 2-4，并支持二进制字符串的查找。
  • 示例
fastring s("hello");
s.find_first_of("def");    // return 1
s.find_first_of("ol", 3);  // return 3

#find_first_not_of

1. size_t find_first_not_of(char c, size_t pos=0) const;
2. size_t find_first_not_of(const char* s, size_t pos=0) const;
3. size_t find_first_not_of(const char* s, size_t pos, size_t n) const;
4. size_t find_first_not_of(const fastring& s, size_t pos=0) const;
5. size_t find_first_not_of(const std::string& s, size_t pos=0) const;
  • 查找第一个出现的非指定字符 c 或非指定字符集 s 中的字符，n 是 s 的长度。
  • 此方法从位置 pos(默认为0) 开始查找，遇到不是 c 或非 s 中的任意字符时，即返回该字符的位置，否则返回 npos。
v3.0.1 中新增 3-5，并支持二进制字符串的查找。
  • 示例
fastring s("hello");
s.find_first_not_of("he");     // return 2
s.find_first_not_of("he", 3);  // return 3
s.find_first_not_of('x');      // return 0

#find_last_of

1. size_t find_last_of(const char* s, size_t pos=npos) const;
2. size_t find_last_of(const char* s, size_t pos, size_t n) const;
3. size_t find_last_of(const fastring& s, size_t pos=npos) const;
4. size_t find_last_of(const std::string& s, size_t pos=npos) const;
  • 查找最后一个出现的指定字符集 s 中的字符。
  • 此方法从 pos(默认值为npos) 处开始反向查找，遇到 s 中的任意字符时，即返回该字符的位置，否则返回 npos。
v3.0.1 中新增 2-4。此方法支持二进制字符串的查找。
  • 示例
fastring s("hello");
s.find_last_of("le");     // return 3
s.find_last_of("le", 1);  // return 1

#find_last_not_of

1. size_t find_last_not_of(char c, size_t pos=npos) const;
2. size_t find_last_not_of(const char* s, size_t pos=npos) const;
3. size_t find_last_not_of(const char* s, size_t pos, size_t n) const;
4. size_t find_last_not_of(const fastring& s, size_t pos=npos) const;
5. size_t find_last_not_of(const std::string& s, size_t pos=npos) const;
  • 查找最后一个出现的非指定字符 c 或者非指定字符集 s 中的字符。
  • 此方法从 pos(默认为npos) 处开始反向查找，遇到不等于 c 或者非 s 中的任意字符时，即返回该字符的位置，否则返回 npos。
v3.0.1 中新增 3-5，并且支持二进制字符串的查找。
  • 示例
fastring s("hello");
s.find_last_not_of("le");     // return 4
s.find_last_not_of("le", 3);  // return 0
s.find_last_not_of('o');      // return 3

#npos

static const size_t npos = (size_t)-1;

  • npos 是 size_t 类型的最大值。

  • npos 作为长度时，表示直到字符串结尾。

  • npos 作为返回值时，表示未找到。

  • 示例

fastring s("hello");
size_t r = s.find('x');
r == s.npos;  // true

#substr

fastring substr(size_t pos) const;
fastring substr(size_t pos, size_t len) const;

  • 第 1 个版本返回从位置 pos 开始的子串。

  • 第 2 个版本返回从位置 pos 开始、长度为 len 的子串。

  • 示例

fastring s("hello");
s.substr(2);     // "llo"
s.substr(2, 2);  // "ll"

#———————————

#starts_with

bool starts_with(char c) const;
bool starts_with(const char* s, size_t n) const;
bool starts_with(const char* s) const;
bool starts_with(const fastring& s) const;
bool starts_with(const std::string& s) const;
  • 此方法判断 fastring 是否以字符 c 或字符串 s 开头，n 是 s 的长度。
  • 当 s 为空字符串时，此方法始终返回 true。

#ends_with

bool ends_with(char c) const;
bool ends_with(const char* s, size_t n) const;
bool ends_with(const char* s) const;
bool ends_with(const fastring& s) const;
bool ends_with(const std::string& s) const;
  • 此方法判断 fastring 是否以字符 c 或字符串 s 结尾，n 是 s 的长度。
  • 当 s 为空字符串时，此方法始终返回 true。

#match

bool match(const char* pattern) const;

  • 判断 fastring 是否匹配模式 pattern，* 匹配 0 个或多个字符，? 匹配单个字符。

  • 示例

fastring s("hello");
s.match("he??o");  // true
s.match("h*o");    // true
s.match("he?o");   // false
s.match("*o");     // true
s.match("h*l?");   // true

#remove_prefix

fastring& remove_prefix(const char* s, size_t n);
fastring& remove_prefix(const char* s);
fastring& remove_prefix(const fastring& s);
fastring& remove_prefix(const std::string& s);

  • 删除 fastring 中的前缀 s，n 是 s 的长度。

  • v3.0.1 新增。

  • 示例

fastring s("12345678");
s.remove_prefix("123"); // s -> "45678"
s.remove_prefix("xxx"); // nothing will be done

#remove_suffix

fastring& remove_suffix(const char* s, size_t n);
fastring& remove_suffix(const char* s);
fastring& remove_suffix(const fastring& s);
fastring& remove_suffix(const std::string& s);
  • 删除 fastring 的后缀 s，n 是 s 的长度。
v3.0.1 中将 remove_tail 更名为 remove_suffix。
  • 示例
fastring s("hello.log");
s.remove_suffix(".log"); // s -> "hello"
s.remove_suffix(".xxx"); // nothing will be done

#———————————

#replace

1. fastring& replace(const char* sub, const char* to, size_t maxreplace=0);
2. fastring& replace(const fastring& sub, const fastring& to, size_t maxreplace=0);
3. fastring& replace(const char* sub, size_t n, const char* to, size_t m, size_t maxreplace=0);
  • 此方法将 fastring 中的子串 sub 替换成 to，参数 maxreplace 指定最大的替换次数，0 表示不限次数。n 和 m 分别是子串 sub、to 的长度。
v3.0.1 中新增 2-3，并支持二进制字符串的替换。
  • 示例
fastring s("hello");
s.replace("ll", "rr");                     // s -> "herro"
s.replace("err", "ok").replace("k", "o");  // s -> "hooo"

#strip

template<typename ...X>
fastring& strip(X&& ...x);
  • 修剪字符串，与 trim 等价。

#trim

1. fastring& trim(char c, char d='b');
2. fastring& trim(unsigned char c, char d='b');
3. fastring& trim(signed char c, char d='b');
4. fastring& trim(const char* s=" \t\r\n", char d='b');
5. fastring& trim(size_t n, char d='b');
6. fastring& trim(int n, char d='b');
  • 修剪字符串，去掉 fastring 左边、右边或两边的指定字符。
  • 参数 d 表示方向，’l’ 或 ‘L’ 表示左边，‘r’ 或 ‘R’ 表示右边，默认为 ‘b’ 表示左右两边。
  • 1-3, 去掉左、右或两边的单个字符 c。
  • 4, 去掉左、右或两边的 s 中的字符。
  • 5-6, 去掉左、右或两边的 n 个字符。
从 v3.0.1 开始，参数 c 可以是 \0。
  • 示例
fastring s = " sos\r\n";
s.trim();          // s -> "sos"
s.trim('s', 'l');  // s -> "os"
s.trim('s', 'r');  // s -> "o"

s = "[[xx]]";
s.trim(2);         // s -> "xx"

#tolower

fastring& tolower();
  • 此方法将 fastring 转换成小写，并返回 fastring 的引用。

#toupper

fastring& toupper();
  • 此方法将 fastring 转换成大写，并返回 fastring 的引用。

#lower

fastring lower() const;
  • 此方法返回 fastring 的小写形式。

#upper

fastring upper() const;

  • 此方法返回 fastring 的大写形式。

  • 示例

fastring s("Hello");
fastring x = s.lower();  // x = "hello", s 保持不变
fastring y = s.upper();  // x = "HELLO", s 保持不变
s.tolower();             // s -> "hello"
s.toupper();             // s -> "HELLO"

#global functions

#operator+

fastring operator+(const fastring& a, char b);
fastring operator+(char a, const fastring& b);
fastring operator+(const fastring& a, const fastring& b);
fastring operator+(const fastring& a, const char* b);
fastring operator+(const char* a, const fastring& b);
fastring operator+(const fastring& a, const std::string& b);
fastring operator+(const std::string& a, const fastring& b);

  • 加法操作，此方法至少有一个参数是 fastring。

  • 示例

fastring s;
s = s + '^';        // s -> "^"
s = "o" + s + "o";  // s -> "o^o"

#operator==

bool operator==(const fastring& a, const fastring& b);
bool operator==(const fastring& a, const char* b);
bool operator==(const char* a, const fastring& b);
bool operator==(const fastring& a, const std::string& b);
bool operator==(const std::string& a, const fastring& b);
  • 此方法判断两个字符串是否相等，至少有一个参数是 fastring。

#operator!=

bool operator!=(const fastring& a, const fastring& b);
bool operator!=(const fastring& a, const char* b);
bool operator!=(const char* a, const fastring& b);
bool operator!=(const fastring& a, const std::string& b);
bool operator!=(const std::string& a, const fastring& b);
  • 此方法判断两个字符串是否不相等，至少有一个参数是 fastring。

#operator<

bool operator<(const fastring& a, const fastring& b);
bool operator<(const fastring& a, const char* b);
bool operator<(const char* a, const fastring& b);
bool operator<(const fastring& a, const std::string& b);
bool operator<(const std::string& a, const fastring& b);
  • 此方法判断字符串 a 是否小于 b，至少有一个参数是 fastring。

#operator>

bool operator>(const fastring& a, const fastring& b);
bool operator>(const fastring& a, const char* b);
bool operator>(const char* a, const fastring& b);
bool operator>(const fastring& a, const std::string& b);
bool operator>(const std::string& a, const fastring& b);
  • 此方法判断字符串 a 是否大于 b，至少有一个参数是 fastring。

#operator<=

bool operator<=(const fastring& a, const fastring& b);
bool operator<=(const fastring& a, const char* b);
bool operator<=(const char* a, const fastring& b);
bool operator<=(const fastring& a, const std::string& b);
bool operator<=(const std::string& a, const fastring& b);
  • 此方法判断字符串 a 是否小于或等于 b，至少有一个参数是 fastring。

#operator>=

bool operator>=(const fastring& a, const fastring& b);
bool operator>=(const fastring& a, const char* b);
bool operator>=(const char* a, const fastring& b);
bool operator>=(const fastring& a, const std::string& b);
bool operator>=(const std::string& a, const fastring& b);

  • 此方法判断字符串 a 是否大于或等于 b，至少有一个参数是 fastring。

  • 示例

fastring s("hello");
s == "hello";  // true
s != "hello";  // false
s > "aa";      // true
s < "xx";      // true
s >= "he";     // true
s <= "he";     // false

#operator«

std::ostream& operator<<(std::ostream& os, const fastring& s);
  • 示例
fastring s("xx");
std::cout << s << std::endl;