string的模拟实现-天翼云

@TOC string底层是一个字符数组为了跟库里的string区别，所以定义了一个命名空间将string类包含

1. string的模拟实现

1.构造函数

#pragma once
#include<iostream>
using namespace std;
namespace yzq
{
    class string
    {
    public:
    string()//无参构造函数
        //初始化列表
        :_str(nullptr)
        ,_size(0)
        ,_capaicty(0)
    {

    }
    string(const char*str)//带参构造函数
        :_str(str),
         _size(strlen(str)),
        _capaicty(strlen(str))
    {

    }
    private:
        char* _str;
        size_t _size;
        size_t _capaicty;

    };
    void test()
    {
        string s1;
        string s2("hello world");
    }
}

string的模拟实现

若写成两个构造函数，一个设置成无参，一个设置成带参，若调用如上的带参构造函数就会报错，将str传给_str，属于权限放大，为了解决这个问题，可以将_str改为const char*类型，但是无法修改_str所指向的内容，调用operator[]函数就会报错

使用new开辟空间

string的模拟实现

因为后续要考虑扩容等问题，所以最好是new一块空间而无参的构造函数为了保持析构都用delete[]，所以使用new[]

优化成全缺省的构造函数

string的模拟实现

不可以将缺省值设置成nullptr，strlen(str)对于str指针解引用，遇到'\0'终止，解引用NULL会报错
将缺省值设置成一个空字符串，结尾默认为'\0'

string(const char* str="")//构造函数

      :_size(strlen(str))
    {
      if (_size == 0)
      {
        _capaicty = 3;
      }
      else
      {
        _capaicty = _size;
      }
      _str = new char[_capaicty + 1];
      strcpy(_str, str);

    }

2. C_str

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

返回const char*类型的指针相当于返回字符串

3. operator[]

char& operator[](size_t pos)//operator[]
     {
         return _str[pos];
     }
      char& operator[](size_t pos)const //函数重载
      {
          return _str[pos];
      }

由于可能存在 string与const string类型所以设置成两个函数构成函数重载

string的模拟实现

调用函数print 需要使用operator[ ]const而正常遍历 s[i] ，需要调用 operator [ ]

4.拷贝构造

浅拷贝

拷贝构造函数如果不写编译器会自动生成，对于内置类型完成值拷贝或者浅拷贝

string的模拟实现

若使用编译器自动生成的拷贝构造就会报错

string的模拟实现

s2与s3发生浅拷贝，导致两个指针都指向同一块空间，一个修改会影响另一个，会析构两次空间

深拷贝

string的模拟实现

创建一块同样大小的空间，并将原来的数据拷贝下来，这样就是s2与s3指向各自的空间，一个被修改也不会影响另一个

string(const string& s)//拷贝构造
            :_size(s._size),
            _capaicty(s._capaicty)
        {
            _str = new char[_capaicty + 1];//开辟一块空间
            strcpy(_str, s._str);//将s2拷贝给s1
        }

5. 赋值

赋值运算符也是默认成员函数，如果不写会进行浅拷贝/值拷贝

三种情况

正常赋值会存在以下是那种情况
若为第一种两者空间大小相同，则进行值拷贝
若为第二种s1的空间远大于s2的空间，进行值拷贝会浪费空间，所以系统会按照第三种做法执行
若为第三种，s1的空间太小，需要new开辟一块空间，将旧空间销毁，将s2拷贝到新开辟的空间
编译器不会这样处理，直接将旧空间释放，再去开新空间，并将值拷贝过来

string& operator=(const string& s)//赋值 s1=s3
        {
            if (this != &s)//排除赋值本身的情况
            {
                char* tmp = new char[s._capaicty + 1];
                strcpy(tmp, s._str);
                delete[] _str;
                _str = tmp;
                _size = s._size;
                _capaicty = s._capaicty;
            }
                return *this;
        }

若释放旧空间，如果new失败了，则破坏原有空间

6. 迭代器

