namespace bit
{
class String
{
public:
typedef char* Iterator;
public:
String(const char* str = " ")
{
if(str == nullptr)
{
assert(false);
return ;
}
_size = strlen(str);
_capacity = _size;
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
String(const String& s)
: _str(new char[strlen(s._str) + 1])
, _size(s._size)
, _capacity(s._capacity)
{
strcpy(_str, s._str);
}
String& operator = (const String& s)
{
if(this != &s)
{
char* pstr = new char[strlen(s._str) + 1];
strcpy(pstr, s._str);
delete[] _str;
_str = pstr;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}
~String()
{
if(_str)
{
delete[] _str;
_str = nullptr;
}
}
迭代器
Iterator Begin()
{
return _str;
}
Iterator End()
{
return _str + _size;
}
void Reserve(size_t newCapacity)
{
if(newCapacity > _capacity)
{
char* str = new char[newCapacity + 1];
strcpy(str, _str);
delete[] _str;
_str = str;
_capacity = newCapacity;
}
}
void PushBack(char c)
{
if(_size == _capacity)
Reserve(_capacity * 2);
_str[_size++] = c;
_str[_size] = '\0';
}
void Append(size_t n, char c)
{
for(int i = 0; i < n; i++)
{
PushBack(c);
}
}
String& operator += (char c)
{
PushBack(c);
return *this;
}
bool operator<(const String& s)
{
return (&s < this);
}
bool operator<=(const String& s)
{
return !(&s > this);
}
bool operator>(const String& s)
{
return (&s > this);
}
bool operator>=(const String& s)
{
return !(&s < this);
}
bool operator==(const String& s)
{
return (&s == this);
}
bool operator!=(const String& s)
{
return !(&s == this);
}
返回c在string中第一次出现的位置
size_t Find (char c, size_t pos = 0) const
{
for(size_t i = pos; i < _size; i++)
{
if(c == _str[i])
return i;
}
return 0;
}
size_t rFind (char c)
{
for(size_t i = _size; i >= 0; --i)
{
if(c == _str[i])
return i;
}
return 0;
}
返回子串s在string中第一次出现的位置
size_t Find (const char* s, size_t pos = 0) const
{
assert(s);
size_t len = strlen(s);
for(int i = pos; i < _size; i++)
{
int j = 0;
if(_str[i] != s[j])
continue;
while(j < len && i + j < _size)
{
j++;
if(_str[i+j] != s[j])
break;
}
if(j == len)
return i + 1;
}
return 0;
}
截取string从pos位置开始的n个字符
String SubStr(size_t pos, size_t n)
{
if(pos > 0 && (pos <= _size))
{
char *tmp = new char[n];
memcpy(tmp, _str + pos - 1, n - 1);
}
return *this;
}
在pos位置上插入字符c/字符串str,并返回该字符的位置
String& Insert(size_t pos, const char* str)
{
判断pos的值是否合理
if(pos > 0 && pos <= _size)
{
检查容量是否足够
Reserve(strlen(str));
创建一块临时空间去接收_str中pos之后的数据
char *tmp = new char[_size - pos + 2];
strcpy(tmp, _str + pos -1);
此时需要将str的数据插入到pos之后,用strcat函数即可,但是注意被追加字符串的哪个字符串必须以'\0'结尾
_str[pos - 1] = '\0';
strcat(_str, str);
strcat(_str, tmp);
_size += strlen(str);
_str[_size] = '\0';
delete[] tmp;
}
return *this;
}
删除pos位置上的元素,并返回该元素的下一个位置
String& Erase(size_t pos, size_t len)
{
if(pos > 0 && pos <= _size)
{
size_t npos = pos - 1;
size_t index = npos + len;
while(npos + len != _size)
{
_str[npos++] = _str[index++];
}
_size -= len;
_str[_size] = '\0';
}
return *this;
}
void Append(const char* str)
{
size_t len = strlen(str);
if(len > _capacity - _size)
Reserve(2 * _capacity + len);
/*for(int i = 0; i < strlen(str); i++)
{
PushBack(str[i]);
}*/
strcat(_str, str);
_size += len;
}
void Resize(size_t newSize, char c = char())
{
if(newSize > _size)
{
如果newSize大于旧_size,就需要开辟新空间
Reserve(newSize);
memset(_str + _size, c, newSize - _size);
}
_size = newSize;
_str[_size] = '\0';
}
char& operator [](size_t index)
{
assert(index < _size);
return _str[index];
}
const char& operator [](size_t index)const
{
assert(index < _size);
return _str[index];
}
private:
friend ostream& operator << (ostream& _cout,const String& s);
private:
char* _str;
size_t _size;
size_t _capacity;
};
ostream& bit::operator << (ostream& _cout,const String& s)
{
cout << s._str;
return _cout;
}
}