文章目录
-
STL库对于string类的介绍
-
string常用接口
-
string类的模拟实现
-
string对象大小的计算
-
写时拷贝
前言
C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
一、STL库对于string类的介绍
官方介绍：
- 字符串是表示字符序列的对象
- 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性
- string 类是使用 char (即作为它的字符类型，使用它的默认 char_traits 和分配器类型(关于模板的更多信息，请参阅 basic_string)
- string 类是 basic_string 模板类的一个实例，它使用 char 来实例化 basic_string 模板类，并用 char_traits 和 allocator 作为 basic_string 的默认参数(关于更多的模板信息请参考 basic_string)
- 注意，这个类独立于所使用的编码来处理字节：如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作
总结：
- string 是表示字符串的字符串类
- 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作 string 的常规操作
- string 在底层实际是 basic_string 模板类的别名 typedef basic_string string;
- 不能操作多字节或者变长字符的序列
二、string常用接口
1. string类对象的常见构造
string类对象的常见构造
default (1) copy (2) substring (3) from c-string (4) from sequence (5) fill (6) range (7)
常见构造代码演示：
#include<iostream>
#include<string>
using namespace std;
int main()
{
string s0("hello");
string s1;
string s2(s0);
string s3("hello world");
string s4("hello world", 4);
string s5(10, 'x');
string s6(s0.begin(), s0.end());
return 0;
}
注意：空串并不是没有，而是第一个字符放的\0，存储空间不为0
2. string类对象的容量操作
函数名称 功能说明size （重点） 返回字符串有效字符长度length 返回字符串有效字符长度capacity 返回空间总大小empty （重点） 检测字符串释放为空串，是返回true，否则返回falseclear （重点） 清空有效字符reserve （重点） 为字符串预留空间**resize （重点） 将有效字符的个数该成n个，多出的空间用字符 c 填充
// 测试string容量相关的接口
// size/clear/resize
void Teststring1()
{
// 注意：string类对象支持直接用cin和cout进行输入和输出
string s("hello, bit!!!");
cout << s.size() << endl;
cout << s.length() << endl;
cout << s.capacity() << endl;
cout << s << endl;
// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
s.clear();
cout << s.size() << endl;
cout << s.capacity() << endl;
// 将s中有效字符个数增加到10个，多出位置用'a'进行填充
// “aaaaaaaaaa”
s.resize(10, 'a');
cout << s.size() << endl;
cout << s.capacity() << endl;
// 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
// "aaaaaaaaaa\0\0\0\0\0"
// 注意此时s中有效字符个数已经增加到15个
s.resize(15);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;
// 将s中有效字符个数缩小到5个
s.resize(5);
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl;
}
//====================================================================================
void Teststring2()
{
string s;
// 测试reserve是否会改变string中有效元素个数
s.reserve(100);
cout << s.size() << endl;
cout << s.capacity() << endl;
// 测试reserve参数小于string的底层空间大小时，是否会将空间缩小
s.reserve(50);
cout << s.size() << endl;
cout << s.capacity() << endl;
}
注意：
1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。
3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
在不同平台下reserve的扩容机制
// 构建vector时，如果提前已经知道string中大概要放多少个元素，可以提前将string中空间设置好
void TestPushBackReserve()
{
string s;
s.reserve(100);
size_t sz = s.capacity();
cout << "making s grow:\n";
for (int i = 0; i < 100; ++i)
{
s.push_back('c');
if (sz != s.capacity())
{
sz = s.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
}
在Linux平台下的vim：
在VS2020平台下是：
结论：VS下是1.5倍扩容，Linux下是2倍扩容
3. string类对象的访问及遍历操作
函数名称 功能说明operator[] （重点） 返回pos位置的字符， const string 类对象调用begin + end begin 获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭 代器rbegin + rend begin 获取一个字符的迭代器 + end 获取最后一个字符下一个位置的迭代器范围forC++11 支持更简洁的范围 for 的新遍历方式
// string的遍历
// begin()+end() for+[] 范围for
// 注意：string遍历时使用最多的还是for+下标 或者 范围for(C++11后才支持)
// begin()+end()大多数使用在需要使用STL提供的算法操作string时，比如：采用reverse逆置string
void Teststring3()
{
string s1("hello Bit");
const string s2("Hello Bit");
cout << s1 << " " << s2 << endl;
cout << s1[0] << " " << s2[0] << endl;
s1[0] = 'H';
cout << s1 << endl;
// s2[0] = 'h'; 代码编译失败，因为const类型对象不能修改
}
void Teststring4()
{
string s("hello Bit");
// 3种遍历方式：
// 需要注意的以下三种方式除了遍历string对象，还可以遍历是修改string中的字符，
// 另外以下三种方式对于string而言，第一种使用最多
// 1. for+operator[]
for (size_t i = 0; i < s.size(); ++i)
cout << s[i] << endl;
// 2.迭代器
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it << endl;
++it;
}
// string::reverse_iterator rit = s.rbegin();
// C++11之后，直接使用auto定义迭代器，让编译器推到迭代器的类型
auto rit = s.rbegin();
while (rit != s.rend())
cout << *rit << endl;
// 3.范围for
for (auto ch : s)
cout << ch << endl;
}
4. string类对象的修改操作
函数名称 功能说明push_back 在字符串后尾插字符 cappend 在字符串后追加一个字符串operator+= (重点) 在字符串后追加字符串strc_str (重点) 返回C格式字符串find + npos (重点) 从字符串pos位置开始往后找字符 c ，返回该字符在字符串中的位置r find 从字符串 pos 位置开始往前找字符 c ，返回该字符在字符串中的位置substr 在 str 中从 pos 位置开始，截取 n 个字符，然后将其返回
// 测试string：
// 1. 插入(拼接)方式：push_back append operator+=
// 2. 正向和反向查找：find() + rfind()
// 3. 截取子串：substr()
// 4. 删除：erase
void Teststring5()
{
string str;
str.push_back(' '); // 在str后插入空格
str.append("hello"); // 在str后追加一个字符"hello"
str += 'b'; // 在str后追加一个字符'b'
str += "it"; // 在str后追加一个字符串"it"
cout << str << endl;
cout << str.c_str() << endl; // 以C语言的方式打印字符串
// 获取file的后缀
string file("string.cpp");
size_t pos = file.rfind('.');
string suffix(file.substr(pos, file.size() - pos));
cout << suffix << endl;
// npos是string里面的一个静态成员变量
// static const size_t npos = -1;
// 取出url中的域名
string url("http://www.cplusplus.com/reference/string/string/find/");
cout << url << endl;
size_t start = url.find("://");
if (start == string::npos)
{
cout << "invalid url" << endl;
return;
}
start += 3;
size_t finish = url.find('/', start);
string address = url.substr(start, finish - start);
cout << address << endl;
// 删除url的协议前缀
pos = url.find("://");
url.erase(0, pos + 3);
cout << url << endl;
}
注意：
1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
5. string类非成员函数
函数 功能说明operator+ 尽量少用，因为传值返回，导致深拷贝效率低operator>> （重点） 输入运算符重载operator<< （重点） 输出运算符重载getline （重点） 获取一行字符串relational operators （重点） 大小比较
6.string的特殊判断接口
C语言头文件<ctype.h>中处理字符的接口：
1.字符串处理函数：
- int isalpha(int c)：检查字符是否为字母，是返回非零(true)，不是则返回0(false)
- int isdigit(int c)：检查字符是否为十进制数字，是返回非零(true)，不是则返回0(false)
2.字符转换函数：
- int tolower(int c)：把字母转换成小写字母，返回转换之后的字符
- int toupper(int c)：把字母转换成大写字母，返回转换之后的字符
C++头文件中处理字符的接口：
1.函数 std::to_string（C++11）：将数值转换为字符串，返回 string 类对象
2.函数 std::stoi（C++11）：将字符串转换为整数，返回 int 整数
三、string类的模拟实现
namespace String
{
class string
{
private:
char* _str; // 指向字符数组
size_t _size; // 有效字符数
size_t _capacity; // 有效字符容量，不包含最后作标识的'\0'
static const size_t npos;
public:
/*******************************************************/
// 迭代器
typedef char* iterator;
typedef const char* const_iterator;
iterator begin() { return _str; } // 返回指向第一个字符的迭代器
iterator end() { return _str + _size; } // 返回指向最后一个字符下一个字符的迭代器
const_iterator begin() const { return _str; } // 返回指向第一个字符的迭代器
const_iterator end() const { return _str + _size; } // 返回指向最后一个字符下一个字符的迭代器
/*******************************************************/
// 默认成员函数：
string(const char* str = ""); // 默认构造函数
void swap(string& s); // 交换两个对象的内容
string(const string& s); // 拷贝构造函数（深拷贝）
string& operator=(string s); // 赋值运算符重载（深拷贝）
~string(); // 析构函数
/*******************************************************/
// 访问元素，[]运算符重载
char& operator[](size_t pos); // 可读可写
const char& operator[](size_t pos) const; // 只读不能写
/*******************************************************/
// 容量操作：
// 获取字符串有效元素个数
size_t size() const { return _size; }
// 获取字符串容量（有效字符的最大容量）
size_t capacity() const { return _capacity; }
// 清空有效字符
void clear()
{
_str[0] = '\0';
_size = 0;
}
// 更改容量（capacity）的大小
void reserve(size_t n);
// 调整字符串有效字符的长度
void resize(size_t n, char ch = '\0');
/*******************************************************/
// 修改操作：
string& insert(size_t pos, const char ch); // 在pos位置插入一个字符
string& insert(size_t pos, const char* str); // 在pos位置插入一个字符串
void push_back(const char ch); // 尾插一个字符
void append(const char* str); // 在当前字符串末尾追加一个字符串
string& operator+=(const char ch); // 当前字符串末尾追加一个字符/字符串
string& operator+=(const char* str);
string& operator+=(const string& s);
string& erase(size_t pos = 0, size_t len = npos); // 删除从pos位置开始的len个字符
/*******************************************************/
// String operations
// 从pos位置开始查找字符，若找到，则返回该字符的下标，若没找到，则返回npos
size_t find(char ch, size_t pos = 0) const;
// 从pos位置开始查找子串，若找到，则返回该子串首字符的下标，若没找到，则返回npos
size_t find(const char* str, size_t pos = 0) const;
// 返回指向 C 格式字符串的数组的指针
char* c_str() const { return _str; }
};
const size_t string::npos = -1;
};1.string的默认成员函数的模拟实现
默认构造函数：
string(const char* str = "") {
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}交换容器内容swap函数
void swap(string& s) {
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}拷贝构造函数
string(const string& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(s._str);
swap(tmp);
}赋值运算符重载
string& operator=(string s) {
swap(s);
return *this;
}析构函数
~string() {
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}2.关于string的深浅拷贝问题
浅拷贝：
也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
#include <iostream>
#include <string>
using namespace std;
namespace String
{
class string
{
private:
char* _str;
public:
// 构造函数
string(const char* s)
:_str(new char[strlen(s) + 1])
{
strcpy(_str, s);
}
// 析构函数
~string()
{
delete[] _str;
_str = nullptr;
}
};
void test()
{
string s1("hello world"); // 用一个常量字符串去构造string类对象s1
string s2(s1); // s2调用编译器默认生成的拷贝构造函数
}
}
int main()
{
String::test();
return 0;
}
上述String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块 空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。
深拷贝:
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。
#include <iostream>
#include <string>
using namespace std;
namespace String
{
class string
{
public:
//浅拷贝
string(const char* s)
:_str(new char[strlen(s) + 1])
{
strcpy(_str, s);
}
// 显式定义拷贝构造函数（深拷贝）
string(const string& s) // 保护形参不被改变，加引用防止无穷递归
:_str(new char[strlen(s._str) + 1]) // 给新对象申请一段和原对象一样大小的空间
{
strcpy(_str, s._str); // 把原对象的数据一一拷贝给新对象
}
private:
char* _str;
};
//测试代码
void test()
{
string s1("hello world"); // 用一个常量字符串去构造string类对象s1
string s2(s1); // s2调用编译器默认生成的拷贝构造函数
}
}
int main()
{
String::test();
return 0;
}
string的拷贝构造的深拷贝实现
传统写法：
//浅拷贝
string(const char* s)
:_str(new char[strlen(s) + 1])
{
strcpy(_str, s);
}
// 显式定义拷贝构造函数（深拷贝）
string(const string& s) // 保护形参不被改变，加引用防止无穷递归
:_str(new char[strlen(s._str) + 1]) // 给新对象申请一段和原对象一样大小的空间
{
strcpy(_str, s._str); // 把原对象的数据一一拷贝给新对象
}
//测试代码
void test()
{
string s1("hello world"); // 用一个常量字符串去构造string类对象s1
string s2(s1); // s2调用编译器默认生成的拷贝构造函数
}现代写法：
// 拷贝构造函数（深拷贝）
string(const string& s)
:_str(nullptr) // 当前对象是一个正在构造的对象，成员变量还未初始化，是一个随机值，所以先置空
{
string tmp(s._str); // 拿s的内容，调用构造函数构造临时对象tmp
swap(_str, tmp._str); // 将临时对象tmp和当前对象的成员变量_str进行交换
}
//测试代码
void test()
{
string s1("hello world"); // 用一个常量字符串去构造string类对象s1
string s2(s1); // s2调用编译器默认生成的拷贝构造函数
}
3.string的赋值运算符重载函数的深拷贝实现
传统写法：
// 显式定义赋值运算符重载（深拷贝）
string& operator=(const string& s)
{
if (this != &s) // 防止自己给自己赋值
{
char* tmp = new char[strlen(s._str) + 1]; // 重新开辟一块和s一样大小的空间
delete[] _str; // 释放自己的空间
_str = tmp;
strcpy(_str, s._str); // 把s的数据拷贝过来
}
return *this;
}
现代写法：
// 赋值运算符重载（深拷贝）
// s1 = s2
// 写法一：
string& operator=(const string& s) // 传引用
{
if (this != &s) // 防止自己给自己赋值
{
string tmp(s._str); // 拿s的内容，调用构造函数构造临时对象tmp
swap(_str, tmp._str); // 将临时对象tmp和当前对象的成员变量_str进行交换
}
return *this;
}
// 写法二：
string& operator=(string s) // 重点：传值
{
// 传参时，调用拷贝构造函数，拷贝构造了一个string类对象s
// 将拷贝构造出来的string类对象s和当前对象的成员变量_str进行交换
swap(_str, s._str);
return *this; // 返回当前对象
}
4.string的迭代器模拟实现
class string
{
private:
char* _str; // 指向字符数组
size_t _size; // 有效字符数
size_t _capacity; // 有效字符容量，不包含最后作标识的'\0'
static const size_t npos;
public:
/*******************************************************/
// 迭代器
// iterator是内嵌类型，在stirng类域里面定义的类型
typedef char* iterator;
typedef const char* const_iterator;
iterator begin() { return _str; } // 返回指向第一个字符的迭代器
iterator end() { return _str + _size; } // 返回指向最后一个字符下一个字符的迭代器
const_iterator begin() const { return _str; } // 返回指向第一个字符的迭代器
const_iterator end() const { return _str + _size; } // 返回指向最后一个字符下一个字符的迭代器
// ...
// ...
};
const size_t string::npos = -1;
//测试代码
void test3()
{
string s1("hello world");
// iterator是内嵌类型，在stirng类域里面定义的类型
// 告诉编译器，要到string类域里面去找
string::iterator it = s1.begin();
while (it != s1.end())
{
cout << *it;
it++;
}
cout << endl;
// 范围for的原理就是被替换成迭代器
for (auto e : s1)
{
cout << e;
}
cout << endl;
}5.string的访问操作运算符重载模拟实现
//对于普通数组来说：越界读一般是检查不出来的，越界写会抽查，可能会检查出来
//对于string类来说：越界读写都会被检查出来，因为[]中进行了严格的检查
// 普通版本
char& operator[](size_t pos) // 可读可写
{
assert(pos < _size);
return _str[pos]; // *(_str + pos)
}
//const版本
const char& operator[](size_t pos) const // 只读不能写
{
assert(pos < _size);
return _str[pos]; // *(_str + pos)
}6.string的容量操作函数模拟实现
resize函数
// 调整字符串有效字符的长度
void resize(size_t n, char ch = '\0')
{
// 要调整的有效字符的长度小于原有 _size 大小
if (n < _size)
{
_size = n; // 更新有效字符个数
_str[_size] = '\0'; // 补上字符串结束标志'\0'
}
// 要调整的有效字符的长度大于原有 _size 大小
else if (n > _size)
{
// 要调整的有效字符的长度大于原有 _capacity 大小，先进行增容
if (n > _capacity) reserve(n);
// 多出的位置用字符 ch（缺省值'\0'）进行填充
for (size_t i = _size; i < n; i++)
{
_str[i] = ch;
}
_size = n; // 更新有效字符个数
_str[_size] = '\0'; // 补上字符串结束标志'\0'
}
}reserve函数
// 更改容量（capacity）的大小
void reserve(size_t n)
{
if (n > _capacity)
{
// 开辟新空间
char* tmp = new char[n + 1];
strcpy(tmp, _str); // 旧空间数据拷贝到新空间
// 释放旧空间，使用新空间
delete[] _str;
_str = tmp; // 指向新空间
_capacity = n; // 更新容量
}
}7.string的修改操作函数模拟实现
insert函数
// 在pos位置插入一个字符串
string& insert(size_t pos, const char* str)
{
assert(pos >= 0 && pos <= _size);
// 先检查是否需要扩容
size_t len = strlen(str);
if (_size + len >= _capacity)
{
reserve(_size + len);
}
// 挪动字符
for (size_t i = _size + len; i >= pos + len; i--)
{
_str[i] = _str[i - len];
}
// 插入字符
for (size_t i = 0; i < len; i++)
{
_str[pos++] = str[i];
}
_size += len; // 更新有效字符个数
return *this;
}push_back函数
void push_back(const char ch)
{
//方法一：
// 先检查是否需要扩容
if (_size >= _capacity)
{
// 防止是空串""，容量为0，扩容失败
size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
reserve(newcapacity); // 扩2倍容
}
_str[_size] = ch; // 尾插字符
_size++; // 有效字符个数+1
_str[_size] = '\0'; // 补上字符串结束标志'\0'
//方法二： 复用 insert 函数的代码
insert(_size, ch);
}append函数
void append(const char* str)
{
//方法一：
// 先检查是否需要扩容
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len); // 扩容
}
strcpy(_str + _size, str); // 尾插字符串（strcpy会拷贝'\0'，并在该点停止）
_size += len; // 有效字符个数+len
//方法二：复用 insert 函数的代码
insert(_size, str);
}+=运算符重载函数
string& operator+=(const char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
string& operator+=(const string& s)
{
append(s._str);
return *this;
}erase函数
string& erase(size_t pos = 0, size_t len = npos)
{
assert(pos >= 0 && pos < _size);
// 1. 从pos位置开始，后面的字符删除完，这是一个O(1)的操作
if (len == npos || pos + len >= _size)
{
_str[pos] = '\0';
_size = pos;
}
// 2. 从pos位置开始，后面的字符删除一部分，这是一个O(n)的操作
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
return *this;
}8.string的字符串操作函数模拟实现
find函数
size_t find(char ch, size_t pos = 0) const
{
assert(pos >= 0 && pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch) return i;
}
return npos;
}size_t find(const char* str, size_t pos = 0) const
{
assert(pos >= 0 && pos < _size);
// 在原串中去匹配子串str
// 匹配成功，返回子串str首字符的地址
// 匹配失败，返回空指针
const char* p = strstr(_str + pos, str);
if (p) return p - _str; // 通过子串str首字符的地址，计算出首字符的下标
else return npos;
}9.string的特殊函数模拟实现
流插入<<运算符重载
// 流插入运算符重载
ostream& operator<<(ostream& out, const string& s)
{
// 遍历string类对象 s ，一个一个字符的插入
for (size_t i = 0; i < s.size(); i++)
{
out << s[i];
}
return out;
}
void test6()
{
// 一般场景下，以下两种输出没有差别
string s1("hello");
cout << s1 << endl; // 编译器当成自定义类型对象处理，匹配该类型重载的<<运算符
cout << s1.c_str() << endl; // C_str()返回char*，编译器当成字符数组处理（内置类型）
// 但是这种场景下有区别
string s2("hello");
s2.resize(10);
s2[9] = 'x'; // 最后一个字符设为'x'
// s2 = "hello\0\0\0\0x"
cout << s2 << endl; // 输出所有有效字符，"hello\0\0\0\0x"
cout << s2.c_str() << endl; // 遇到'\0'终止，"hello"
}流提取>>运算符重载
// 流提取运算符重载
istream& operator>>(istream& in, string& s)
{
// 一个一个字符输入
// 遇到空格或者换行符终止输入
char ch;
in >> ch; // 从流中获取一个字符
while (ch != ' ' && ch != '\n')
{
s += ch; // 把提取的字符追加到sting类对象 s 中去
in >> ch; // 继续从流中获取下一个字符
}
return in;
}
void test7()
{
string s1;
cin >> s1; // operator>>(cin, s1);
cout << s1 << endl;
}getline函数:获取一行字符串，直到遇到换行符 ‘\n’
istream& getline(istream& in, string& s)
{
// 先清空所有有效字符
s.clear();
// 一个一个字符的输入
// 遇到换行符终止输入
char ch;
ch = in.get(); // 从流中获取一个字符
while (ch != '\n')
{
s += ch; // 把获取的字符追加到string类对象 s 中去
ch = in.get(); // 继续从流中获取下一个字符
}
return in;
}关系运算符>重载：关系运算符，进行大小比较
bool operator>(const string& s) const
{
return strcmp(_str, s._str) > 0;
}
bool operator==(const string& s) const
{
return strcmp(_str, s._str) == 0;
}
bool operator>=(const string& s) const
{
return *this > s || *this == s;
}
bool operator<=(const string& s) const
{
return !(*this > s);
}
bool operator<(const string& s) const
{
return !(*this >= s);
}
bool operator!=(const string& s) const
{
return !(*this == s);
}四、string类对象的大小计算
注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。
vs下string的结构
string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义string中字
符串的存储空间：
当字符串长度小于16时，使用内部固定的字符数组来存放当字符串长度大于等于16时，从堆上开辟空间
union _Bxty
{ // storage for small buffer or pointer to larger one
value_type _Buf[_BUF_SIZE];
pointer _Ptr;
char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;
这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建好之后，内
部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。
其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量
最后：还有一个指针做一些其他事情。
故总共占16+4+4+4=28个字节。
g++下string的结构
G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指
针将来指向一块堆空间，内部包含了如下字段：
空间总大小字符串有效长度引用计数
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
指向堆空间的指针，用来存储字符串
。
五、写时拷贝
写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
写时拷贝
写时拷贝在读取是的缺陷
