string类模拟实现

A_csdn_greenhorn

已于 2024-07-25 17:48:43 修改

阅读量177

点赞数 4

文章标签： c++ c语言数据结构

于 2024-07-25 17:44:55 首次发布

本文链接：https://blog.csdn.net/A_csdn_greenhorn/article/details/140611598

版权

基础自实现结构

1.构造和拷贝构造&析构函数

2.capacity内存

2.1 size(),capacity(),empty()

2.2 resize()

2.3 reserve()

3.modify修改：

3.1 push_back(),append()

3.2 operator+=

3.3 clear(),c_str(),swap

4.iterator迭代器

5.access访问（operator[ ]）

基础自实现结构

首先我们来看一看string的基础构造（该注意点都有注释，贴心0.0）有目录方便查找

class string
  {
    friend ostream& operator<<(ostream& _cout, const bit::string& s);
    friend istream& operator>>(istream& _cin, bit::string& s);
  public:
    typedef char* iterator;
  public:
    string(const char* str = "")；
    string(const string& s)；
    string& operator=(const string &s)；
    ~string()；

    //
    // iterator
    iterator begin()；
    iterator end()；

    /
    // modify
    void push_back(char c);
    string& operator+=(char c);
    void append(const char* str);
    string& operator+=(const char* str);
    void clear();
    void swap(string& s);
    const char* c_str()const;

    /
  // capacity

    size_t size()const
    size_t capacity()const
    bool empty()const
    void resize(size_t n, char c = '\0');
    void reserve(size_t n);

    /
   // access
    char& operator[](size_t index);
    const char& operator[](size_t index)const;

    /
    //relational operators
    bool operator<(const string& s);
    bool operator<=(const string& s);
    bool operator>(const string& s);
    bool operator>=(const string& s);
    bool operator==(const string& s);
    bool operator!=(const string& s);

    // 返回c在string中第一次出现的位置
    size_t find (char c, size_t pos = 0) const;

    // 返回子串s在string中第一次出现的位置
    size_t find (const char* s, size_t pos = 0) const;

    // 在pos位置上插入字符c/字符串str，并返回该字符的位置
    string& insert(size_t pos, char c);
    string& insert(size_t pos, const char* str);

    // 删除pos位置上的元素
    string& erase(size_t pos, size_t len);

  private:
    char* _str;
    size_t _capacity;
    size_t _size;
  }
}；

1.构造和拷贝构造&析构函数

string(const char* str = "")
{
     _size = strlen(str);
    _capacity = _size;
    
    //多开一个空间为了‘\0’
    _str = new char[_capacity+1];
    strcpy(_str,str);
    
}

//拷贝构造
string(const string& s)
{
    //同样多开一字节空间
    _str = mew char[s._capacity + 1];
    strcpy(_str,s._str);
    _size = s._size;
    _capacity = s._capacity;
}

//析构
~string()
{
    delete[] _str;
    _str = nullptr;
    _size = _capcacity = 0;
}

//如果定义声明分离记得在函数前加string::

2.capacity内存

2.1 size(),capacity(),empty()

size_t size() const
{
    return _size;
}

size_t capacity() const
{
    return _capacity;
}

bool empty() const//判空
{
    return _size == 0;
}

2.2 resize()

void resize(size_t n, char c)//重新定义大小，并初始化
{
    if(n > _capacity)
    {
        //判断是否需要扩容
        reserve(n + 1);
    }

    _size = n;
    //char c 的缺省值为\0，所以进行判断
    if(c != '\0')
    {
        int i = 0;
        while(i<n)
        {
            _str[i++] = c;
        }
    }_str[n] = '\0';
}

2.3 reserve()

void reserve(size_t n)//储存空间
{
    //判断是否需要扩容
    if(n > _capacity)
    {
        char* tmp = new char[n+1];
        strcpy(tmp,_str);
        delete[] _str;
        _str = tmp;
        _capacity = n;
    }
}

3.modify修改：

3.1 push_back(),append()

void push_back(char c)//尾插
{
    if(_size == _capacity)
    {
        reverse(_capacity == 0 ? 4 : 2 * _capacity);
    }

    _str[_size] = c;
    ++_size;
    _str[_size] = '\0';
}

void append(const char* str)//尾插字符串
{
    int len = strlen(str);
    if(_size = _capacity)
        reverse(_capacity == 0 ? 4 : 2 * _capacity);

    strcpy(str + _size,_str);
    _size += len;
}

