C++:String的模拟实现

简介: C++:String的模拟实现

     

    模拟实现的节奏比较快,大家可以先去看看博主的关于string的使用,然后再来看这里的模拟实现过程

C++:String类的使用-CSDN博客

     String模拟实现大致框架迭代器以及迭代器的获取(public定义,要有可读可写的也要有可读不可写的)/成员变量(private定义)  并且为了不和库的string冲突,我们需要自己搞一个命名空间

namespace cyx
{
  class string
  {
  public:
    //迭代器的实现(可读可写)
    typedef char* iterator;
    iterator begin()
    {
      return _str;
    }
    iterator end()
    {
      return _str + _size;
    }
    //迭代器的实现(可读不可写)
    typedef const char* const_iterator;
    const_iterator begin() const
    {
      return _str;
    }
    const_iterator end() const
    {
      return _str + _size;
    }
  private:
    char* _str;
    size_t _size;
    size_t _capacity;
    static const size_t npos;
    //static const size_t npos=-1  vs下int类型支持给static和const同时修饰的变量用缺省值
  };
   const size_t string::npos = -1;//静态成员遍历类外初始化
}

     nops是一个静态变量,要类内定义类外初始化,由于nops是size_t类型,赋值-1会被强转成最大的无符号整数

一、构造+析构+赋值重载(Member functions)

1.1 全缺省构造函数

//构造函数
string(const char* str = "")
  :_size(strlen(str))
  {
    _capacity = _size == 0 ? 3 : _size;
    _str = new char[_capacity + 1];//   多开一块\0的空间
    strcpy(_str, str);
  }

1、 “ ”空字符串其实里面默认就有\0,所以缺省值直接给空字符串就行

2、_capacity 一定要给初始空间,不然后面如果涉及到2倍扩容,为0的话就扩不了了

3、要多开一块空间,连这个\0

4、可以复用strcpy函数

1.2 拷贝构造函数的传统写法

    传统的思路就是拷贝,也就是我们先根据被拷贝的对象的_capacity开空间,然后再进行拷贝

string(const string& s)
    :_size(s._size)
    , _capacity(s._capacity)
  {
    _str = new char[_capacity + 1];
    strcpy(_str, s._str);
  }

1.3 拷贝构造函数的现代写法和swap函数

      现代的思路就是,尝试去复用,比如说我们可不可以直接去利用前面的构造函数去构造一个新对象,然后再窃取新对象的成果(利用swap)

//交换字符串
void swap(string& s)
{
  std::swap(_str, s._str);//浅拷贝,没有开空间,只是改变指针指向
  std::swap(_size, s._size);
  std::swap(_capacity, s._capacity);
}
string(const string& s)
      :_str(nullptr)
    {
      string temp(s._str);
      swap(temp);
    }

传统写法和现代写法参数一样,不能重载,只能保留一个

1. 4 迭代器区间构造

//迭代器区间构造
    template <class InputIterator>
    string(InputIterator first, InputIterator last)
      :_str(new char[last-first+1])
      ,_size(0)
      ,_capacity(last-first)
    {
      while (first != last)
      {
        push_back (*first);
        ++first;
      }
    }

      这里定义的模版InputIterator的意思其实是这边我们可以传不同类型对象的迭代器,我们并不知道这个迭代器里面有多少元素,所以得用指针-指针,即last-first来确定我们的容量,然后再开空间,一个个进行尾插。

1.5 赋值重载的传统写法

      传统的思路就是,先开一块新空间拷贝旧数据,然后再释放掉原空间,这里尽量是先开空间再释放,避免我们开空间失败导致原始数据的丢失。  

//赋值重载(传统写法)
    string& operator=(const string& s)
    {
      if (this != &s)//避免自赋值
      {
        //先开新空间再毁旧空间,避免新空间开失败导致数据丢失
        char* temp = new char[s._capacity + 1];
        strcpy(temp, s._str);
        delete[]_str;
        _str = temp;
        _size = s._size;
        _capacity = s._capacity;
      }
      return *this;
    }

注意:要注意自赋值情况!!否则刚拷贝完自己就被释放了

1.6 赋值重载的现代写法

     现代的思路就是,既然被赋值这个空间不想要,那就和形参直接交换吧!!但是要注意的是,这里就不能像传统的一样用const引用了,否则不想要的空间就给到我们的赋值对象了,这边就得用传值传参,这样被交换的就只是一个临时拷贝,不想要的空间随着栈帧的结束被销毁。

