C++实现string

 gitee仓库Data structure and algorithm: 数据结构与算法 - Gitee.com

#ifndef MY_STRING_MYSTRING_H
#define MY_STRING_MYSTRING_H

#endif //MY_STRING_MYSTRING_H
#include<iostream>
using namespace std;
namespace wzh
{
    class STRING
    {
    public:
        //迭代器（在string下可以理解为指针）
        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;
        }
        //默认构造函数,无返回类型
        STRING(const char* str="")
                :_size(strlen(str))
        {
            _capacity=_size==0?3:_size;
            _str=new char[_capacity+1];
            strcpy(_str,str);
        }
        //析构函数
        ~STRING()
        {
            delete[] _str;
            _str= nullptr;
            _size=_capacity=0;
        }
        //拷贝构造
        STRING(const STRING& s)
        :_size(s._size)
        ,_capacity(s._capacity)
        {
            _str=new char[s._capacity+1];
            strcpy(_str,s._str);
        }
        //赋值重载
        STRING& operator=(const STRING& s)
        {
            if(this!=&s)
            {
                char* tmp=new char[s._capacity+1];
                strcpy(tmp,s._str);
                delete[] _str;
                _size=s._size;
                _capacity=s._capacity;
                strcpy(_str,tmp);
            }
            return *this;
        }
        //变成char*类型,非string类型
        const char* c_str()
        {
            return _str;
        }
        //重载方括号,可以修改值
        char& operator[](int index)
        {
            return _str[index];
        }
        //重载方括号,不可以修改值
        const char& operator[](int index) const
        {
            return _str[index];
        }
        //相等
        bool operator==(const STRING& s)const
        {
            return strcmp(_str,s._str)==0;
        }
        //不相等
        bool operator!=(const STRING& s)const
        {
            return !(_str==s._str);
        }
        //大于
        bool operator>(const STRING& s)const
        {
            return strcmp(_str,s._str)>=1;
        }
        //大于等于
        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)||(*this==s);
        }
        //重载+=
        STRING operator+=(const char s)
        {
            push_back(s);
            return *this;
        }
        STRING operator+=(const char* s)
        {
            append(s);
            return *this;
        }
        //返回大小
        const size_t size() const
        {
            return _size;
        }
        void resize(size_t n,char c='\0')
        {
            //小于_size的时候是删除数据
            if(n<=_size)
            {
                _size=n;
                _str[_size]='\0';
            }
            else
            {
                if(n>_capacity)
                {
                    reserve(n);
                }
                size_t i=_size;
                while(i<n)
                {
                    _str[i]=c;
                    ++i;
                }
            }
            _size=n;
            _str[_size]='\0';
        }
        //预留大小
        void reserve(size_t n)
        {
            char* tmp=new char[n+1];
            strcpy(tmp,_str);
            delete[] _str;
            _str=tmp;
            _capacity=n;
        }
        //尾插(单个字符)
        void push_back(const char s)
        {
            if(_size+1>_capacity)
            {
                STRING::reserve(_capacity*2);
            }
            _str[_size]=s;
            ++_size;
            _str[_size]='\0';
        }
        //插入多个字符
        void append(const char* s)
        {
            int len=strlen(s);
            if(_size+len>_capacity)
            {
                STRING::reserve(_size+len);
            }
            //不用strcat的原因是，strcat要自己找\0，而这里我们已经知道莫问是什么了，用strcat会浪费时间
            strcpy(_str+_size,s);
            _size=_size+len;

        }
        //在指定位置插入(单个字符)
        void insert(size_t pos,const char c)
        {
            assert(pos<=_size);
            if(_size+1>_capacity)
            {
                reserve(_capacity*2);
            }
            int end=_size+1;
            while(end>pos)
            {
                _str[end]=_str[end-1];
                end--;
            }
            _str[pos]=c;
            ++_size;
        }
        //在指定位置插入多个字符
        void insert(size_t pos,const char* c)
        {
            int len=strlen(c);
            if(_size+len>_capacity)
            {
                reserve(_size+len);
            }
            int end=_size+len;
            while(end-len+1>pos)
            {
                _str[end]=_str[end-len];
                end--;

            }
            strncpy(_str+pos,c,len);
        }
        //删除pos的len个
        void erase(size_t pos,size_t len=npos)
        {
            if(len==npos||pos+len>=_size)
            {
                _size=pos;
                _str[pos]='\0';
            }
            else
            {
                strcpy(_str+pos,_str+pos+len);
                _size-=len;
            }
        }
        //交换
        void swap(STRING& s)
        {
            std::swap(_str,s._str);
            std::swap(_size,s._size);
            std::swap(_capacity,s._capacity);
        }
        size_t find(const char ch,size_t pos=0)const
        {
            for(int i=pos;i<_size;i++)
            {
                if(_str[i]==ch)
                {
                    return i;
                }
            }
            return npos;
        }
    private:
        char* _str;
        int _size;
        int _capacity;
        static const size_t npos = -1;
    };
    ostream& operator<<(ostream& out,const STRING& s)
    {
        for(int i=0;i<s.size();i++)
        {
            out << s[i];
        }
        return out;
    }
    istream& operator>>(istream& in,STRING& s)
    {
        char ch=in.get();
        while(ch!=' '&&ch!='\n')
        {
            s+=ch;
            ch=in.get();
        }
        return in;
    }
}

#include"mystring.h"
using namespace std;
using namespace wzh;
int main()
{
    STRING s1("wzh");
    STRING s2(s1);
    STRING s3("abcde");
    STRING::iterator it=s1.begin();
//    while(it!=s1.end())
//    {
//        *it=*it+1;
//        it++;
//    }
//    STRING::const_iterator it1=s1.begin();
//    while(it1!=s1.end())
//    {
//        *it1=*it1+1;
//        it1++;
//    }

    cout << s1.find('b') << endl;
    return 0;
}