C++string类模拟实现
文章目录
-
-
- 构造函数
-
- 有参构造函数
- 无参构造函数
- 简略版本
- 深拷贝和浅拷贝
- 赋值重载
- 析构函数
-
- npos
- c_str
- 迭代器
- reserve
- push_back() && append()
- []运算符
- insert
- erase
- +=
- find
- cout,cin
- 总结：
- string.h 和测试代码
-
在前面我们学习string的功能，今天我们来模拟一下string类的实现。
构造函数
有参构造函数
string(const char *str)//(1)
:_size(strlen(str)),//(2)
_capacity(_size)//(3)
{
_str = new char[_capacity + 1];//(4)
strcpy(_str, str);//(5)
}
( 1 ) (1) (1)形参传递的字符串属于常量区，不能修改，const不能忘了
( 2 ) (2) (2)计算字符串的长度
( 3 ) (3) (3)初始化字符串容量_capacity
( 4 ) (4) (4)为字符指针开辟空间，这里需要多开一个字节，因为传进来的可能是个空串，空串含有一个'/0'(strlen计算到\0即停止，不含\0)。
------------------------------------------------------------我是分割线-----------------------------------------------------------
无参构造函数
string()
:_size(0),//(1)
_capacity(0),//(2)
_str(new char[1])//(3)
{
_str[0] = '\0';
}
( 1 ) ( 2 ) (1)(2) (1)(2)因为传进来的是一个空串，所以_size和_capacity都设置为0
( 3 ) (3) (3)空串有个/0，为其开一个字节空间。
简略版本
为了简略，上面的两种构造函数可以合成一个：
string(const char*str="")//传进来的可能是空串 这里包含了无参和有参
:_str(nullptr),
_size(0),
_capacity(0)
{
int newcapacity = strlen(str);//(1)
_str = new char[newcapacity + 1];//(2)
strcpy(_str, str);//(3)
_size = newcapacity;//(4)
_capacity = newcapacity;//(5)
}
( 1 ) (1) (1)计算形参字符串的长度
( 2 ) (2) (2)申请空间
( 3 ) (3) (3)拷贝字符串的数据
( 4 ) (4) (4)更新_size
( 5 ) (5) (5)更新_capacity
------------------------------------------------------------我是分割线-----------------------------------------------------------
深拷贝和浅拷贝
在模拟拷贝构造函数之前，我们首先学习一下深拷贝和浅拷贝。
浅拷贝：计算机默认提供的拷贝构造函数和赋值重载函数实现的都是浅拷贝，浅拷贝完成的字节序的拷贝。举例说明：浅拷贝就是抄作业，连名字也一起照抄的一种行为。
这种不修改的名字的抄作业行为有时候就容易被老师发现，然后被逮住。
在计算机中也是如此：
浅拷贝带来的问题就是总结就是：堆区申请的内存被重复释放
浅拷贝的问题需要通过人为深拷贝进行解决。
解决方法如下：
在了解了深浅拷贝以后，我们继续学习拷贝构造函数的实现：
拷贝构造函数的传统写法：自己开空间，完成深拷贝
string(const string &s)//拷贝构造
:_size(s._size)//(1)
_capacity(s._capacity),//(2)
_str(nullptr)
{
//reserve(_capacity); ！！！！拷贝构造这里不能使用reserve ，因为strcpy会解引用空指针
_str = new char[_capacity+1];//(3)
strcpy(_str, s._str);//(4)
}
注意：这里的拷贝构造不能用reserve开空间，指针_str是一个空指针，而strcpy需要传入空指针，系统会报错，所以需要通过new申请空间。
( 1 ) ( 2 ) (1)(2) (1)(2)拷贝_size和_capacity。
( 3 ) (3) (3)进行深拷贝，在堆区重新申请一块空间，字符串末尾有个'\0'所以需要多开一个空间。
( 4 ) (4) (4)将数据拷贝到新空间。
拷贝构造函数的现代写法:复用string的有参构造函数
void swap(string &s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
string(const string &s)
:_size(0),
_capacity(0),
_str(nullptr)
{
string tmp(s._str);//复用有参构造函数
swap(tmp);
}
------------------------------------------------------------我是分割线-----------------------------------------------------------
赋值重载
赋值重载的传统写法:老老实实进行开空间，深拷贝
string& operator=(string &s) {
if (this!=&s)//(1)
{
char *temp = new char[s._capacity + 1];//(2)
strcpy(temp, s._str);//(3)
delete []_str;//(4)
_size = s._size;//(5)
_capacity = s._capacity;//(6)
_str = temp;//(7)
}
return *this;
}
( 1 ) (1) (1)赋值重载的时候，可能会有这样一种情况s1 = s1,对于这种自己给自己赋值的情况，直接进行返回。
( 2 ) (2) (2) 在进行深拷贝的时候，先进行申请空间，因为申请空间可能会失败。
( 3 ) (3) (3)将数据拷贝到临时对象中。
( 4 ) (4) (4)赋值重载对象可能先前就指向了一块空间，需要将这块空间进行释放。
( 5 ) (5) (5)拷贝临时对象的_size和_capacity
( 6 ) (6) (6)将_str指针指向临时对象中申请的空间
------------------------------------------------------------我是分割线-----------------------------------------------------------
赋值重载的现代写法：复用拷贝构造函数
void swap(string &s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
string& operator=(string s)//(1)
{
if (this != &s)
{
swap(s);//(2)
}
return *this;
}
( 1 ) (1) (1)：赋值重载运算符的现代写法精髓正是在这，因为形参是实参的拷贝，所以这里会先调用拷贝构造函数完成深拷贝。
( 2 ) (2) (2)：防止s1=s1这种自己给自己赋值的情况，直接将拷贝构造得到的对象和该对象交换。
析构函数
~string()
{
delete[]_str;
_str = nullptr;
_size = _capacity = 0;
}
析构函数的实现很简单，释放空间就好。
------------------------------------------------------------我是分割线-----------------------------------------------------------
npos
string::npos是一个静态成员常量，表示size_t的最大值（Maximum value for size_t）。在使用中通常将其定义为-1。
c_str
const char* c_str() const
{
return _str;//(1)
}
( 1 ) (1) (1)返回字符指针。
迭代器
typedef char* iterator;//(1)
typedef const char* const_iterator;//(2)
iterator begin() {//(3)
return _str;
}
iterator end()//(4)
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
( 1 ) ( 2 ) (1)(2) (1)(2)迭代器又分为普通迭代器和const迭代器，这里对两个返回值进行typedef
( 3 ) (3) (3)返回字符的第一个位置
( 4 ) (4) (4)返回最后一个字符的下一个位置
------------------------------------------------------------我是分割线-----------------------------------------------------------
reserve
void reserve(int newcapacity)
{
char *tmp = new char[newcapacity + 1];//(1)
strcpy(tmp, _str);//(2)
delete []_str;//(3)
_str = tmp;//(4)
_capacity = newcapacity;//(5)
}
( 1 ) (1) (1)申请新空间。
( 2 ) (2) (2)将旧空间的数据拷贝到新空间。
( 3 ) (3) (3)将旧空间的数据释放。
( 4 ) (4) (4)让指针指向新空间。
( 5 ) (5) (5)更新_capacity。
push_back() && append()
( 1 ) (1) (1)push_back()
void push_back(char ch)
{
if (_size == _capacity)//(1)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);//(2)
}
_str[_size++] = ch;//(3)
_str[_size] = '\0';//(4)
}
( 1 ) (1) (1)说明空间用完了，需要扩容
( 1 ) (1) (1)如果原空间为0，就扩容为4，反之扩大2倍
( 1 ) (1) (1)尾插字符
( 1 ) (1) (1)别忘了'\0'
( 1 ) (1) (1)append()
void append(const char *str)
{
int len = strlen(str);//(1)
int newcapacity = len + _size;//(2)
if (newcapacity >= _capacity)//(3)
{
reserve(newcapacity + 1);
}
memcpy(_str + _size, str, len);//(4)
_size = newcapacity;//(5)
_capacity = newcapacity ;//(6)
_str[_size] = '\0';//(7)
}
( 1 ) (1) (1)计算要插入的字符串的长度。
( 2 ) (2) (2)计算当前所需要的空间容量。
( 3 ) (3) (3)当前容量如果不够，就进行扩容。
( 4 ) (4) (4)将字符串插入。
( 5 ) ( 6 ) (5)(6) (5)(6)更新_size和_capacity。
( 7 ) (7) (7)别忘了末尾还有个'\0'
------------------------------------------------------------我是分割线-----------------------------------------------------------
[]运算符
( 1 ) (1) (1)普通版本
char& operator[](int pos)
{
assert(pos < _size);
return _str[pos];
}
( 1 ) (1) (1)const版本
const char& operator[](int pos)const
{
assert(pos < _size);
return _str[pos];
}
ps::这里返回的时候别忘了+引用，[]需要支持读写操作
两个版本的实现基本相同，const版本返回值是const的，只能读但是不能写。
------------------------------------------------------------我是分割线-----------------------------------------------------------
insert
( 1 ) (1) (1)insert插入字符
void insert(int pos,char ch)
{
assert(pos <= _size);
if (_size == _capacity)
reserve(_capacity == 0 ? 4 : _capacity * 2);//(1)
int l = pos;
int r = _size;
while (l < r)//(2)
{
_str[r] = _str[r - 1];
r--;
}
_str[pos] = ch;//(3)
_str[++_size] = '\0';//(4)
}
( 1 ) (1) (1)如果容量不够，就进行扩容。
( 2 ) (2) (2)插入字符需要挪动数据，从最后一个位置开始挪动。
( 3 ) (3) (3)将要插入的位置赋值。
( 4 ) (4) (4)更新_size，并且末尾添上\0。
( 2 ) (2) (2)insert插入字符串。
string& insert(int pos, const char *str)//插入字符串
{
//判断容量够不够
int len = strlen(str);//(1)
if (len + _size > _capacity)//(2)
reserve(len + _size);
int l = pos;
int r = _size + len;
while (l+len-1 < r)//(3)
{
_str[r] = _str[r - len];
r--;
}
strncpy(_str + pos, str, len);//(4)
_size += len;//(5)
return *this;
}
( 1 ) (1) (1)计算要插入的字符串的长度。
( 2 ) (2) (2)判断是否需要扩容。
( 3 ) (3) (3)挪动数据。
( 4 ) (4) (4)将要插入的字符串插入。
( 5 ) (5) (5)更新_size。
------------------------------------------------------------我是分割线-----------------------------------------------------------
erase
string& erase(int pos = 0, int len = npos)
{
assert(pos < _size);
if (len == npos || pos+len >= _size)//(1)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);//(2)
_size -= len;
}
return *this;
}
( 1 ) (1) (1):判断是否需要删除pos位置开始的所有字符。
( 2 ) (2) (2)，将数据拷贝到被删除的位置。这里我们进行画图理解。
+=
( 1 ) (1) (1)+=字符串
string& operator+=(const char *str)
{
append(str);//(1)
return *this;
}
( 1 ) (1) (1)复用append函数。
( 1 ) (1) (1)+=字符
string& operator+=(char ch)
{
push_back(ch);//(1)
return *this;
}
( 1 ) (1) (1)复用push_back函数。
------------------------------------------------------------我是分割线-----------------------------------------------------------
find
( 1 ) (1) (1)查找字符第一次出现的位置
int find(char ch,int pos=0)
{
for (int i = pos; i < _size; i++)//(1)
{
if (_str[i] == ch)
return i;
}
return -1;
}
( 1 ) (1) (1)对字符串遍历一遍，如果找到了就返回该字符对应位置
( 2 ) (2) (2)没找到就返回-1。
( 2 ) (2) (2)查找字符串第一次出现的位置
int find(const char* s, int pos = 0)
{
const char* ptr = strstr(_str + pos, s);//(1)
//出现的位置，没找到返回空指针。
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;//(2)
}
}
( 1 ) (1) (1)使用strstr库函数进行查找字串，如果没找到，返回-1
( 2 ) (2) (2)这里涉及指针-指针，我们进行画图理解：
cout,cin
cout
ostream& operator<<(ostream&cout, string &s)
{
//cout << s.c_str() << endl;//不能这样写 因为cout判断结束是遇到'\0'，但是如果字符串中插入'\0'，
//就会导致后面的字符打印不出来
for (int i = 0; i < s._size; i++)
cout << s[i];
return cout;
}
cin
istream& operator>>(istream& in, string& s)
{
s.clear();//(1)
char ch = in.get();
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();//(2)
}
return in;
}
( 1 ) (1) (1)在输入字符串之前必须先clear一次，字符串在先前可能有字符存在
( 2 ) (2) (2)cin.get(),每次读取一个字符。
总结：
( 1 ) (1) (1)：使用strcpy函数时要注意实参是不是一个可以使用的地址，并且不能为空。
( 2 ) (2) (2)：临时对象的生命周期到函数结束，接着会被析构掉。
( 3 ) (3) (3)：指针-指针得到的是两个指针的间隔长度。
如：
( 4 ) (4) (4)：reserve每次都会多开一个空间，用来存储‘\0’
( 5 ) (5) (5)：字符串属于常量区，形参接收的时候需要加const
( 6 ) (6) (6)：重载[]运算符的时候需要+引用，因为需要[]运算符需要支持读写操作
( 7 ) (7) (7)：insert，find，erase这里的对于库函数的用法很灵活，需要多练习。
string.h 和测试代码
#pragma once
#include