3.2 operator+=

string& operator+=(char c)//尾插
{
    //代码复用
    push_back(c);

    return *this;
}

string& operator+=(const char* str)//尾插字符串
{
    //代码复用
    append(str);
    
    return *this;
}

3.3 clear(),c_str(),swap

void clear()//清除所有元素
{
    _size = 0;
    _str[0] = '\0';
}

const char* c_str()//返回char*的指针
{
	return _str;
}

void swap(string& s)//交换
{
    //运用库里的swap进行
    std::swap(_str,s._str);
    std::swap(_capacity,s._capacity);
    std::swap(_size,s._size);
}

4.iterator迭代器

typedef char* iterator;
typedef const char* const_iterator;//不可修改性

iterator begin()
{
    return _str;
}

iterator end()
{
    return _str + _size;
}

const_iterator begin() const
{
    return _str;
}

const_iterator end() const
{
    return _str + _size;
}

5.access访问（operator[ ]）

char& operator[](size_t index)
{
    assert(index < _size)
    
    return _str[index];
}

const char& operator[](size_t index) const
{
    assert(index < _size)
    
    return _str[index];
}

6.大小比较operator

bool operator<(const string& s)
{
    return strcmp(_str,s._str) < 0;
}

bool operator<=(const string& s)
{
    return *this == s || *this < s;
}

bool operator>(const string& s)
{
    return !(*this <= s);
}
bool operator>=(const string& s)
{
    return !(*this < s);
}

bool operator==(const string& s)
{    
    return strcmp(_str,s.str) == 0;
}

bool operator!=(const string& s)
{
    return !(*this == s);
}

7. find

size_t find(char c,size_t pos) const//寻找字符开始坐标
{
    assert(pos < _size);
    
    
    while(pos< _size)
    {
        if(_str[pos++] == c)
            return pos;
    }
    return npos;
}

size_t find(const char* s, size_t pos ) const//寻找字符串开始坐标
{
    assert(pos < _size);

    const char* p = strstr(_str + pos,s);
    if(p == nullptr)
        return npos;

    return p - _str;
}

8.insert

string& insert(size_t pos, char c)//指定位置前插入字符
{
    memmove(_str + pos + 1,_str + pos,_size - pos);//同一块空间里移动用memmove
    _str[pos] = c;
    _size += 1;

    return *this;
}

string& insert(size_t pos, const char* str)//指定位置前插入字符串
{
    int len = strlen(str);
    memmove(_str + pos + len,_str + pos,_size - pos);

    for(int i = 0;i < len;++i) 
    {
        _str[i + pos] = str[i];
    }
    _size += len;

    return *this;
}

9.erase

string& erase(size_t pos,size_t len)
{
    if(len >= _size - pos)
    {
        _str[pos] = '\0';
        _size = pos;
    }
    else
    {
        //memmove(_str + pos,_str + pos + len,_size - pos - len + 1);
        for(int i = pos + len;i<_size;++i)//将之后的数据往前移
        {
            _str[i-len] = _str[i];
        }
        _size-=len;

    }
    return *this;
}

10.输入输出流重载

ostream& operator<<(ostream& out, const string& s)
{
    for(auto ch :s)
    {
        out<<ch;
    }
    return out;
}

istream& operator>>(istream& in, string& s)
{
    s.clear();//先清理要输入的字符串
    
    int N = 256;
    char buff[N];//预先设定一个数组避免频繁扩容
    char ch = in.get();
    int i = 0;

    //读到空格或者换行符就停止
    while(ch != '\n' && ch != ' ')
    {
        buff[i++] = ch;
        if(i+1==N)
        {
            //'\0'存入斜杠0并一起尾插到s后
            buff[N-1] = '\0';
            s+=buff;
            i = 0;    
        }
    }

    //还有没有剩余没读进去的
    if(i> 0)
    {
        buff[i] = '\0';
        s+=buff;
    }

     return in;
}

附加：npos

//最后别忘了声明npos，不然npos编译器无法识别
static const size_t npos;
const size_t string::npos = -1;

A_csdn_greenhorn

关注

4
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
string类模拟实现

首先我们来看一看string的基础构造（该注意点都有注释，贴心0.0）有目录方便查找。
复制链接

扫一扫