typedef char* iterator;
        typedef const char* const_iterator;
        iterator begin()
        {
            return _str;
        }
        iterator end()
        {
            return _str + _size;
        }
        
        iterator begin()const //指针指向的内容不能被修改
        {
            return _str;
        }
        iterator end()const
        {
            return _str + _size;
        }

string的模拟实现

使用typedef 分别将用iterator代替 char*const_iterator代替 const char*

7.比较(ASCII值)大小

bool operator==(const string& s)const //s1==s2
      {
          return strcmp(_str, s._str)==0;
      }
      bool operator<(const string& s)const //s1<s2
      {
          return strcmp(_str, s._str) < 0;
      }
      bool operator<=(const string& s)const //s1<=s2
      {
          return *this < s || *this == s;
      }
      bool operator>(const string& s)const //s1>s2
      {
          return !(*this <= s);
      }
      bool operator>=(const string& s)const //s1>=s2
      {
          //复用
          return *this > s || *this == s;
      }
      bool operator!=(const string& s)const //s1!=s2
      {
          return !(*this == s);
      }

通过C语言函数strcmp，比较字符串从头开始字符的ASCII值，再通过复用来实现剩下的
如果不小心在复用时将const修饰的传给非const成员就会报错，所以括号外面加上const，修饰this指针

8. reserve(扩容)

void reserve(size_t n)//开辟空间
    {
      if (n > _capacity)//防止缩容的问题
      {
        char* tmp = new char[n + 1];//多开一个'\0'
        strcpy(tmp, _str);
        delete[]_str;
        _str = tmp;
        _capacity = n;//计算有效
      }
    }

reserve主要实现类似扩容的操作

string的模拟实现

为了防止new失败，所以使用临时变量tmp指向new出来的空间，若new成功，释放旧空间，并将_str指向新空间

9. push_back(尾插字符)

void push_back(char ch)//尾插字符
      {
          if (_size + 1 > _capaicty)
          {
              reserve(2 * _capaicty);//开辟2倍空间
          }
          _str[_size] = ch;
          _size++;
      }

通过reserve进行类似扩容的操作，再将ch赋值给当前最后一个字符

10. append(尾插字符串)

void append(const char* str)//尾插 字符串
      { 
          int len = strlen(str);
          if (_size + len > _capaicty)
          {
              reserve(_size + len);
          }
          strcpy(_str + _size, str);//在原来的字符串后拷贝字符串
          _size += len;
      }

通过reserve类似扩容的操作，扩大了字符串长度的空间，并且在原字符串'\0'的位置开始拷贝str字符串

11. +=(字符/字符串)

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

使用使用上面实现好的push_back和append

12. insert

在pos位置前插入字符ch

void insert(size_t pos, char ch)//在pos位置前插入字符ch
      {
          if (_size + 1 > _capacity)//扩容
          {
              reserve(2 * _capacity);
          }
          size_t end = _size + 1;//'\0'的下一个位置
          while (end > pos)
          {
              //把前面传给后面
              _str[end] = _str[end - 1];
              end--;
           }
          _str[pos] = ch;
          _size++;
      }

由于pos与end都是size_t类型，没有负数所以当while循环条件设置为end>=pos并且pos=0时，end--，end变为负数，计算的是其补码，所以一直成立，无法结束循环

string的模拟实现

把前面的传给后面的，当end下标为1时，end-1的下标为0，循环结束

在pos位置前插入字符串str

void insert(size_t pos, const char* str)//在pos位置前插入字符串str
      {
          int 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);//拷贝len个字节，不包含'\0'
          _size += len;
      }

string的模拟实现

临界条件为保证最后一次下标end减去len,在下标为0的位置上，所以取边界为pos+len end>pos+len-1 ，最后一次取值即为pos+len 使用strncpy函数，不包含'\0'，将str拷贝给_str+pos下标位置开始的len个字符

13 .resize

