完整的string(模拟string接口的增删查改)

1.深拷贝与swap函数的综合

函数声明：

    string(const char* str = "");

    string(const string& s);

    string& operator=(const string &s);

    ~string();

	void swap(string& s);

 //构造函数
      //若str=nullptr，strlen会崩，会认为传的指针是空指针，会对空指针进行解引用
      
      string(const char* str="")   //是""的原因：str是字符串常量，默认会有'\0'
      {
        _size = strlen(str);
        _capacity = _size;      //_capacity是有效个字符的空间，不包括'\0'
        _str = new char[_capacity + 1]; //+1是把'\0'的位置留出来 
        strcpy(_str,str);   //直到遇到'\0'拷贝结束，但是'\0'也会拷贝过去
      }
      
      //传统写法
      //拷贝构造函数
      /*
      string (const string& s)
        :_str(new char[strlen(s._str)+1])
      {
        strcpy(_str,s._str);
      }

      //赋值重载
      string& operator=(const string &s)
      {
        if(this != &s)
        {
          delete[] _str;
          _str = new char[strlen(s._str) + 1];
          strcpy(_str,s._str);
        }
        return *this;
      }
      */

      //现代写法
      //与传统写法相比，效率一样，只是更简洁
      template<class T>
      void swap( T& a,T& b)
      {
        T tmp = a;
        a = b;
        b = tmp;
      }

      void swap(string& s)
      { 
        //下面写域名是为了和自己写的swap函数区分，下面是string中已经存在的swap函数
        swap(_str,s._str);
        swap(_size,s._size);
        swap(_capacity,s._capacity);
      }
      //拷贝构造函数
      string(const string &s)
        :_str(nullptr)        //把_str初始化，不然会成为随机值
        ,_size(0)
        ,_capacity(0)
      {
        string tmp(s._str);   //构造一个与_str相同空间大小的
        /*
        swap(_str,tmp._str);  //直接交换
        swap(_size,tmp._size);
        swap(_capacity,tmp._capacity);
        */
        // this->swap(tmp);
        swap(tmp);  //也可以直接写成这样，this是默认已有的
      }

      //赋值重载函数
      string& operator=(string s)   //直接利用传值，构造一个空间、值均相同的
      {
        /*
        swap(_str,s._str); //此时的s._str为这个函数的局部变量，出了函数，则调用析构函数销毁
        swap(_size,s._size);
        swap(_capacity,s._capacity);
        */
        //上面的可替换成下面语句
        //  this->swap(s);
        swap(s);  //也可直接这样写，this指针是默认的
        return *this;
      }
        
     //遍历
     //获取第i个的值
     //可读可写
      char& operator[](size_t i)
      {
        assert(i < _size);  //防止越界，i不能超出数组范围
        return _str[i];
      }

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

2.三种遍历方式

迭代器、for+下标、auto

	  typedef char* iterator;
      typedef const char* const_iterator;

      iterator begin()
      {
        return _str;  //返回的是数组首地址
      }

      iterator end()
      {
        return _str+_size;  //返回的是数组末尾的地址
      }
 //遍历
     //获取第i个的值
     //可读可写
      char& operator[](size_t i)
      {
        assert(i < _size);  //防止越界，i不能超出数组范围
        return _str[i];
      }
      //测试遍历
  //
  void test_string3()
  {
    string s1("hello world");
    s1[0] = 's';

    cout << s1. c_str() << endl;

    //范围for
    for(size_t i = 0; i < s1.size(); i++)
    {
      cout << s1[i] << " " ;
    }
    cout << endl;

    //迭代器
    string::iterator it = s1.begin();
    while(it != s1.end())
    {
      cout << *it << " ";
      ++it;
    }
    cout << endl;

    //auto遍历:也是转换成迭代器
    for(auto& e:s1)
    {
      cout << e << " ";
    }
    cout << endl;
    
  }

3.增

