STL中的string模拟实现
string类中的常用接口总结
namespace bit
{
class string
{
public:
//构造函数
string(const char* str = "");
//拷贝构造
string(const string& str);
//析构函数
~string();
//迭代器
typedef char* iterator;
typedef const char* const_iterator;
//string类访问操作
iterator begin();
iterator end();
const_iterator begin()const;
const_iterator end()const;
char& operator[](size_t pos);//[]运算符重载
const char& operator[](size_t pos)const;
//string类容量操作
size_t size();
size_t capacity();
void resize(size_t n, char c);
void reserve(size_t n = 0);
void clear();
bool empty() const;
//string类修改字符串操作
void push_back(char c);
void append(const char* str);
string& operator+= (const string& str);
string& operator+= (const char* s);
void insert(size_t pos, char c);
void insert(size_t pos, const char* str);
void erase(size_t pos = 0, size_t len = npos);
void swap(string& str);
//string类字符串操作
const char* c_str() const;
size_t find(const char* s, size_t pos = 0) const;
string substr(size_t pos = 0, size_t len = npos) const;
private:
char* _str;
size_t _size;
size_t _capacity;
public:
static const int 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);
//<< 和 >> 运算符重载
ostream& operator<<(ostream& out, const string& s1);
istream& operator>>(istream& in, string& s1);
//getline()模拟实现
istream& getline(istream& in, string& s1);
}
string的默认成员函数
构造函数
构造函数添加缺省参数，如果没有添加传入参数，则构造空字符。
string(const char* str = "")
:_size(strlen(str))//初始值为传入参数字符长度的大小
{
_capacity = _size;//初始字符串容量大小为字符串长度大小
_str = new char[_capacity + 1];//开辟新的空间为容量+1用来存放“\0”
strcpy(_str, str);//复制str中的字符到_str开好的空间中
}
拷贝构造函数
拷贝构造函数的实现就需要了解浅拷贝和深拷贝。
浅拷贝：常用于内置类型的拷贝方式，拷贝的目标对象的指针与源对象的目标指针指向的是同一块空间，任意一方的改动会对另一方造成影响。（常用于内置类型的拷贝）
深拷贝：拷贝的目标对象的指针与源对象的指针所指向的空间各自存在，因此任意一方的改动并不会对另一方造成影响。
传统写法
传统方法就是开辟一个与源对象同样大小的空间，将源对象中的字符串、_size、_capacity，拷贝到开辟的空间中。
string(const string& str)
{
_str = new char[str._capacity + 1];
strcpy(_str, str._str);
_size = str._size;
_capacity = str._capacity;
}
现代写法
现代写法就是构造一个源对象一样的string对象tmp，再与让tmp与this交换。
string(const string& str)
{
string tmp(str._str);
swap(tmp);
}
析构函数
析构函数需要调用delete[] 手动释放，因为string对象中_str都在堆上开辟空间存放字符串，当对象销毁时堆上的空间并不会释放会造成内存泄漏。
~string()
{
delete[] _str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
迭代器
我们在这里将迭代器设置为char* ，但是并不是所有的迭代器的底层都是char*。
typedef char* iterator;
typedef const char* const_iterator;//const对象调用
begin() 和 end()
begin() 的作用就是返回字符串第一个字符地址，end() 返回最后一个字符地址后面一个地址。
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const 对象调用 begin() 和 end()
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
迭代器的使用
我们了解了迭代器的底层，现在使用迭代器遍历数组。
string s1("hello world");
string::iterator it1 = s1.begin();
while (it1 != s1.end())
{
cout << *it1 << " ";
++it1;
}
另一个与迭代器相关的是范围for(),范围for()并没有什么高大上的地方，在编译时编译器会自动将范围for()替换成迭代器的形式。
string s1("hello world");
for (auto ch : s1)
{
cout << ch << " ";
}
operator[]运算符重载
operator[]成员函数实现的目的是让string对象字符能和c中的字符串一样能够使用下标访问。
char& operator[](size_t pos)//可读可写
{
assert(pos < _size);//检查pos位置
return _str[pos];//返回字符
}
const char& operator[](size_t pos) const//可读
{
assert(pos < _size);//检查pos位置
return _str[pos];//返回字符
}
string类容量操作
size() 和capacity()
string类中的_size 和_capacity 都是私有的不能直接访问，因此下需要我们编写size()和capacity()成员函数来获取大小和容量。
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
reserve()
reserve()的使用情况有两种：
- 当参数n小于_caapcity时，什么也不做
- 当n大于_capacity时， 会将string对象容量_capacity扩大到n。
void reserve(size_t n )
{
if (n > _capacity)
{
char* tmp = new char[n + 1];//创建临时空间
strcpy(tmp, _str);//将_str中的内容拷贝到tmp中
delete[] _str;//释放原来的空间
_str = tmp;//让_str指向tmp指向的空间
_capacity = n;//调整容量大小
}
}
resize()
resiz()的使用有两种情况：当参数n小于字符串_size时，字符串会缩小到n。另一种就是n大于_size时，_size会扩大到n，并会用c扩大，若是没有给出则默认给’\0’。
void resize(size_t n,char c = '\0')
{
if (n < _size)
{
_str[n] = '\0';
_size = n;
}
else
{
reserve(n);//扩容
for (size_t i = _size; i < n; i++)
{
_str[i] = c;
}
_str[n] = '\0';
_size = n;
}
}
clear()
clear()就是将_str中的数据清空。注意：只是将数据清空，并不是释放空间。
void clear()
{
_size = 0;
_str[_size] = '\0';
}
empty()
empty()判断字符串是否为空。
bool empty() const
{
return strcmp(_str, " ") == 0;
}
string类修改字符串操作
push_back()
在string类中常用的尾插就时尾插单一字符。
void push_back(char c)
{
if (_size == _capacity)//判断是否需要扩容
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
_str[_size] = c;//尾插字符
++_size;
_str[_size] = '\0';
}
append()
append()在string对象后面追加字符串。
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)//判断是否需要扩容
{
reserve(_size + len);
}
strcpy(_str + _size, str);//在相应的位置拷贝字符串
_size += len;
}
operator+=运算符重载
operator+=说白了就是成员函数的复用。
//+=单一字符
string& operator+= (char s)
{
push_back(s);
return *this;
}
//+=字符串
string& operator+= (const char* s)
{
append(s);
return *this;
}
insert()
insert()的使用要复杂一点，在pos位置插入字符或者字符串。需要将pos位置原有的字符往后挪动，pos位置空出后才能插入字符串。
void insert(size_t pos, char c)//插入单一字符
{
assert(pos < _size);//断言插入pos位置不能超过_size
if (_size == _capacity)//判断是否需要扩容
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
size_t end = _size+ 1;
while (end > pos)//挪动数据
{
_str[end] = _str[end-1];//将前一个数据往后挪动
--end;
}
_str[pos] = c;//在pos位置插入数据
++_size;
}
void insert(size_t pos, const char* str)//插入字符串
{
assert(pos < _size);//断言插入pos位置不能超过_size
size_t len = strlen(str);//测出待插入字符串的长度
if (_size+len > _capacity)//判断是否需要扩容
{
reserve(_size+len);
}
size_t end = _size + len;
while (end > pos + len-1)//挪动数据
{
_str[end] = _str[end - len];
--end;
}
strncpy(_str + pos, str, len);//在pos位置插入字符串
_size += len;
}
erase()
void erase(size_t pos = 0, size_t len = npos)
{
assert(pos < _size);
if (len == npos || len >= _size - pos)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}
swap()
swap()作用是交换两个对象的数据，直接调用库中的swap模板即可。但是想要调用库中实现的swap函数就要加域限定符 :: ，否则编译器就会调用你实现的swap函数（调用函数的就近原则）。
void swap(string& str)
{
std::swap(_str,str._str);//交换字符串
std::swap(_size, str._size);//交换字符串大小
std::swap(_capacity, str._capacity);//交换数据容量
}
c_str()
c_str()用于获取string对象的字符串，返回值直接就是_str。
const char* c_str() const
{
return _str;
}
find()
find()用于查找字符，若是找到返回字符下标位置。
size_t find(const char* s, size_t pos = 0) const
{
assert(pos < _size);//查找位置不能超过_size
const char* p = strstr(_str + pos, s);
if (p)
{
return p - _str;
}
else
{
return npos;
}
}
substr()
substr()用于获取源对象中的字符放入一个新对象中并返回。
string substr(size_t pos = 0, size_t len = npos) const
{
string s;//新对象
if (len == npos || len >= _size - pos) //判断获取源对象字符长度
{
for (size_t i = 0; i < _size; i++)
{
s += _str[i];
}
}
else
{
for (size_t i = pos; i < pos+len ; i++)
{
s += _str[i];
}
}
return s;
}
关系运算符重载
多数的关系运算符都是各个运算符之间的复用。
operator==()
用于判断两个string对象是否相等。
bool operator==(const string& s1, const string& s2)
{
int ret = strcmp(s1.c_str(), s2.c_str());
return ret == 0;
}
operator<()
判断两个string对象的大小
bool operator<(const string& s1, const string& s2)
{
int ret = strcmp(s1.c_str(), s2.c_str());
return ret < 0;
}
operator<=()
operator<和 operator== 的复用。
bool operator<=(const string& s1, const string& s2)
{
return s1 < s2 || s1 == s2;
}
operator>()
operator<=结果取反。
bool operator>(const string& s1, const string& s2)
{
return !(s1 <= s2);
}
operator>=()
operator<结果取反。
bool operator>=(const string& s1, const string& s2)
{
return !(s1 < s2);
}
operator!=()
operator==结果取反。
bool operator!=(const string& s1, const string& s2)
{
return !(s1 == s2);
}
operator<<()
流插入的重载比较容易，复用迭代器或或者范围for就行。在这里就是用范围for。
ostream& operator<<(ostream& out, const string& s1)
{
for (auto ch : s1)
{
out << ch << "";
}
return out;
}
operator>>()
这种写法有一种好处就是即使输入的字符很大，string的扩容也不会造成浪费。原因函数调用结束buff出了作用域就销毁了。
istream& operator>>(istream& in, string& s1)
{
s1.clear();//清除s1中原有的数据
char ch;
ch = in.get();//提取输入的字符
char buff[128];//创建字符数组
size_t i = 0;
while (ch!=' '&& ch!='\n')//遇到空格或者换行就停止
{
buff[i++] = ch;//将提取的字符放入字符数组中
if (i == 127)//若是字符数组存满了
{
buff[127] = '\0';
s1 += buff[127];
i = 0;
}
ch = in.get();
}
if (i > 0)
{
buff[i] = '\0';
s1 += buff;
}
return in;
}
getline模拟实现
getline 唯一于operator>>不同的就是遇到空格不会停止，取一整行的字符。
istream& getline(istream& in, string& s1)
{
s1.clear();
char ch;
ch = in.get();
char buff[128];
size_t i = 0;
while (ch != '\n')
{
buff[i++] = ch;
if (i == 127)
{
buff[127] = '\0';
s1 += buff[127];
i = 0;
}
ch = in.get();
}
if (i > 0)
{
buff[i] = '\0';
s1 += buff;
}
return in;
}
1479
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
