目录
reverse|push_back|operator+= |append
构造函数的实现
namespace bit { class string { public: string(const char *str) :_str(str) {} private: char* _str; size_t _size; size_t _capacity; }; }?这种写法会报错，因为不能用const char *类型来初始化char *类型的实体
?解决办法，采用动态开辟空间，因为以后要用到增删查改
namespace bit { class string { public: string(const char* str) :_str(new char[strlen(str) + 1]) , _size(strlen(str)) ,_capacity(strlen(str)) { strcpy(_str, str); } private: char* _str; size_t _size; size_t _capacity; }; }这里给_str多开了一个空间，是因为要存放/0
优化后
class string { public: string(const char *str) :_str(new char[strlen(str)+1]) , _size(strlen(str)) ,_capacity(0) { strcpy(_str, str); } string() :_str(new char[1]) , _size(0) , _capacity(0) { _str[0] = '\0'; } const char* c_str()const { return _str; } ~string() { delete[]_str; _str = nullptr; _size = _capacity = 0; } private: char* _str; size_t _size; size_t _capacity; };一个构造函数是针对传参，一个是针对没有传参
如果给的是空指针
?
在打印s2的时候会崩溃
?初始化列表里面初始化的是空指针，但c_const返回类型是char *，返回的是_str,如果传的是空指针，则解引用空指针就会报错，所以这里传参不能传空指针
?给缺省值对构造函数进行优化
?strlen效率是O(N)，这里使用了三次
我们可这样修改，但是在初始化列表中，要注意先声明的先初始化
最好别使用初始化列表，以防出错
?
namespace bit { class string { public: string(const char* str="\0") { _size = strlen(str); _capacity = _size; _str = new char[_capacity + 1]; strcpy(_str, str); } /*string() :_str(new char[1]) , _size(0) , _capacity(0) { _str[0] = '\0'; }*/ const char* c_str()const { return _str; } ~string() { delete[]_str; _str = nullptr; _size = _capacity = 0; } private: char* _str; size_t _size; size_t _capacity; }; void test_string1() { string s1("hello world"); string s2; cout << s1.c_str() << endl; cout << s2.c_str() << endl; } }
?operator 和迭代器
?迭代器左闭右开
typedef char* iterator; iterator begin() { return _str; } iterator end() { return _str + _size; }
?const迭代器
拷贝构造?
?在自己没有写拷贝构造的情况下，进行拷贝会出错，因为系统默认的拷贝是值拷贝，会导致s1的str和str2的str指向同一块空间，前面博客有写到过
?这里可以看到俩个_str的地址一样
?调用析构函数的时候先把str2的_str置空,但可以看到s1的_str没被置空，也就是说存储数组的地址析构完str2的之后，已经变为空了，但是s1的_str仍然指向这块位置，接下来系统会对s1进行析构，对s1一析构就报错，因为这块空间已经被释放过一次了
?解决办法，让str2指向另一块空间，把s1的值拷贝下来即可，释放的时候各自释放各自的，这中方法叫深拷贝
string(const string& s) :_str(new char[s._capacity+1]) ,_size(s._size) ,_capacity(s._capacity) { strcpy(_str, s._str); }
此时他们的地址不一样?，就不会出现析构俩次的问题
.比较懒得一种写法
string(const string& s) { string tmp(s._str); swap(_str, tmp._str); swap(_size, tmp._size); swap(_capacity, tmp._capacity); } string s1("hello world"); string s2(s1);这个程序能完成拷贝构造，但是有一个缺陷，tmp是局部对象，出了作用域会调用析构函数，析构函数
?? ?string tmp(s._str);这条语句调用的是构造
这个写法会崩溃，执行完第一条语句后会tmp和s1一模一样
之后可以把tmp的值给s（s2）
由于是swap函数，s2一开始是一堆随机值，交换之后这些随机值给了tmp,之后调用析构函数，析构不能对tmp的随机空间进行释放，所以会崩溃
稍作修改，稍微初始化以下就行
string(const string& s) :_str(nullptr), _size(0), _capacity(0) { string tmp(s._str); swap(_str, tmp._str); swap(_size, tmp._size); swap(_capacity, tmp._capacity); }?我们也可自己写一个swap
void swap(string& tmp) { ::swap(_str, tmp._str);//库里面的swap ::swap(_size, tmp._size); ::swap(_capacity, tmp._capacity); } string(const string& s) :_str(nullptr), _size(0), _capacity(0) { string tmp(s._str); swap(tmp);//this->swap }
?
注意：
string tmp(s._str)//调用的是构造 strint tmp(s)//调用的是拷贝构造
赋值运算符重载
?如果不写赋值，系统默认的是浅拷贝的赋值，也会出现错误
如
?string s1("hello world"); string s3="11111111111"; ?s3=s1;浅拷贝会让s1的_str和s3的_str指向同一块空间，但s1存储hello world的这块空间就找不到了，同样的析构的时候也会析构俩次
拷贝的时候要考虑到释放s3的原数组空间，然后再建一个新的数组，再把s1数据放进去
我们这样写即可，delete有自动检查机制
string& operator=(const string& s) { delete[]_str; _str = new char[s._capacity + 1]; strcpy(_str, s._str); _size = s._size; _capacity = s._capacity; return *this; }这种方法有个缺陷，语法上允许自己给自己赋值，但如果用上面的自己给自己赋值就会出错，因为一开始就把数组空间就释放了
string& operator=(const string& s) { if (this != &s)//这个是取地址 { delete[]_str; _str = new char[s._capacity + 1]; strcpy(_str, s._str); _size = s._size; _capacity = s._capacity; return *this; } return *this; }或者下面这种方法也可以
string& operator=(const string& s) { char* tmp = new char[s._capacity + 1]; strcpy(tmp, s._str); delete[] _str; _str = tmp; _size = s._size; _capacity = s._capacity; return *this; }以上写法比较传统，下面介绍现代写法
void swap(string& tmp) { ::swap(_str, tmp._str);//库里面的swap ::swap(_size, tmp._size); ::swap(_capacity, tmp._capacity); } string& operator=(const string& s) { if (this != &s) { string tmp(s); swap(tmp); } return *this; }s1=s3
先l利用构造函数把s3的数据拷贝tmp，构造函数的写法，让s3和tmp数组的地址不同
?然后交换即可
tmp是局部对象，除了作用域要析构
?
?string类的swap和库里面的swap区别：
string里面非常简单，直接交换成员变量
库里面会定义一个对象，通过第三方进行交换
下面这种写法会不断调用赋值重载
string& operator=(string s) { swap(s); return *this; }也可这样写，利用传值传参的中间变量，直接进行交换
reverse|push_back|operator+= |append
void reserve(size_t n)//保留数据 { if (n > _capacity) { char* tmp = new char[n + 1]; strcpy(tmp, _str); delete[]_str; _str = tmp; _capacity = n; } } void push_back(char ch) { if (_size==_capacity) { reserve(_capacity == 0 ? 4 : 2 * _capacity); } _str[_size] = ch; ++_size; _str[_size] = '\0'; } string& operator+=(char ch) { push_back(ch); return *this; }void append(const char* str) { size_t len=strlen(str); if (_size + len > _capacity) { reserve(_size + len); } strcpy(_str + _size, str); } void append(const string& s)//函数重载 { append(s._str); }也可用append实现+=
string& operator+=(char* str) { append(str); return *this; }
insert?
void reserve(size_t n)//保留数据 { if (n > _capacity) { char* tmp = new char[n + 1]; strcpy(tmp, _str); delete[]_str; _str = tmp; _capacity = n; } } string& insert(size_t pos, char ch) { assert(pos <= _size); if(_size==_capacity) { reserve(_capacity==0?4:_capacity*2); } size_t end = _size; while (end >= pos) { _str[end + 1] = _str[end]; end--; } _str[end + 1] = ch; ++_size; return *this; }pos=0，这里会报错，因为end会越界，end是size_t类型，0减1之后，是一个很大的数字
这样修改即可
string& insert(size_t pos, char ch) { assert(pos <= _size); reserve(_capacity==0?4:_capacity*2); size_t end = _size+1; while (end > pos) { _str[end ] = _str[end-1]; end--; } _str[end] = ch; ++_size; return *this; }插入字符串
string& insert(size_t pos,const char* str) { assert(pos<=_size); size_t len = strlen(str); if (_size +len> _capacity) { reserve(_size + len); } size_t end = _size+len; while (end >=pos+len) { _str[end] = _str[end - len]; end--; } strncpy(_str + pos, str, len); _size += len; return *this; }通过insert就可以把push_back和append改了
如果用const修饰就可以在声明的时候给缺省值，这是C++特例，const静态处理
find
可用C语言的strstr（子串查找算法）
size_t find(char ch,size_t pos=0) { assert(pos < _size); for (int i = pos; i < _size; ++i) { if (ch == _str[i]) return i; } return npos; } size_t find(const char* sub, size_t pos = 0)const { assert(pos < _size); assert(sub); const char* ptr = strstr(_str + pos, sub); if (ptr == nullptr)//如果没找到 { return npos; } else { return (ptr - _str);//指针相减，返回下标 } }
流提取和流插入重载?
之前我们写过流插入和流提取，用了友元，这里可以不使用友元， 因为以前的友元要访问私有，而这里不需要，所以可以不用友元
ostream& operator<<(ostream& out, const string& s) { for (size_t i = 0; i < s.size(); ++i) { out << s[i]; } return out; }流提取时要注意 cin和scanf获取不到空格和换行，会把空格和换行认定为字符和字符间的间隔
istream& operator>>(istream& in, string& s) { //如果输入字符串很长,不断+=，频繁扩容，效率很低 char ch; ch = in.get(); while (ch != ' ' && ch != '\n') { s += ch; ch = in.get(); } return in; }但是存在一个问题，会和库里面的string产生差异，库里面不会打印拷贝构造的内容，而且输入的字符串如果很长，就会不断的+=，也就意味着要频繁的扩容，效率特别低
?可这样修改，避免频繁扩容
istream& operator>>(istream& in, string& s) { char ch; ch = in.get(); const size_t N = 32; char buff[N]; size_t i = 0; while (ch != ' ' && ch != '\n') { buff[i++] = ch; if (i == N - 1) { buff[i] = '\0'; s += buff; i = 0; } ch = in.get(); } buff[i] = '\0'; s += buff; return in; }
?substr
string substr(size_t pos, size_t len = npos) { assert(pos < _size); size_t realLen = len;//默认给5 if (len == npos ||pos+len>_size) { realLen = _size - pos; } string sub; for (size_t i = 0; i < realLen; ++i) { sub += _str[pos + i]; } return sub; }
operator系列?
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); }?利用C语言中的strcmp进行比较
resize?
void resize(size_t n, char ch = '\0') { if (n > _size) { reserve(n); for (size_t i = _size; i < n; ++i) { _str[i] = ch; } _str[n] = '\0'; _size = n; } else { _str[n] = '\0'; _size = n; } }
?注意事项
vs下的string做了一些特殊的处理，这里的值本来应该是12（内存对齐），但结果却是28
?
?这是因为vs下面进行了一些优化，这是因为vs多开了一个16字节的数组，
?
相当于如果总体大小<16,字符串存在buff数组中，如果>=16，存在_str指向的堆空间上?
string的拷贝问题?
?浅拷贝缺陷：
1.析构俩次
2.一个对象修改影响另外一个对象
解决方案：针对问题1：增加一个引用计数
如果有n个对象指向这块空间就计数为n，这里有俩个就计数为2
?每个对象析构时，--引用计数，最后一个析构的对象释放空间
第二个问题解决办法：写时拷贝，（本质，延迟拷贝，谁去写，谁做深拷贝。没人写就赚了）
这种解决办法叫引用计数+写时拷贝