函数声明：

    void resize(size_t n, char c = '\0');

    void reserve(size_t n);
    
	void push_back(char c);

    string& operator+=(char c);

    void append(const char* str);

    string& operator+=(const char* str);

    void clear();

 //插入一个字符，要先开空间
      //
      //reserve,开空间，扩展_capacity
      //reserve只影响预先分配多大的空间，不改变元素的数量
      void reserve(size_t n)
      {
          if(n > _capacity)
          {
            char* tmp = new char[n + 1];
            strncpy(tmp,_str,_size+1);
            delete[] _str;

            _str = tmp;
            _capacity = n;
          }

      }

      //resize函数开空间+初始化，扩展capacity，并且初始化空间，size也要动
      void resize(size_t n,char val = '\0')
      {
        if(n < _size)
        {
          _size = n;
          _str[_size] = '\0';
        }
        else
        {
          if(n > _capacity)
          {
            reserve(n);
          }
          for(size_t i = _size; i < n; i++)
          {
            _str[i] = val;
          }
          _str[n] = '\0';
          _size = n;
        }

      }

      //尾插字符
      void push_back(char c)
      {
        if(_size == _capacity)
        {
          reserve(_capacity == 0 ? 4:_capacity * 2);   //防止_capacity为0的情况
        }
        _str[_size] = c;
        _str[_size + 1] = '\0';
        ++_size;

      }

      //尾部连接字符串
      void append(const char* str)
      {
        size_t len = strlen(str) + _size;
        if(len > _capacity)
        {
          reserve(len);
        }
        strcpy(_str+_size,str);  //_str是数组的首地址，+_size是数组末尾的地址，和迭代器一样
        _size = len;
          
      }

      //直接+=，和push_bank作用一样，本质还是调用push_back函数
      string& operator+=(char c)
      {
        push_back(c);
        return *this;
      } 
      
      //和append作用一样，本质还是调用append函数，只是实现更简单
      string& operator+=(const char* str)
      {
        append(str);
        return *this;
      } 
      
      //在pos位置插入一个字符
      string& insert(size_t pos,char ch)
      {
        if(_size == _capacity)
        {
          reserve(_capacity == 0 ? 4:_capacity*2);
        }
        /*  //如果头插的话，会出现end=-1大于pos=0的情况，是因为size_t是无符号整数，-1的补码就是最大的整数，为2^32-1
        size_t end = _size;
        while(end > pos)
        {
          _str[end + 1] = _str[end];
          --end;
        }
        */

        //为了解决上述问题，有以下解决办法
        //1.改变变量的类型:不推荐
        /*
        int end = _size;
        while(end >= (int)pos)
        {
          _str[end + 1] = _str[end];
          --end;
        }
        */

        //2.不改变类型，改变end指向的位置
        /*
        size_t end = _size + 1;
        while(end > pos)
        {
          _str[end] = _str[end - 1];
          --end;
        }
        */

        //3.用指针
        char* end = _str+_size;
        while(end >= pos+_str)
        {
          *(end + 1) = *end;
          --end;
        }

        _str[pos] = ch;
        ++_size;
        return *this;

      }

      //在pos位置上插入一个字符串
      string& insert(size_t pos,const char* str)
      {
        assert(pos <= _size);
        size_t len = strlen(str);
        if(_size + len > _capacity)
        {
          reserve(_size + len);
        }

        char* end = _str + _size;
        while(end >= _str + pos)
        {
          *(end + len) = *end;
          --end;
        }

        strncpy(_str+pos,str,len);
        _size += len;

        return *this;
      }

4.删

函数声明：

string& erase(size_t pos,size_t len = npos);

 //在pos位置删除len个字符
      string& erase(size_t pos,size_t len = npos)
      {
        assert(pos < _size);
        size_t leftlen = _size - pos;
        if(leftlen < len)
        {
          _str[pos] = '\0';
          _size = pos;
        }
        else
        {
          strcpy(_str+pos,_str+pos+len);
          _size -= len;
        }
        return *this;
      }

5.查

函数声明：

size_t find(char ch,size_t pos = 0);

size_t find(const char* str,size_t pos = 0);

size_t size() const;

const char* c_str() const;

void clear();

 size_t find(char ch,size_t pos = 0)
      {
        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 char* ret = strstr(_str,str);
        if(ret)
        {
          return ret - _str;
        }
        else
        {
          return npos;
        }
      }
      //返回元素的多少
      size_t size() const
      {
        return _size;
      }

      //返回字符串
      const char* c_str() const
      {
        return _str;
      }

      void clear()
      {
        _size = 0;
        _str[0] = '\0';
      }

6.比较字符串大小

函数声明：

bool operator<(const string& s1,const string& s2);

bool operator==(const string& s1,const string& s2);

bool operator>(const string& s1,const string& s2);

bool operator<=(const string& s1,const string& s2);

