模拟实现string
1.代码理解
1.substr
断言指定的位置在字符的长度之内，_size-len是剩余字符的长度(pos后面的),如果输入len是大于pos后面的字符长度则默认为pos后面全部的字符去拷贝，再建立一个sub去储存，通过循环把pos后面的字符接收到sub里面。
string string::substr(size_t pos, size_t len)
{
assert(pos < _size);
if (len > _size - pos)
{
len = _size - pos;
}
string sub;
sub.reserve(len);
for (size_t i = 0; i < len; i++)
{
sub[i] = _str[pos + i];
}
return sub;
}注意下面，如果成员函数没有写拷贝函数的话，编译器是自动写一个浅拷贝的函数，这里调用substr函数去拷贝给suffix，而浅拷贝只是把一个一个字节拷贝过去，而string是私有成员有_str，是一个指针有指向空间的，这样的话就是suffix和sub俩个的私有成员_str都指向这片空间，但是sub是值传回，会产生一个临时变量(与sub一样) 去拷贝给suffix,而临时变量的声明周期就只有一行代码(下一行开始就销毁了),所以suffix的_str指向的空间也被销毁了，所以说字符无效，需要自己写一个深拷贝去把指向空间单独储存，不是一起指向。
2.运算符重载
这里主要是运用了strcmp函数，可以去比较俩个字符的大小，需要俩个字符的地址，如果是第一个大于第二个就会返回一个大于0的值，否则就返回小于0的值，等于就返回小于0的值。
注意：运算符重载的定义要写在类的外面，因为写在类里面就会出问题，写在类的里面会有一个隐藏的参数this，而二元运算符是不能有三个参数的(一个隐式俩个显式)。
bool operator<(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str())<0;
}
bool operator<=(const string& s1, const string& s2)
{
return s1 < s2 || s1 == s2;
}
bool operator==(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str())==0;
}
bool operator>(const string& s1, const string& s2)
{
return !(s1 <= s2);
}
bool operator != (const string & s1, const string & s2)
{
return !(s1 == s2);
}3.输出和输入
输出>>就用范围for一个一个输出到控制台，这里输出前先清空s的内容(删除之前的内容)，定义一个N，get()函数可以一个一个获取输出的字符(可以获取停止符‘ ’ 空格，所以再可以去判断是否读取到空格)，然后循环条件就是读到空格或者\n，把读取到的内容放到buff数组里面，如果储存的内容达到定义的N-1个就要把最后一个位置留个\0，然后把整个buff尾插到s上面，然后把i置0重新开始储存，循环结束后还要判断i是否为0，为0表示数组没有数据，不为0表示还有一些，先把buff最后一位\0然后再尾插到s上面，没有\0是不完整的，之前的\0在尾插后会被覆盖掉，所以要重新给终止符。
ostream& operator>>(ostream& out, const string& s)
{
for (auto ch : s)
{
out << ch;
}
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear();
const int N = 256;
int i = 0;
char buff[N];
char ch;
ch = in.get();
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i > 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}4.insert
_size+len是否大于容量，大就扩容，这里end>pos+len-1(跟end>=pos+len一样)，比如hello world，pos指向o，要加入三个xxx，则pos+len在o处，end-len就是原字符的最后一个d处，要把空格后面包括空格一起往后挪三个位置，所以end-len是要到空格的，而end-len到空格要六个距离，就说明循环要走六次而end--要指向六次，而第六次就是pos+len的位置，所以要取等号，挪完位置后就把要插入的数据填到里面。
void string::insert(size_t pos, const char* s)
{
assert(pos <= _size);
size_t len = strlen(s);
if (_size + len > _capacity)
{
reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
}
size_t end = _size + len;
while (end > pos + len - 1)
{
_str[end] = _str[end - len];
--end;
}
for (size_t i = 0; i < len;)
{
_str[pos + i] = s[i];
}
_size += len;
}5.erase删除
这里_size-pos是指定位置之后的字符，如果输入的len大于这个就默认为删除后面全部，只需要把pos位置变为\0终止符，不是就走else，这里通过覆盖了实现删除，再把_size-len就行，就行hello world，把后面的往前挪，而像d的就不用置0，因为_size就访问不到了(size-len)。
void string::erase(size_t pos, size_t len)
{
assert(pos < _size);
if (_size - pos < len)
{
_str[pos] = '\0';
_size = pos;
}
else
{
for (size_t i = pos + len; i < _size; i++)
{
_str[i - len] = _str[i];
}
_size -= len;
}
}6.find
这里用strstr函数，作用是给俩个字符地址然后找到俩个字符第一个相同的字符的指针，刚好就可以把pos位置的指针传过来，再判断是否为空，不为空就返回俩个地址相减的值，俩个地址相减是俩个地址的距离，可以得到pos的值。
size_t string::find(const char* str, size_t pos)
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, _str);
if (ptr == nullptr)
{
return npos;
}
else
return ptr - _str;
}剩下的代码在前一篇文章已讲。
总代码
string.h
#include<iostream>
#include<string>
#include<assert.h>
using namespace std;
namespace zym
{
class string
{
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()
:_str(new char[1]{'\0'})
,_size(0)
,_capacity(0)
{}*/
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
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;
}
~string()
{
if (_str)
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
}
const char* c_str() const
{
return _str;
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n);
void push_back(char ch);
string& operator+=(char ch);
string& operator+=(const char* str);
void insert(size_t pos, char ch);
void insert(size_t pos, const char* str);
void erase(size_t pos, size_t len = npos);
void append(const char* str);
size_t find(char ch, size_t pos);
size_t find(const char* str, size_t pos);
string substr(size_t pos, size_t len);
//void test();
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;
//static const size_t npos=1;//这里是定义的行为，static const才可以，其它不写而且还要是 整型
//给static const整型开绿灯 为了方便下面行为
//static const int N =10
//int buff[N]
static const size_t npos;
};
bool operator<(const string& s1, const string& s2);
bool operator<=(const string& s1, const string& s2);
bool operator>(const string& s1, const string& s2);
bool operator==(const string& s1, const string& s2);
bool operator!=(const string& s1, const string& s2);
bool operator>=(const string& s1, const string& s2);
}string.cpp
#include"string.h"
namespace zym
{
const size_t string::npos = -1;
void string::reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];//给/0留一个位置
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void string::push_back(char ch)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
++_size;
//_str[_size] ='\0';//因为/0被覆盖了所以需要重新加上/0
}
string& string::operator+=(char ch)
{
push_back(ch);
return *this;
}
void string::append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
}
strcpy(_str + _size, str);
_size += len;
}
string& string::operator+=(const char* str)
{
append(str);
return *this;
}
void string::insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
--end;
}
_str[pos] = ch;
++_size;
}
void string::insert(size_t pos, const char* s)
{
assert(pos <= _size);
size_t len = strlen(s);
if (_size + len > _capacity)
{
reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
}
size_t end = _size + len;
while (end > pos + len - 1)
{
_str[end] = _str[end - len];
--end;
}
for (size_t i = 0; i < len;)
{
_str[pos + i] = s[i];
}
_size += len;
}
void string::erase(size_t pos, size_t len)
{
assert(pos < _size);
if (_size - pos < len)
{
_str[pos] = '\0';
_size = pos;
}
else
{
for (size_t i = pos + len; i < _size; i++)
{
_str[i - len] = _str[i];
}
_size -= len;
}
}
size_t string::find(char ch, size_t pos)
{
for (size_t i = pos; i <_size; i++)
{
if (_str[i] == ch)
return i;
}
return npos;
}
size_t string::find(const char* str, size_t pos)
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, _str);
if (ptr == nullptr)
{
return npos;
}
else
return ptr - _str;
}
string string::substr(size_t pos, size_t len)
{
assert(pos < _size);
if (len > _size - pos)
{
len = _size - pos;
}
string sub;
sub.reserve(len);
for (size_t i = 0; i < len; i++)
{
sub[i] = _str[pos + i];
}
return sub;
}
bool operator<(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str())<0;
}
bool operator<=(const string& s1, const string& s2)
{
return s1 < s2 || s1 == s2;
}
bool operator==(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str())==0;
}
bool operator>(const string& s1, const string& s2)
{
return !(s1 <= s2);
}
bool operator != (const string & s1, const string & s2)
{
return !(s1 == s2);
}
ostream& operator>>(ostream& out, const string& s)
{
for (auto ch : s)
{
out << ch;
}
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear();
const int N = 256;
int i = 0;
char buff[N];
char ch;
ch = in.get();
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i > 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
}原文地址：https://blog.csdn.net/2302_80378107/article/details/142700088
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！