【C++】string类（下）

个人主页~
string类（上）

string类

二、模拟实现string类

今天我们来实现一下上篇文章中详细介绍过的接口

1、头文件string.h

#pragmaonce#include<iostream>#include<assert.h>//const和非const迭代器typedefchar* iterator;typedefconstchar* const_iterator;namespace little_monster
{classstring{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;}//定义一个nposconststatic size_t npos =-1;//构造、拷贝、析构函数string(constchar* str);string(const string& s);~string();//有关于类容量的接口
        size_t size()const;//当前数据个数
        size_t capacity()const;//容量boolempty();//判空voidreserve(size_t n);//预留空间voidclear();//清理资源voidresize(size_t n,char ch);//调整大小并补齐//访问以及遍历的接口char&operator[](size_t pos);constchar&operator[](size_t pos)const;//重载下标访问操作符
        iterator begin();
        const_iterator begin()const;//迭代器begin
        iterator end();
        const_iterator end()const;//迭代器end//迭代器有很多都是指针，但也有很多不是指针，string类这里的迭代器是指针//类对象修改的接口voidpush_back(char ch);//尾插一个字符voidappend(constchar* str);//尾插一个字符串
        string&operator+=(char ch);//尾插一个字符
        string&operator+=(constchar* str);//尾插一个字符串voidinsert(size_t pos,char ch);//pos位置插入一个字符voidinsert(size_t pos,constchar* str);//pos位置插入一个字符串voiderase(size_t pos,size_t len);//pos位置开始往后删除len个字符
        size_t find(char ch, size_t pos);//从pos位置开始往后查找到第一个ch字符，返回它的索引
        size_t find(constchar* sub,size_t pos);//pos位置开始往后查找到第一个sub指向的字符串，返回第一个字符的索引constchar*c_str()const;//类转化为c格式
        string substr(size_t pos,size_t len);//从字符串pos位置开始提取len个字符
        string&operator=(string tmp);//重载=操作符//重载运算符接口booloperator<(const string& s)const;booloperator==(const string& s)const;booloperator>(const string& s)const;booloperator<=(const string& s)const;booloperator>=(const string& s)const;booloperator!=(const string& s)const;//类交换函数voidswap(string& s);private:char* _str;//指向字符串的指针
        size_t _size;//字符个数
        size_t _capacity;//容量};}

2、常见构造

构造函数、拷贝构造、析构函数

//交换函数void::string::swap(string& s){
    std::swap(_str, s._str);
    std::swap(_capacity, s._capacity);
    std::swap(_size, s._size);//交换值}//构造函数
string::string(constchar* str ="")//给一个缺省值，在无参时为'\0':_size((size_t)strlen(str))//强制类型转换为size_t型,_capacity(_size){
    _str =newchar[_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

size_t string::size()const{return _size;}

size_t string::capacity()const{return _capacity;}bool string::empty(){if(_size ==0){returntrue;}returnfalse;}void string::reserve(size_t n){if(n > _capacity)//n < _capacity不用预留{char* tmp =newchar[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就可以使后来的数据覆盖原来的数据，访问时也只有\0void 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

char& string::operator[](size_t pos){assert(pos < _size);return _str[pos];}constchar& 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=

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(constchar* 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+=(constchar* 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,constchar* 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而不是删除那段数据的beginwhile(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(constchar* sub, size_t pos =0){constchar* 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;//找到末尾的位置endif(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;}constchar* 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、流插入流提取重载

代码搁上边头文件里

今日分享就到这了~