bool operator>=(const string& s1,const string& s2);

bool operator!=(const string& s1,const string& s2);

bool operator<(const string& s1,const string& s2)
  {
    return strcmp(s1.c_str(),s2.c_str()) < 0;
  }

  bool operator==(const string& s1,const string& s2)
  {
    return strcmp(s1.c_str(),s2.c_str()) == 0;
  }

  bool operator<=(const string& s1,const string& s2)
  {
    return s1 < s2 || s1 == s2;
  }

  bool operator>=(const string& s1,const string& s2)
  {
    return !(s1 < s2);
  }

  bool operator!=(const string& s1,const string& s2)
  {
    return !(s1 == s2);
  }


  bool operator>(const string& s1,const string& s2)
  {
    return !(s1 <= s2);
  }

7.字符串的输入输出

函数声明：

ostream& operator<<(ostream& out, string& s);

istream& operator>>(istream& in,string& s);

istream& getline(istream& in,string& s);

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

  istream& operator>>(istream& in,string& s)
  {
    s.clear();  //把原来已有的数据清除
    char ch;
    ch = in.get();
    while(ch != ' ' && ch != '\n')
    {
      s += ch;
      ch = in.get();
    }
    return in;
  }


  istream& getline(istream& in,string& s)
  {
    s.clear();  //把原来已有的数据清除
    char ch;
    ch = in.get();
    while(ch != '\n')
    {
      s += ch;
      ch = in.get();
    }
    return in;
  }

以下为全部代码：

#include<iostream>
#include<assert.h>
#include<string>
#include<string.h>

using namespace std;

namespace sxl
{
  class string
  {
    public:
      typedef char* iterator;
      typedef const char* const_iterator;

      iterator begin()
      {
        return _str;  //返回的是数组首地址
      }

      iterator end()
      {
        return _str+_size;  //返回的是数组末尾的地址
      }
    public:
      //构造函数
      //若str=nullptr，strlen会崩，会认为传的指针是空指针，会对空指针进行解引用
      
      string(const char* str="")   //是""的原因：str是字符串常量，默认会有'\0'
      {
        _size = strlen(str);
        _capacity = _size;      //_capacity是有效个字符的空间，不包括'\0'
        _str = new char[_capacity + 1]; //+1是把'\0'的位置留出来 
        strcpy(_str,str);   //直到遇到'\0'拷贝结束，但是'\0'也会拷贝过去
      }
      
      //传统写法
      //拷贝构造函数
      /*
      string (const string& s)
        :_str(new char[strlen(s._str)+1])
      {
        strcpy(_str,s._str);
      }

      //赋值重载
      string& operator=(const string &s)
      {
        if(this != &s)
        {
          delete[] _str;
          _str = new char[strlen(s._str) + 1];
          strcpy(_str,s._str);
        }
        return *this;
      }
      */

      //现代写法
      //与传统写法相比，效率一样，只是更简洁
      template<class T>
      void swap( T& a,T& b)
      {
        T tmp = a;
        a = b;
        b = tmp;
      }

      void swap(string& s)
      { 
        //下面写域名是为了和自己写的swap函数区分，下面是string中已经存在的swap函数
        swap(_str,s._str);
        swap(_size,s._size);
        swap(_capacity,s._capacity);
      }
      //拷贝构造函数
      string(const string &s)
        :_str(nullptr)        //把_str初始化，不然会成为随机值
        ,_size(0)
        ,_capacity(0)
      {
        string tmp(s._str);   //构造一个与_str相同空间大小的
        /*
        swap(_str,tmp._str);  //直接交换
        swap(_size,tmp._size);
        swap(_capacity,tmp._capacity);
        */
        // this->swap(tmp);
        swap(tmp);  //也可以直接写成这样，this是默认已有的
      }

      //赋值重载函数
      string& operator=(string s)   //直接利用传值，构造一个空间、值均相同的
      {
        /*
        swap(_str,s._str); //此时的s._str为这个函数的局部变量，出了函数，则调用析构函数销毁
        swap(_size,s._size);
        swap(_capacity,s._capacity);
        */
        //上面的可替换成下面语句
        //  this->swap(s);
        swap(s);  //也可直接这样写，this指针是默认的
        return *this;
      }
        
     //遍历
     //获取第i个的值
     //可读可写
      char& operator[](size_t i)
      {
        assert(i < _size);  //防止越界，i不能超出数组范围
        return _str[i];
      }

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