void resize(size_t n,char ch)//开辟空间+初始化
      {
          if (n <= _size)//删除数据保留前n个
          {
              _size = n;
              _str[n] = '\0';
          }
          else //n>_size
          {
              if (n >_capacity)//扩容
              {
                  reserve(n);
              }
              int i = _size;
              while (i < n)//剩余空间初始化为ch
              {
                  _str[i] = ch;
                  i++;
              }
              _size = n;
              _str[_size] = '\0';
          }
      }

string的模拟实现

分为三种情况n<size 删除数据size<n<capacity 剩余空间初始化n>capacity 扩容+初始化

14. erase

pos位置开始删除len个数据

static const size_t npos = -1;
      string& erase(size_t pos = 0, size_t len = npos)//从pos位置开始删除len个数据
      {
          if (len==npos||pos+len>=_size)
          {
              //全部删除
              _str[pos] = '\0';
              _size = pos;
          }
          else
          {
              strcpy(_str + pos, _str +pos+len);//包含'\0'
              _size -= len;
          }
          return *this;
      }

pos处于下标为2的位置上，共有两种情况

string的模拟实现

当pos+len<总长度时，使用strcpy函数拷贝，从而覆盖删除要被删除的字符

string的模拟实现

当pos+len大于总长度或者len等于npos时，剩余长度全部删除

15. 流插入<<

流插入重载必须实现为友元函数么？
不对，使用友元函数是为了在类外面调用类的私有的成员变量，若不需要调用则不用友元函数

ostream& operator<<(ostream& out, const string&s)
    {
        int i = 0;
        
        for (i = 0; i < s.size(); i++)
        {
            out << s[i] << " ";
        }
        return out;
    }

实现流插入不可以调用C_str()，因为C_str()返回的是一个字符串，遇见'\0'就会结束，但若打印结果有好几个'\0'，则遇见第一个就会结束，不符合预期

16. 流提取 >>

输入多个值，C++规定空格/换行是值与值之间的区分

istream& operator>>(istream& in,  string& s)//>>
    {//错误写法
        char ch;
        in >> ch;
        while (ch != ' ' && ch != '\n')
        {
            s += ch;
            in >> ch;
        }
        return in;
    }

上述代码在循环中无法找到空格/换行，导致循环无法停止
输入的数据在缓冲区中，使用循环在缓冲区中提取数据，但是空格/换行不在缓冲区中,因为认为它是多个值之间的间隔
使用get就不会认为空格/换行是多个值之间的间隔，若遇见空格/换行就会存储缓冲区中等待提取

istream& operator>>(istream& in,  string& s)//>>
    {
        s.clear();
        char ch = in.get();
        char buf[128];
        size_t index = 0;
        while (ch != ' ' && ch != '\n')
        {
            buf[index++] = ch;
            if (index == 127)//为了防止频繁扩容
            {
                buf[127] = '\0';
                s += buf;
                index = 0;
            }
            ch = in.get();
        }
        if (index != 0)
        {
            buf[index] = '\0';
            s += buf;
        }
        return in;
    }

当需要输入的string对象中有值存在时，需要先使用clear清空，再输入新的数据
为了避免频繁扩容，使用一个128的字符数组接收，若输入的数据比128小，跳出循环将数组中的数据传给string类s，若输入的数据比128大，则将字符数组整体传给string类s，再正常扩容

2. 整体代码

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
namespace yzq
{
  class string
  {
  public:
  //string()//无参构造函数
  //  //初始化列表
  //  :_str(new char[1])//为了析构都是用delete[]，匹配使用
  //  ,_size(0)
  //  ,_capaicty(0)
  //{
  //  _str[0] = '\0';
  //}
  //string(const char*str)//带参构造函数
  //  
  //   :_size(strlen(str))
  //{
  //     _capaicty = _size;
  //   _str = new char[_capaicty+1];//因为有'\0'的存在所以多开一个空间
  //   strcpy(_str, str);//拷贝
  //}
    typedef char* iterator;
    typedef const char* const_iterator;
    iterator begin()
    {
      return _str;
    }
    iterator end()
    {
      return _str + _size;
    }
    
