因为学习了string的相关知识,了解了string大部分接口的底层实现原理,所以我决定自己模拟实现一个mini版的string类,用来加深对string各方面知识的理解。 如果有错误或不足之处,还望各位读者小伙伴们指出。
#include<iostream>
#include<assert.h>
#include<cstring>
using std::ostream;
using std::istream;
using std:: cout;
using std:: endl;
//构造
string(const char* str = "")
{
size_t len = strlen(str);
_capacity = _size = len;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
该对象自己一点一点的进行深拷贝
//拷贝构造
string(const string& s)
{
_str = new char[s._capacity + 1];
_size = s._size;
_capacity = s._capacity;
strcpy(_str, s._str);
}
找一个中间对象,让这个中间对象用参数的值进行直接构造,再将这个中间对象的内容与自己的内容进行交换。相较于传统写法,现代写法更加简洁。
//拷贝构造
string(const string& s)
:_str(nullptr),//此处要注意将该对象的地址赋值为nullptr,否则析构中间对象时会因为发生野指针的访问而导致程序崩溃。
_size(0),
_capacity(0)
{
string temp(s);
swap(temp);
}
此处的swap用的是string自己实现的swap,为什么不用库里的swap呢?因为库里的swap是进行深拷贝,会降低效率。我们自己实现的swap只需要进行浅拷贝,即将它们对应的资源进行交换即可。
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
//赋值运算符重载
string& operator=(const string &s)
{
if (this != &s)
{
char* temp = new char[s._capacity + 1];//用一个中间值记录新开辟的空间,如果开辟空间成功,再将该空间的地址给_str。避免因为开辟空间失败,_str原本的内容也销毁的情况发生。
strcpy(temp, s._str);
delete[] _str;
_str = temp;
_capacity = s._capacity;
_size = s._size;
}
return *this;
}
与拷贝构造的现代写法思想类似,可以使程序更加简洁。并且此处不需要专门定义一个中间对象,因为传值传参传过来的形参是实参拷贝构造出来的对象,它就是一个很好的中间对象,我们直接和它进行交换即可。
//赋值运算符重载
string& operator=(string s)
{
swap(s);
return *this;
}
//析构
~string()
{
delete[] _str;
_str = nullptr;//释放指针所指向的空间后要将该指针置为空(避免出现野指针的非法访问)
_size = _capacity = 0;
}
迭代器是一个使用起来像指针的东西,实际上string的迭代器就是char*类型的指针,因此我们先在最开始进行typedef
typedef char* iterator;
定义两个迭代器:分别指向字符串开头和结尾
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
string只提供了push_back的接口没有提供头插的接口,因为头插需要移动数据,效率很低,所以尽量不要在string中使用头插。
void push_back(char c)
{
if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;//要考虑到如果初始字符串的容量为0的情况
reserve(newcapacity);
_capacity = newcapacity;
}
_str[_size++] = c;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t len = strlen(str);
if (len + _size > _capacity)
{
reserve(len + _size);
}
strcpy(end(), str);
_size += len;
}
尾插一个字符(复用尾插)
string& operator+=(char c)
{
push_back(c);
return *this;
}
尾插一个字符串(复用append)
string& operator+=(const char* str)
{
append(str);
return *this;
}
清除string中所有元素
void clear()
{
_size = 0;
_str[0] = '\0';
}
在字符串某位置插入一个字符:
// 在pos位置上插入字符c/字符串str
string& insert(size_t pos, char c)
{
assert(pos <= _size);
if (_size + 1 > _capacity)
{
reserve(_size + 1);
}
for (size_t i = _size + 1; i > pos; --i)//要注意避免i减为-1变成一个极大的无符号数,导致死循环
{
_str[i] = _str[i - 1];
}
_str[pos] = c;
++_size;
return *this;
}
在字符串某位置插入一个字符串:
string& insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t i = 0;
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
for (i = _size + len; i > pos + len - 1; --i)
{
_str[i] = _str[i - len];
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}
删除从字符串某位置开始,某长度的子串(如果不说明删除子串的长度,则默认从开始位置到最后的所有内容都删除)
// 删除pos位置上的元素
string& erase(size_t pos, size_t len = npos)
{
if (len == npos || pos + len > _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
return *this;
}
类外成员不能直接访问类的私有属性/数据,因此需要提供一个接口进行访问数据,但是要对数据进行保护,因此用了const传参和传值返回。 访问string中的元素个数。
size_t size()const
{
return _size;
}
访问string的容量。
size_t capacity()const
{
return _capacity;
}
判断字符串是否为空。
bool empty()const
{
if (_size == 0)
{
return true;
}
return false;
}
修改字符串的元素个数,可以尾插指定的字符,未指定则默认插入’\0’。
void resize(size_t n, char c = '\0')//更改元素个数
{
if (n <= _size)
{
_size = n;
_str[_size] = '\0';
}
else
{
reserve(n);//先扩容,再加元素
for (size_t i = _size; i < n; ++i)
{
_str[i] = c;
}
_str[n] = '\0';
_size = n;
}
}
修改字符串的容量。
void reserve(size_t n)//更改容量大小
{
if (n > _capacity)
{
char* temp = new char[n + 1];//先开空间再拷贝值(避免因为空间开辟失败的异常使_str原地址也丢失了)
strcpy(temp, _str);
delete[] _str;
_str = temp;
_capacity = n;
}
}
访问字符串中的字符,运算符[]重载。
char& operator[](size_t index)//普通对象的接口(可读可写)
{
assert(index < _size);
return _str[index];
}
const char& operator[](size_t index)const//const对象的接口(只读)
{
assert(index < _size);
return _str[index];
}
bool operator<(const string& s)
{
size_t len = _size < s._size ? _size : s._size;
for (size_t i = 0; i < len; ++i)
{
if ((*this)[i] >= s[i])
{
return false;
}
return true;
}
}
bool operator>(const string& s)
{
size_t len = _size < s._size ? _size : s._size;
for (size_t i = 0; i < len; ++i)
{
if ((*this)[i] <= s[i])
{
return false;
}
return true;
}
}
复用>。
bool operator<=(const string& s)
{
return !(*this > s);
}
复用<。
bool operator>=(const string& s)
{
return !(*this < s);
}
复用<和>。
bool operator==(const string& s)
{
return (!((*this) < s)) && (!((*this) > s));
}
复用==。
bool operator!=(const string& s)
{
return !((*this) == s);
}
找一个字符第一次在字符串中出现的下标
// 返回c在string中第一次出现的位置(下标)
size_t find(char c, size_t pos = 0) const
{
assert(pos < _size);
for (size_t i = 0; i < _size; ++i)
{
if ((*this)[i] == c)
{
return i;
}
}
return npos;
}
找一个子串第一次出现在字符串中的下标 复用C语言对字符串的操作——strstr函数(在一个字符串中找子串)
// 返回子串s在string中第一次出现的位置(下标)
size_t find(const char* s, size_t pos = 0) const
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, s);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
也可以一个字符一个字符的遍历寻找:
// 返回子串s在string中第一次出现的位置(下标)
size_t find(const char* s, size_t pos = 0) const
{
assert(pos < _size);
size_t i = 0;
while (i < _size)
{
int flag = 0;
if ((*this)[i] == s[0])
{
size_t k = i;
for (size_t j = 0; j < strlen(s); ++j, ++k)
{
if ((*this)[k] != s[j])
{
flag = 1;
}
}
if (flag == 0) return i;
}
i++;
}
return npos;
}
返回字符串的地址
const char* c_str()const
{
return _str;
}
ostream& operator<<(ostream& _cout, const string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
_cout << s[i];
}
return _cout;
}
istream& operator>>(istream& _cin, string& s)
{
s.clear();//将原来s中的值清除
char buff[128] = { '\0' };
size_t i = 0;
char ch = _cin.get();//这里不能使用getc或者scanf函数的原因是他们都是按照空格' '或者换行'\n'进行分割内容的,所以无法取到空格和换行,因此只能用get()
while (ch != ' ' || ch != '\n')
{
if (i == 127)//缓存部分满了
{
s += buff;//将内容存入s,同时将缓存部分情况
i = 0;
}
buff[i++] = ch;
ch = _cin.get();
}
return _cin;
}
private:
char* _str;
size_t _capacity;
size_t _size;
const static size_t npos = -1;//只有这个特例可以这样定义,其他static数据成员都要在类内声明,在类外定义。
以上就是今天要讲的内容,本文介绍了作者自己实现的string类的相关类成员函数,如果文章中的内容有错误或者不严谨的部分,欢迎大家在评论区指出,也欢迎大家在评论区提问、交流。 最后,如果本篇文章对你有所启发的话,希望可以多多支持作者,谢谢大家!