1、string的基本概念
string是表示字符串的字符串类,所以在模拟实现string类时,我们先定义一个String类
class String
{
public:
//成员函数
private:
//成员变量
char* _ptr;
char* _size;
char* _capacity;
};
_ptr表示字符串指针,_size表示字符串大小,_capacity表示容量
2、成员函数的实现
(1)构造函数
String(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_ptr = new char[_capacity + 1];
strcpy(_ptr, str);
}
(2)拷贝构造
String(const String& str)
:_ptr(nullptr)
, _size(0)
, _capacity(0)
{
String tmp(str._ptr);
Swap(tmp);
}
void Swap(String& str)
{
swap(_ptr, str._ptr);
swap(_capacity, str._capacity);
swap(_size, str._size);
}
(3)赋值
String operator=(String str)
{
Swap(str);
return *this;
}
(4)析构
~String()
{
if (_ptr)
{
delete[] _ptr;
_ptr = nullptr;
}
}
(5)尾插
void push_back(const char ch)
{
//判断容量
if (_size == _capacity)
{
//增容
size_t newCapacity = _capacity == 0 ? 15 : 2 * _capacity;
reverse(newCapacity);
}
//插入
_ptr[_size++] = ch;
_ptr[_size] = '\0';
}
(6)增容
void reverse(size_t n)
{
if (n > _capacity)
{
//开新空间
char* tmp = new char[n + 1];
//拷贝原始空间内容
strcpy(tmp, _ptr);
//释放原有空间
delete[] _ptr;
_ptr = tmp;
//更新容量
_capacity = n;
}
}
(7)修改字符串大小
void resize(size_t sz, char ch = '\0')
{
if (sz > _capacity)
{
//增容
reverse(sz);
}
if (sz > _size)
{
//赋值
memset(_ptr + _size, ch, sz - _size);
}
_size = sz;
_ptr[_size] = '\0';
}
(8)[]运算符重载
char& operator[](size_t pos)
{
assert(pos < _size);
return _ptr[pos];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _ptr[pos];
}
(9)迭代器的实现
typedef char* iterator;
typedef const char* const_iterator;
// 第一个元素
iterator begin()
{
return _ptr;
}
// 最后一个元素的下一个位置
iterator end()
{
return _ptr + _size;
}
const_iterator begin() const
{
return _ptr;
}
const_iterator end()const
{
return _ptr + _size;
}
//遍历
void test()
{
String str1 = "123456";
String::iterator it = str1.begin();
while (it != str1.end)
{
cout << *it << " ";
++it;
}
cout << endl;
}
(10)追加字符串
void Append(const char* str)
{
int len = strlen(str);
if (_size + len > _capacity)
{
reverse(_size + len);
}
//尾插字符串
strcpy(_ptr + _size, str);
_size += len;
}
(11)+= 操作
String& operator+=(const char& ch)
{
push_back(ch);
return *this;
}
String& operator+=(const char* str)
{
Append(str);
return *this;
}
(12)任意位置插入字符
void insert(size_t pos, const char& ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
size_t newCapacity = _capacity == 0 ? 15 : 2 * _capacity;
reverse(newCapacity);
}
size_t end = _size;
while (end > pos)
{
_ptr[end] = _ptr[end - 1];
--end;
}
_ptr[pos] = ch;
_ptr[++_size] = '\0';
}
(13)任意位置插入字符串
void insert(size_t pos, const char* str)
{
assert(pos <= _size);
int len = strlen(str);
if (_size + len > _capacity)
{
reverse(_size + len);
}
size_t end = _size + len;
while (end > pos + len - 1)
{
_ptr[end] = _ptr[end - len];
--end;
}
memcpy(_ptr + pos, str, len*sizeof(char));
_size += len;
}
(14)pos位置删除len个字符
void erase(size_t pos, size_t len)
{
assert(pos < _size);
if (pos + len >= _size)
{
_size = pos;
_ptr[_size] = '\0';
return;
}
size_t start = pos + len;
while (start < _size)
{
_ptr[start - len] = _ptr[start];
++start;
//_ptr[pos++] = _ptr[start++];
}
_size -= len;
_ptr[_size] = '\0';
}
(15)返回字符ch在字符串中第一次出现的位置
size_t find(const char& ch, size_t pos = 0)
{
for (size_t i = pos; i < _size; i++)
{
if (_ptr[i] == ch)
return i;
}
return npos;
}
(16) 返回子串str在字符串中第一次出现的位置
size_t find(const char* str, size_t pos = 0)
{
char* start = strstr(_ptr + pos, str);
if (start)
{
return start - _ptr;
}
return -1;
}
(17)求大小、容量、判空
size_t size()const
{
return _size;
}
size_t capacity()const
{
return _capacity;
}
bool empty()const
{
return _size == 0;
}
(18)比较字符串的大小
bool operator<(const string& s)
{
return strcmp(_str, s._str) < 0 ? true : false;
}
bool operator<=(const string& s)
{
return ((*this < s )|| (*this == s));
}
bool operator>(const string& s)
{
return !((*this < s) || (*this == s));
}
bool operator>=(const string& s)
{
return !(*this < s);
}
bool operator==(const string& s)
{
return strcmp(_str, s._str) == 0 ? true : false;
}
bool operator!=(const string& s)
{
return !(*this == s);
}
这些函数的实现看起来很简单,但是在自己动手敲的时候还是会出现一些大大小小的问题,所以,要多练习呀!完结!!!