    iterator begin()const 
    {
      return _str;
    }
    iterator end()const
    {
      return _str + _size;
    }

    string(const char* str="")//构造函数

      :_size(strlen(str))
    {
      if (_size == 0)
      {
        _capacity = 3;
      }
      else
      {
        _capacity = _size;
      }
      _str = new char[_capacity + 1];
      strcpy(_str, str);

    }

    string(const string& s)//拷贝构造
      :_size(s._size),
      _capacity(s._capacity)
    {
      //深拷贝
      _str = new char[_capacity + 1];//开辟一块空间
      strcpy(_str, s._str);//将s2的值传给s1
    }

    string& operator=(const string& s)//赋值 s1=s3
    {
      if (this != &s)//排除赋值本身的情况
      {
        char* tmp = new char[s._capacity + 1];
        strcpy(tmp, s._str);
        delete[] _str;
        _str = tmp;
        _size = s._size;
        _capacity = s._capacity;
      }
        return *this;
    }

    size_t size()const
    {
      return _size;
    }

   const char* C_str()//返回const char*类型的指针 
  {
     return  _str;
  }
    
    char& operator[](size_t pos)//operator[]
   {
     return _str[pos];
   }
    char& operator[](size_t pos)const //函数重载
    {
      return _str[pos];
    }

    bool operator==(const string& s)const //s1==s2
    {
      return strcmp(_str, s._str)==0;
    }
    bool operator<(const string& s)const //s1<s2
    {
      return strcmp(_str, s._str) < 0;
    }
    bool operator<=(const string& s)const //s1<=s2
    {
      return *this < s || *this == s;
    }
    bool operator>(const string& s)const //s1>s2
    {
      return !(*this <= s);
    }
    bool operator>=(const string& s)const //s1>=s2
    {
      //复用
      return *this > s || *this == s;
    }
    bool operator!=(const string& s)const //s1!=s2
    {
      return !(*this == s);
    }

    void reserve(size_t n)//开辟空间
    {
      if (n > _capacity)//防止缩容的问题
      {
        char* tmp = new char[n + 1];//多开一个'\0'
        strcpy(tmp, _str);
        delete[]_str;
        _str = tmp;
        _capacity = n;//计算有效
      }
    }

    void resize(size_t n,char ch)//开辟空间+初始化
    {
      if (n <= _size)//删除数据保留前n个
      {
        _size = n;
        _str[n] = '\0';
      }
      else //n>_size
      {
        if (n >_capacity)//扩容
        {
          reserve(n);
        }
        int i = _size;
        while (i < n)
        {
          _str[i] = ch;
          i++;
        }
        _size = n;
        _str[_size] = '\0';
      }
    }

    void push_back(char ch)//尾插字符
    {
      if (_size + 1 > _capacity)
      {
        reserve(2 * _capacity);//开辟2倍空间
      }
      _str[_size] = ch;
      _size++;
      //ch是一个字符，所以用单独处理'\0'
      _str[_size] = '\0';
    }