      //增删改查
      //插入一个字符，要先开空间
      //
      //reserve,开空间，扩展_capacity
      //reserve只影响预先分配多大的空间，不改变元素的数量
      void reserve(size_t n)
      {
          if(n > _capacity)
          {
            char* tmp = new char[n + 1];
            strncpy(tmp,_str,_size+1);
            delete[] _str;

            _str = tmp;
            _capacity = n;
          }

      }

      //resize函数开空间+初始化，扩展capacity，并且初始化空间，size也要动
      void resize(size_t n,char val = '\0')
      {
        if(n < _size)
        {
          _size = n;
          _str[_size] = '\0';
        }
        else
        {
          if(n > _capacity)
          {
            reserve(n);
          }
          for(size_t i = _size; i < n; i++)
          {
            _str[i] = val;
          }
          _str[n] = '\0';
          _size = n;
        }

      }

      //尾插字符
      void push_back(char c)
      {
        if(_size == _capacity)
        {
          reserve(_capacity == 0 ? 4:_capacity * 2);   //防止_capacity为0的情况
        }
        _str[_size] = c;
        _str[_size + 1] = '\0';
        ++_size;

      }

      //尾部连接字符串
      void append(const char* str)
      {
        size_t len = strlen(str) + _size;
        if(len > _capacity)
        {
          reserve(len);
        }
        strcpy(_str+_size,str);  //_str是数组的首地址，+_size是数组末尾的地址，和迭代器一样
        _size = len;
          
      }

      //直接+=，和push_bank作用一样，本质还是调用push_back函数
      string& operator+=(char c)
      {
        push_back(c);
        return *this;
      } 
      
      //和append作用一样，本质还是调用append函数，只是实现更简单
      string& operator+=(const char* str)
      {
        append(str);
        return *this;
      } 
      
      //在pos位置插入一个字符
      string& insert(size_t pos,char ch)
      {
        if(_size == _capacity)
        {
          reserve(_capacity == 0 ? 4:_capacity*2);
        }
        /*  //如果头插的话，会出现end=-1大于pos=0的情况，是因为size_t是无符号整数，-1的补码就是最大的整数，为2^32-1
        size_t end = _size;
        while(end > pos)
        {
          _str[end + 1] = _str[end];
          --end;
        }
        */

        //为了解决上述问题，有以下解决办法
        //1.改变变量的类型:不推荐
        /*
        int end = _size;
        while(end >= (int)pos)
        {
          _str[end + 1] = _str[end];
          --end;
        }
        */

        //2.不改变类型，改变end指向的位置
        /*
        size_t end = _size + 1;
        while(end > pos)
        {
          _str[end] = _str[end - 1];
          --end;
        }
        */

        //3.用指针
        char* end = _str+_size;
        while(end >= pos+_str)
        {
          *(end + 1) = *end;
          --end;
        }

        _str[pos] = ch;
        ++_size;
        return *this;

      }

      //在pos位置上插入一个字符串
      string& insert(size_t pos,const char* str)
      {
        assert(pos <= _size);
        size_t len = strlen(str);
        if(_size + len > _capacity)
        {
          reserve(_size + len);
        }

        char* end = _str + _size;
        while(end >= _str + pos)
        {
          *(end + len) = *end;
          --end;
        }

        strncpy(_str+pos,str,len);
        _size += len;

        return *this;
      }
      
      //在pos位置删除len个字符
      string& erase(size_t pos,size_t len = npos)
      {
        assert(pos < _size);
        size_t leftlen = _size - pos;
        if(leftlen < len)
        {
          _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)
      {
        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 char* ret = strstr(_str,str);
        if(ret)
        {
          return ret - _str;
        }
        else
        {
          return npos;
        }
      }

      //插入一个字符串
     /* void clear()
      {

      }
     */
      //交换字符串，先在域里面找，例如：s1.swap(s2),s1与s2交换
     

      //返回元素的多少
      size_t size() const
      {
        return _size;
      }

      //返回字符串
      const char* c_str() const
      {
        return _str;
      }

      void clear()
      {
        _size = 0;
        _str[0] = '\0';
      }

    private:
      size_t _size;
      size_t _capacity;
      char* _str; 
      static const size_t npos;
  };

  const  size_t string::npos = -1;