//赋值重载(现代写法)
string& operator=(string s)//必须用值传递,否则会导致原数据的丢失
{
  swap(s);
  return *this;
}

 传统写法和现代写法参数不一样,一个是const引用,一个传值传参,所以可以同时存在。

1.7 析构函数

~string()
  {
    delete[]_str;
    _str = nullptr;
    _size = _capacity = 0;
  }

二、容量相关的接口(Capacity)

2.1 size、capacity

//获取当前size
  size_t size() const
  {
    return _size;
  }
  //获取当前capacity
  size_t capacity() const
  {
    return _capacity;
  }

2.2 reserve

如果n比_capacity大,思路就是先开新空间进行拷贝,然后再释放旧空间

//改变capacity
  void reserve(size_t n)
  {
    if (n > _capacity)
    {
      char* tmp = new char[n + 1];
      strcpy(tmp, _str);
      delete[] _str;
      _str = tmp;
      _capacity = n;
    }
  }

2.3 resize

如果n比_size大,我们根据n去扩容,然后因为string的底层是字符数组,所以memset就很适合,他就是可以去一个字节一个字节设置成我们想要的。缺省值给‘\0’

//改变size
void resize(size_t n, char ch = '\0')
{
  if (n > _size)
  {
    reserve(n);
    memset(_str + _size, ch, n - _size);
  }
  _size = n;
  _str[_size] = '\0';
}

2.4 clear和empty

//清理字符串
void clear()
{
  _str[0] = '\0';
  _size = 0;
}
//判断字符串是否为空
bool empty()
{
  return _capacity == 0;
}

2.5 shrink_to_fit(用得少)

缩容到size位置,平时用的很少,我们要尽量减少扩容,思路也是一样的,开辟新空间去拷贝,再释放旧空间

void shrink_to_fit()
  {
    char* temp = new char[_size + 1];
    strcpy(temp, _str);
    delete[] _str;
    _str = temp;
    _capacity = _size;
  }

三、[ ]和比较运算符重载

//[]重载(可读可写)
char& operator[](size_t pos)
{
  assert(pos < _size);//确保地址有效
  return _str[pos];
}
//[]重载(可读不可写)
const char& operator[](size_t pos) const
{
  assert(pos < _size);//确保地址有效
  return _str[pos];
}
//比较类型重载
//>
bool operator>(const string& s) const
{
  return strcmp(_str, s._str) > 0;
}
//==
bool operator==(const string& s) const
{
  return strcmp(_str, s._str) == 0;
}
//>=
bool operator>=(const string& s) const
{
  return *this > s || *this == s;
}
//<
bool operator<(const string& s) const
{
  return !(*this >= s);
}
//<=
bool operator<=(const string& s) const
{
  return !(*this > s);
}
//!=
bool operator!=(const string& s) const
{
  return !(*this == s);
}

有了[ ]、迭代器,我们可以展示3种遍历方法:下标访问、迭代器区间访问、范围for访问

void Print(const string& s)
  {
    //下标遍历
    for (size_t i = 0; i < s.size(); ++i)
      cout << s[i] << " ";
    cout << endl;
    //迭代器遍历访问
    string::const_iterator it = s.begin();
    while (it != s.end())
    {
      cout << *it << " ";
      ++it;
    }
    cout << endl;
    //范围for
    for (auto &e : s)
      cout << e << " ";
    cout << endl;
  }

四、增删接口(Modifiers)

      字符串的增删接口一般要设置两个版本,一个是操作字符,一个是操作字符串,我们先把最难的insert和erase搞了,其他的就可以复用了

4.1 insert

//指定位置插入一个字符
  string& insert(size_t pos, char ch)
  {
    assert(pos <= _size);
    //判断是否需要扩容
    if (_size + 1 > _capacity)
      reserve(2 * _capacity);
    //pos后的数据要往后挪,所以要从后往前移
    size_t end = _size + 1;
    while (end > pos)
    {
      _str[end] = _str[end - 1];
      --end;
    }
    _str[pos] = ch;
    ++_size;
    return *this;
  }
  //指定位置插入一个字符串
  string& insert(size_t pos, const char* str)
  {
    assert(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);
    _size += len;
    return *this;
  }