    void append(const char* str)//尾插 字符串
    { 
      int len = strlen(str);
      if (_size + len > _capacity)
      {
        reserve(_size + len);
      }
      strcpy(_str + _size, str);//在原来的字符串后拷贝字符串
      _size += len;
      //str是一个字符串，本身带'\0'
    }

    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)//在pos位置前插入字符ch
    {
      if (_size + 1 > _capacity)//扩容
      {
        reserve(2 * _capacity);
      }
      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)//在pos位置前插入字符串str
    {
      int 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);//拷贝len个字节，不包含'\0'
      _size += len;
      return *this;
    }

    static const size_t npos = -1;
    string& erase(size_t pos = 0, size_t len = npos)//从pos位置开始删除len个数据
    {
      if (len==npos||pos+len>=_size)
      {
        //全部删除
        _str[pos] = '\0';
        _size = pos;
      }
      else
      {
        strcpy(_str + pos, _str +pos+len);//包含'\0'
        _size -= len;
      }
      return *this;
    }

    void swap(string &s)//交换
    {
      std::swap(_str, s._str);
      std::swap(_capacity, s._capacity);
      std::swap(_size, s._size);
    }

    size_t find(char c, size_t pos =0)
    {
      int i = 0;
      for (i = pos; i < size(); i++)
      {
        if (_str[i] == c)
        {
          return i;
        }
      }
      return npos;  
    }
    size_t find(const char* str, size_t pos = 0)//从pos位置开始找子串
    {
      char*p=strstr(_str+pos, str);
      if (p == nullptr)
      {
        return npos;
      }
      else
      {
        return p - _str;//指针相减为个数
      }
    }
    void clear()//清空
    {
      _str[0] = '\0';
    }
  ~string()//析构
  {
    delete[]_str;
    _str = nullptr;
    _size = 0;
    _capacity = 0;
  }
  private:
    char* _str;
    size_t _size;
    size_t _capacity;
  };
  ostream& operator<<(ostream& out, const string&s)//<<
  {
    int i = 0;
    for (i = 0; i < s.size(); i++)
    {
      out << s[i];
    }
    return out;
  }
  istream& operator>>(istream& in,  string& s)//>>
  {
    s.clear();
    char ch = in.get();
    char buf[128];
    size_t index = 0;
    while (ch != ' ' && ch != '\n')
    {
      buf[index++] = ch;
      if (index == 127)//为了防止频繁扩容
      {
        buf[127] = '\0';
        s += buf;
        index = 0;
      }
      ch = in.get();
    }
    if (index != 0)
    {
      buf[index] = '\0';
      s += buf;
    }
    return in;
  }
  void print(const string& s)
  {
    string::const_iterator it = s.begin();
    while (it != s.end())
    {
      cout << *it << " ";
      it++;
    }
    cout << endl;
  }
  void test()
  {
    string s1;
    cin >> s1;
    cout << s1;
  }
}

活动

智算服务

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

string的模拟实现

string的模拟实现

1. string的模拟实现

1.构造函数

使用new开辟空间

优化成全缺省的构造函数

2. C_str

3. operator[]

4.拷贝构造

浅拷贝

深拷贝

5. 赋值

三种情况

6. 迭代器

7.比较(ASCII值)大小

8. reserve(扩容)

9. push_back(尾插字符)

10. append(尾插字符串)

11. +=(字符/字符串)

12. insert

在pos位置前插入字符ch

在pos位置前插入字符串str

13 .resize

14. erase

15. 流插入<<

16. 流提取 >>

2. 整体代码

相关文章

读取模版并生成html文件

DataGuard GAP 修复1-- 模拟产生GAP

模拟实现strlen

记录一个傻错误：“error: expected identifier before string constant“

Java实现根据概率中奖率怎么算

List<T>的使用

【C/C++算法】从浅到深学习--- 简单模拟算法（图文兼备 + 源码详解）

初学Java,IO之使用转换流,读取键盘输入(四十三)

java面试题之编程【火星车问题】

【贪心】【回溯】【字符串】2014. 重复 K 次的最长子序列|2558

作者介绍

最新文章

List<T>的使用

【Clng与Cint】clng与cint的区别及防溢出函数

【字典树（前缀树)】745. 前缀和后缀搜索

【CPP】栈简介及简化模拟实现

python实战三：使用循环while模拟用户登录

【STL】string

热门文章

JSP AJAX之Form序列化登录体验

shiro自定义过滤器，实现角色或关系

Android第十七课 Jni string空串跨模块使用崩溃注意事项

string string.h cstring 区别

String不可变？一个关于String类的笔试题

String类的对象的方法 格式小结 java 1202

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

初学Android,使用样式(style)资源(二十)

这个递归哪有问题？

Struts2的OGNL经典实例

【字典树（前缀树)】745. 前缀和后缀搜索

初学Android,Activity的生命周期(十)

string string.h cstring 区别

String类的对象的方法格式小结 java 1202