  bool operator<(const string& s1,const string& s2)
  {
    return strcmp(s1.c_str(),s2.c_str()) < 0;
  }

  bool operator==(const string& s1,const string& s2)
  {
    return strcmp(s1.c_str(),s2.c_str()) == 0;
  }

  bool operator<=(const string& s1,const string& s2)
  {
    return s1 < s2 || s1 == s2;
  }

  bool operator>=(const string& s1,const string& s2)
  {
    return !(s1 < s2);
  }

  bool operator!=(const string& s1,const string& s2)
  {
    return !(s1 == s2);
  }


  bool operator>(const string& s1,const string& s2)
  {
    return !(s1 <= s2);
  }

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

  istream& operator>>(istream& in,string& s)
  {
    s.clear();  //把原来已有的数据清除
    char ch;
    ch = in.get();
    while(ch != ' ' && ch != '\n')
    {
      s += ch;
      ch = in.get();
    }
    return in;
  }


  istream& getline(istream& in,string& s)
  {
    s.clear();  //把原来已有的数据清除
    char ch;
    ch = in.get();
    while(ch != '\n')
    {
      s += ch;
      ch = in.get();
    }
    return in;
  }

  // 测试深拷贝
  void test_string1()
  {
    string s1("hello world");
    string s2(s1);

    cout<<s1.c_str()<<endl;
    cout<<s2.c_str()<<endl;
    
    string s3("hello sxl");

    s1 = s3;
    cout << s3.c_str() << endl;
    cout << s1.c_str() << endl;
  }

  //测试swap函数
  void test_string2()
  {
    string s1("hello world");
    string s2("hello sxl");
    cout << s1.c_str() << endl;
    cout << s2.c_str() << endl;

    s1.swap(s2);

    cout << s1.c_str() << endl;
    cout << s2.c_str() << endl;
  }

  //测试遍历
  //
  void test_string3()
  {
    string s1("hello world");
    s1[0] = 's';

    cout << s1. c_str() << endl;

    //范围for
    for(size_t i = 0; i < s1.size(); i++)
    {
      cout << s1[i] << " " ;
    }
    cout << endl;

    //迭代器
    string::iterator it = s1.begin();
    while(it != s1.end())
    {
      cout << *it << " ";
      ++it;
    }
    cout << endl;

    //auto遍历:也是转换成迭代器
    for(auto& e:s1)
    {
      cout << e << " ";
    }
    cout << endl;
    
  }

  //测试增加字符与字符串
  void test_string4()
  {
    string s1("hello world");
    s1 += ' ';
    s1 += '#';  
    for(auto ch:s1)
    {
      cout << ch << " ";
    }
    cout << endl;
    s1 += "sxl";

    for(auto ch:s1)
    {
      cout << ch << " ";
    }
    cout << endl; 
  }

  //测试resize()函数
  void test_string5()
  {
    string s1("hello");
    s1 += '@';
    cout << s1.c_str() << endl;

    s1.resize(8,'s');
    cout << s1.c_str() << endl;

    s1.resize(15,'x');
    cout << s1.c_str() << endl;

    s1.resize(3);
    cout << s1.c_str() << endl;
  }

  //测试insert()函数和erase()函数
  void  test_string6()
  {
    string s1("hello");
    s1.insert(2,'s');

    cout << s1.c_str() << endl;

    s1.insert(0,"xl");
    cout << s1.c_str() << endl;

    s1.erase(2,2);
    cout << s1.c_str() << endl;
  }

  //测试find()函数
  void test_string7()
  {
    string s1("hello world");
   cout <<  s1.find('e') << endl;
    
    cout << s1.find("wor") << endl;
  }

  //测试输入输出
  void test_string8()
  {
    string s1("hello world");
    string s2("hello world");
   // s2.size(20,'x');
   // s2 += "!!!";

    //string s1("hello");
    cin >> s2 >> s1;
    cout << s2 << endl;
    cout << s1 << endl;

    string line;
    getline(cin,line);
    cout << line <<endl;
  }
}

#include"string.h"
#include<iostream>
#include<string>

using namespace std;

int main()
{
  //  sxl::test_string1();
    //sxl::test_string2();
  //  sxl::test_string3();
   // sxl::test_string4();
   // sxl::test_string5();
    //sxl::test_string6();
   // sxl::test_string7();
    
      sxl::test_string8();
  return 0;
}