目录
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
每个对象析构时,--引用计数,最后一个析构的对象释放空间
第二个问题解决办法:写时拷贝,(本质,延迟拷贝,谁去写,谁做深拷贝。没人写就赚了)
这种解决办法叫引用计数+写时拷贝