string类
二、模拟实现string类
今天我们来实现一下上篇文章中详细介绍过的接口
1、头文件string.h
cpp
#pragma once
#include <iostream>
#include <assert.h>
//const和非const迭代器
typedef char* iterator;
typedef const char* const_iterator;
namespace little_monster
{
class string
{
public:
//重载流输入流提取操作符
friend std::ostream& operator<<(std::ostream& out, const string& s)
{
for (auto ch : s)
{
out << ch;
}//范围for一个一个读取
return out;
}
friend std::istream& operator>>(std::istream& in, string& s)
{
s.clear();//清理掉原来的资源
char buff[129];
size_t i = 0;
char ch;
ch = in.get();//获取第一个字符
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 128)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}//持续获取字符,如果满128就存到s中,将i置为0继续获取,直到遇到空格或者换行停止获取
if (i != 0)
{
buff[i] = '\0';
s += buff;
}//如果此时的i不为0,那么就在此位置加一个'\0',这个位置是有效数据的后一个位置
return in;
}
//定义一个npos
const static size_t npos = -1;
//构造、拷贝、析构函数
string(const char* str);
string(const string& s);
~string();
//有关于类容量的接口
size_t size() const;//当前数据个数
size_t capacity() const;//容量
bool empty();//判空
void reserve(size_t n);//预留空间
void clear();//清理资源
void resize(size_t n,char ch);//调整大小并补齐
//访问以及遍历的接口
char& operator[](size_t pos);
const char& operator[](size_t pos) const;//重载下标访问操作符
iterator begin();
const_iterator begin() const;//迭代器begin
iterator end();
const_iterator end() const;//迭代器end
//迭代器有很多都是指针,但也有很多不是指针,string类这里的迭代器是指针
//类对象修改的接口
void push_back(char ch);//尾插一个字符
void append(const char* str);//尾插一个字符串
string& operator+=(char ch);//尾插一个字符
string& operator+=(const char* str);//尾插一个字符串
void insert(size_t pos,char ch);//pos位置插入一个字符
void insert(size_t pos, const char* str);//pos位置插入一个字符串
void erase(size_t pos,size_t len);//pos位置开始往后删除len个字符
size_t find(char ch, size_t pos);//从pos位置开始往后查找到第一个ch字符,返回它的索引
size_t find(const char* sub,size_t pos);
//pos位置开始往后查找到第一个sub指向的字符串,返回第一个字符的索引
const char* c_str() const;//类转化为c格式
string substr(size_t pos,size_t len);//从字符串pos位置开始提取len个字符
string& operator=(string tmp);//重载=操作符
//重载运算符接口
bool operator<(const string& s) const;
bool operator==(const string& s) const;
bool operator>(const string& s) const;
bool operator<=(const string& s) const;
bool operator>=(const string& s) const;
bool operator!=(const string& s) const;
//类交换函数
void swap(string& s);
private:
char* _str;//指向字符串的指针
size_t _size;//字符个数
size_t _capacity;//容量
};
}
2、常见构造
构造函数、拷贝构造、析构函数
cpp
//交换函数
void::string::swap(string& s)
{
std::swap(_str, s._str);
std::swap(_capacity, s._capacity);
std::swap(_size, s._size);
//交换值
}
//构造函数
string::string(const char* str = "")//给一个缺省值,在无参时为'\0'
:_size((size_t)strlen(str))//强制类型转换为size_t型
, _capacity(_size)
{
_str = new char[_capacity + 1];
strcpy(_str, str);
}
//拷贝构造函数
string::string(const string& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(s._str);
swap(tmp);
}
//析构函数
string::~string()
{
if(_str)
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
}
构造函数new的地方开多一个空间放'\0',因为是字符串,由于初始化时的顺序是按照声明的顺序,在初始化列表初始化指针_str会因为容量无数据导致随机值,所以我们不用初始化列表初始化指针_str,等它们通过初始化列表初始化完成后再赋初值
拷贝构造函数是拷贝构造的一种方法,创建一个拷贝对象,将该对象按照初始化列表初始化为一个空类,用s的_str指针构造一个tmp类,然后将tmp类的参数与空类的参数进行swap互换,这样此时的空类也就是拷贝对象就有了数据,并且tmp作为一个临时类,会在函数结束后自动调用析构函数析构
析构函数就很简单了,按照delete[]的方式释放空间后将指针_str置为空,然后将容量和大小置为0,但其实容量和大小没必要操作的,这个无所谓
构造函数和拷贝构造调试:
析构函数调试:先析构s2再析构s1
3、容量函数
size、empty、capacity、reserve、clear、resize
函数后面加一个const我们讲过,因为this指针是隐参数,不能在括号里边修饰,后加const修饰的是隐参数this
cpp
size_t string::size() const
{
return _size;
}
size_t string::capacity() const
{
return _capacity;
}
bool string::empty()
{
if (_size == 0)
{
return true;
}
return false;
}
void string::reserve(size_t n)
{
if (n > _capacity)//n < _capacity不用预留
{
char* tmp = new char[n + 1];//创建一个指针tmp指向new出来的n+1大小的字符串位置
strcpy(tmp, _str);//将内容拷贝过去
delete[] _str;//释放原来的空间
_str = tmp;//指针指向tmp的位置
_capacity = n;//将容量置为n
}//这里不用担心tmp没有置空的问题,因为除了作用域tmp就会销毁,其他人是访问不到的
}
void string::clear()
{
_str[0] = '\0';
_size = 0;
}//将第一个位置放\0,然后size为0就可以使后来的数据覆盖原来的数据,访问时也只有\0
void string::resize(size_t n,char ch = '\0')
{
if (n <= _size)
{
_str[n] = '\0';
}//如果n<=size,就是缩小或者不动,直接在n的位置放一个'\0'就可以了
else
{
reserve(n);//如果n>_size,不管_capacity是多大直接预留出n个位置
while (n > _size)
{
_str[_size] = ch;
++_size;
}//将ch填充进去,ch若是没有就是缺省参数'\0'
_str[_size] = '\0';//在最后的位置填一个'\0'
}
}
4、访问及遍历
operator[]、begin和end
cpp
char& string::operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& string::operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
iterator string::begin()
{
return _str;
}
const_iterator string::begin() const
{
return _str;
}
iterator string::end()
{
return _str + _size;
}
const_iterator string::end() const
{
return _str + _size;
}
范围for用的就是迭代器begin和end
这是还未进入范围for的调试过程
进入范围for,首先找到迭代器begin
然后找到迭代器end
5、类对象修改
operator+=、push_back、append、insert、erase、find、c_str、substr、operator=
cpp
void string::push_back(char ch)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}//空间问题,如果空间为0,则开辟空间
_str[_size++] = ch;
_str[_size] = '\0';//在最后的位置插入后++,在++后的位置放一个'\0'
}
void string::append(const char* str)
{
size_t len = strlen(str);//len是字符串有效字符的个数
if (_capacity < (len + _size))
{
reserve(len + _size);
}//如果容量较小,就预留出刚刚够的空间
strcpy(_str + _size, str);//将str拷贝到_str的后面,strcpy的拷贝是包括'\0'的
_size += len;
}
string& string::operator+=(char ch)
{
push_back(ch);
return *this;//复用push_back
}
string& string::operator+=(const char* str)
{
append(str);
return *this;//复用append
}
void string::insert(size_t pos, char ch)
{
assert(pos <= _size);
size_t n = _size + 1;
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
while (pos < n)
{
_str[n] = _str[n - 1];
--n;
}
_str[pos] = ch;
++_size;
}
void string::insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
if (len + _size > _capacity)
{
reserve(len + _size);
}
int n = (int)_size;
while (n >= (int)pos)
{
_str[n + len] = _str[n];
--n;
}
strncpy(_str + pos, str, len);
_size += len;
}
void string::erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
if (len == npos || len + pos > _size)
{
_str[pos] = '\0';
_size = pos;
}//如果len太大,就是从pos开始往后删干净
else
{
size_t begin = pos + len;//这里的begin其实是移动数据的begin而不是删除那段数据的begin
while (begin < _size)
{
_str[begin - len] = _str[begin];
begin++;
}//将数据移动到len个位置之前
_size -= len;
}
}
size_t string::find(char ch, size_t pos = 0)
{
for (int i = (int)pos; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}
return npos;
}
size_t string::find(const char* sub, size_t pos = 0)
{
const char* p = strstr(_str, sub);
if (p)
{
return p - _str;
}
return npos;
}
string string::substr(size_t pos, size_t len = npos)
{
string s;
size_t end = pos + len;//找到末尾的位置end
if (len == npos || pos + len >= _size)
{
len = _size - pos;
end = _size;
}//如果len太大就直接从pos位置截取到最后
s.reserve(len);//给新创建的类预留len大小的空间
for (size_t i = pos; i < end; i++)
{
s += _str[i];
}//从pos位置开始,一直到end,输入所需要插入的字符
return s;
}
string& string::operator=(string tmp)
{
swap(tmp);
return *this;
}
const char* string::c_str() const
{
return _str;
}
insert一个字符这里,插入一个字符,就是在最后位置开始往后移动一位,一直到pos位置,这样pos位置就空出来了,再把ch字符填入到pos位置,比较简单
insert字符串也是差不多的方法,插入一个字符串,用类似append那里的方法,先要知道当前的容量够不够容纳这两段字符串,然后不够就用reserve预留空间,然后再将字符从最后面挨个王后移动 len 位次,最后把字符串放里边,当然这次不要'\0',所以我们用strncpy
find一个字符这里,找到从pos位置开始的第一个字符ch很简单,直接for循环比对就可以了,比较简单
find字符串需要请出C语言中的函数strstr,它可以比对两个指针指向位置的字符串是否有重合的部分,如果有就返回重合那部分的指针,如果没有返回空,指针减去指针得到两指针之间的数据个数
operator=的实现方式是一种极简的方法,也叫现代方法,直接将两者的数据进行交换,参数类tmp在出作用域也会自动调用析构函数销毁,代码简洁,很方便
6、流插入流提取重载
代码搁上边头文件里
今日分享就到这了~