4.2 erase

//删除指定位置之后的字符
string& erase(const size_t pos, size_t len = npos)
{
  assert(pos <= _size);
  //有两种情况,一种是全删完,一种是删中间的一部分
  //全删完
  if (len == npos || pos + len > _size)//len == npos必须写,因为nops是无符号最大值,+的话会溢出
  {
    _str[pos] = '\0';
    _size = pos;
  }
  //删一部分
  else
  {
    strcpy(_str + pos, _str + pos + len);
    _size -= len;
  }
  return *this;
}

len == npos这个判断条件必须写,因为nops已经是无符号最大值了,再+会溢出

4.3 push_back

//尾插一个字符
  void push_back(char ch)
  {
    insert(_size, ch);
  }

4.4 append

//尾插一个字符串
string& append(const char* str)
{
  return insert(_size, str);
}

4.5 +=重载(用的多)

//+=重载 字符
  string& operator+=(char ch)
  {
    push_back(ch);
    return *this;
  }
  //+=重载 字符串
  string& operator+=(const char* str)
  {
    append(str);
    return *this;
  }

五、字符串操作(String operations

5.1 获取c类型字符串

//获取c类型字符串
const char* c_str() const
{
  return _str;
}

5.2 寻找指定字符串并返回下标

//寻找指定字符串并返回下标
  size_t find(const char* str, size_t pos = 0)const
  {
    assert(pos < _size);
    char* p = strstr(_str + pos, str);
    if (p == nullptr)
      return npos;
    return p - _str;
  }

六、重载流插入和流提取

我们不能写在类内,否则会*this会占用第一个操作数,不符合我们的使用习惯。

6.1 流提取

//重载<<
std::ostream& operator<< (std::ostream& out, const string& s)
{
  //可以用范围for,也可以用迭代器   范围for是用宏写的,本质上也是迭代器!
  for (auto ch : s)
    out << ch;
  return out;
}

6.2 流插入

首先我们要知道两点,1.>>只会读取到空格或者换行结束 2.读取前会清理掉原空间的数据

//重载>>
  std::istream& operator>> (std::istream& in, string& s)
  {
    //读取前要先清理掉原来存在的字符
    s.clear();
    //用get获取字符
    char ch = in.get();
    //先用一个数组存起来,再一起加
    char buff[128];
    size_t i = 0;
    while (ch != ' ' && ch != '\n')
    {
      //原始方法,一个字符一个字符加太麻烦,先用一个数组存起来,再一起加
      //s += ch;
      buff[i++] = ch;
      if (i == 127)
      {
        buff[127] = '\0';
        s += buff;
        i = 0;//重置i
      }
      ch = in.get();
    }
    //循环结束后可能还要一些字母没有存进去
    if (i != 0)
    {
      buff[i] = '\0';
      s += buff;
    }
    return in;
  }

我们用一个buff数组来暂时存储需要插入的字符,等存完了再+=,这样可以提高效率,以空间换时间

七、string模拟实现全部代码

namespace cyx
{
  using std::endl;
  using std::cout;
  class string
  {
  public:
    //迭代器的实现(可读可写)
    typedef char* iterator;
    iterator begin()
    {
      return _str;
    }
    iterator end()
    {
      return _str + _size;
    }
    //迭代器的实现(可读不可写)
    typedef const char* const_iterator;
    const_iterator begin() const
    {
      return _str;
    }
    const_iterator end() const
    {
      return _str + _size;
    }
    //交换字符串
    void swap(string& s)
    {
      std::swap(_str, s._str);//浅拷贝,没有开空间,只是改变指针指向
      std::swap(_size, s._size);
      std::swap(_capacity, s._capacity);
    }
    //构造函数
    string(const char* str = "")
      :_size(strlen(str))
      {
        _capacity = _size == 0 ? 3 : _size;
        _str = new char[_capacity + 1];//   多开一块\0的空间
        strcpy(_str, str);
      }
    //拷贝构造函数(传统写法)
    /*string(const string& s)
      :_size(s._size)
      , _capacity(s._capacity)
    {
      _str = new char[_capacity + 1];
      strcpy(_str, s._str);
    }*/
        //拷贝函数的现代写法
    string(const string& s)
      :_str(nullptr)
    {
      string temp(s._str);
      swap(temp);
    }
    //迭代器区间构造
    template <class InputIterator>
    string(InputIterator first, InputIterator last)
      :_str(new char[last-first+1])
      ,_size(0)
      ,_capacity(last-first)
    {
      while (first != last)
      {
        push_back (*first);
        ++first;
      }
    }
    //赋值重载(传统写法)
    string& operator=(const string& s)
    {
      if (this != &s)//避免自赋值
      {
        //先开新空间再毁旧空间,避免新空间开失败导致数据丢失
        char* temp = new char[s._capacity + 1];
        strcpy(temp, s._str);
        delete[]_str;
        _str = temp;
        _size = s._size;
        _capacity = s._capacity;
      }
      return *this;
    }
    //赋值重载(现代写法)
    string& operator=(string s)//必须用值传递,否则会导致原数据的丢失
    {
      swap(s);
      return *this;
    }
    //析构函数
    ~string()
    {
      delete[]_str;
      _str = nullptr;
      _size = _capacity = 0;
    }
    //获取c类型字符串
    const char* c_str() const
    {
      return _str;
    }
    //获取当前size
    size_t size() const
    {
      return _size;
    }
    //获取当前capacity
    size_t capacity() const
    {
      return _capacity;
    }
    //[]重载(可读可写)
    char& operator[](size_t pos)
    {
      assert(pos < _size);//确保地址有效
      return _str[pos];
    }
    //[]重载(可读不可写)
    const char& operator[](size_t pos) const
    {
      assert(pos < _size);//确保地址有效
      return _str[pos];
    }
    //比较类型重载
    //>
    bool operator>(const string& s) const
    {
      return strcmp(_str, s._str) > 0;
    }
    //==
    bool operator==(const string& s) const
    {
      return strcmp(_str, s._str) == 0;
    }
    //>=
    bool operator>=(const string& s) const
    {
      return *this > s || *this == s;
    }
    //<
    bool operator<(const string& s) const
    {
      return !(*this >= s);
    }
    //<=
    bool operator<=(const string& s) const
    {
      return !(*this > s);
    }
    //!=
    bool operator!=(const string& s) const
    {
      return !(*this == s);
    }
    //改变size
    void resize(size_t n, char ch = '\0')
    {
      if (n > _size)
      {
        reserve(n);
        memset(_str + _size, ch, n - _size);
      }
      _size = n;
      _str[_size] = '\0';
    }
    //改变capacity
    void reserve(size_t n)
    {
      if (n > _capacity)
      {
        char* tmp = new char[n + 1];
        strcpy(tmp, _str);
        delete[] _str;
        _str = tmp;
        _capacity = n;
      }
    }
    //尾插一个字符
    void push_back(char ch)
    {
      insert(_size, ch);
    }
    //尾插一个字符串
    string& append(const char* str)
      {
      return insert(_size, str);
    }
    //+=重载 字符
    string& operator+=(char ch)
    {
      push_back(ch);
      return *this;
    }
    //+=重载 字符串
    string& operator+=(const char* str)
    {
      append(str);
      return *this;
    }
    //指定位置插入一个字符
    string& insert(size_t pos, char ch)
    {
      assert(pos <= _size);
      //判断是否需要扩容
      if (_size + 1 > _capacity)
        reserve(2 * _capacity);
      //pos后的数据要往后挪,所以要从后往前移
      size_t end = _size + 1;
      while (end > pos)
      {
        _str[end] = _str[end - 1];
        --end;
      }
      _str[pos] = ch;
      ++_size;
      return *this;
    }
    //指定位置插入一个字符串
    string& insert(size_t pos, const char* str)
    {
      assert(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);
      _size += len;
      return *this;
    }
    //删除指定位置之后的字符
    string& erase(const size_t pos, size_t len = npos)
    {
      assert(pos <= _size);
      //有两种情况,一种是全删完,一种是删中间的一部分
      //全删完
      if (len == npos || pos + len > _size)//len == npos必须写,因为nops是无符号最大值,+的话会溢出
      {
        _str[pos] = '\0';
        _size = pos;
      }
      //删一部分
      else
      {
        strcpy(_str + pos, _str + pos + len);
        _size -= len;
      }
      return *this;
    }
    //寻找指定字符并返回下标
    size_t find(char ch, size_t pos = 0)const
    {
      assert(pos < _size);
      for (size_t i = pos; i < _size; ++i)
        if (_str[i] == ch)
          return i;
      return npos;
    }
    //寻找指定字符串并返回下标
    size_t find(const char* str, size_t pos = 0)const
    {
      assert(pos < _size);
      char* p = strstr(_str + pos, str);
      if (p == nullptr)
        return npos;
      return p - _str;
    }
    //清理字符串
    void clear()
    {
      _str[0] = '\0';
      _size = 0;
    }
    //缩容到他的size
    void shrink_to_fit()
    {
      char* temp = new char[_size + 1];
      strcpy(temp, _str);
      delete[] _str;
      _str = temp;
      _capacity = _size;
    }
    //判断字符串是否为空
    bool empty()
    {
      return _capacity == 0;
    }
  private:
    char* _str;
    size_t _size;
    size_t _capacity;
    static const size_t npos;
    //static const size_t npos=-1       vs下int类型支持给static和const同时修饰的变量用缺省值
  };
   const size_t string::npos = -1;//静态成员遍历类外初始化
  //重载<<
  std::ostream& operator<< (std::ostream& out, const string& s)
  {
    //可以用范围for,也可以用迭代器   范围for是用宏写的,本质上也是迭代器!
    for (auto ch : s)
      out << ch;
    return out;
  }
  //重载>>
  std::istream& operator>> (std::istream& in, string& s)
  {
    //读取前要先清理掉原来存在的字符
    s.clear();
    //用get获取字符
    char ch = in.get();
    //先用一个数组存起来,再一起加
    char buff[128];
    size_t i = 0;
    while (ch != ' ' && ch != '\n')
    {
      //原始方法,一个字符一个字符加太麻烦,先用一个数组存起来,再一起加
      //s += ch;
      buff[i++] = ch;
      if (i == 127)
      {
        buff[127] = '\0';
        s += buff;
        i = 0;//重置i
      }
      ch = in.get();
    }
    //循环结束后可能还要一些字母没有存进去
    if (i != 0)
    {
      buff[i] = '\0';
      s += buff;
    }
    return in;
  }
  //遍历方法的展示
  void Print(const string& s)
  {
    //下标遍历
    for (size_t i = 0; i < s.size(); ++i)
      cout << s[i] << " ";
    cout << endl;
    //迭代器遍历访问
    string::const_iterator it = s.begin();
    while (it != s.end())
    {
      cout << *it << " ";
      ++it;
    }
    cout << endl;
    //范围for
    for (auto &e : s)
      cout << e << " ";
    cout << endl;
  }

有新的后面再补充哦!

相关文章
|
6天前
|
算法 C++ 容器
【C++】string模拟实现
【C++】string模拟实现
13 1
|
6天前
|
C语言 C++
【C++】string类(常用接口)
【C++】string类(常用接口)
21 1
|
4天前
|
存储 算法 搜索推荐
C++|STL简介-string-vector基础运用
C++|STL简介-string-vector基础运用
|
6天前
|
C语言 C++ 容器
C++ string类
C++ string类
9 0
|
6天前
|
编译器 C++
【C++】继续学习 string类 吧
首先不得不说的是由于历史原因,string的接口多达130多个,简直冗杂… 所以学习过程中,我们只需要选取常用的,好用的来进行使用即可(有种垃圾堆里翻美食的感觉)
10 1
|
6天前
|
算法 安全 程序员
【C++】STL学习之旅——初识STL,认识string类
现在我正式开始学习STL,这让我期待好久了,一想到不用手撕链表,手搓堆栈,心里非常爽
17 0
|
6天前
|
存储 安全 测试技术
【C++】string学习 — 手搓string类项目
C++ 的 string 类是 C++ 标准库中提供的一个用于处理字符串的类。它在 C++ 的历史中扮演了重要的角色,为字符串处理提供了更加方便、高效的方法。
18 0
【C++】string学习 — 手搓string类项目
|
6天前
|
存储 C++ 容器
【C++从练气到飞升】09---string语法指南(二)
【C++从练气到飞升】09---string语法指南(二)
|
6天前
|
存储 Linux C语言
【C++从练气到飞升】09---string语法指南(一)
【C++从练气到飞升】09---string语法指南(一)
|
6天前
|
C++
【C++】string类(介绍、常用接口)
【C++】string类(介绍、常用接口)
18 2