C++ 模拟实现string类

C++ 模拟实现string类

String类：按照类的方式进行动态管理字符串

底层：是一种顺序表的结构，元素是char类型的字符

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

using namespace std;

class String //与标准库中的string类区分S采用大写
{
public:
    typedef char* Iterator; 
public:
    //构造 与析构
    String(const char* str = "")
    {
        if(nullptr == str)
            str_ ="";
        size_ = strlen(str);
        capacity_ = size_ ;
        str_ = new char[capacity_+1];
        strcpy(str_,str);
    }
    
    String(size_t n, char ch)
    :str_(new char [n+1])
    ,size_(n)
    ,capacity_(n)
    {
        memset(str_,ch,n);
        str_[size_] = '\0';
    }

    String(const String& str)
    :str_(new char[str.capacity_+1])
    ,size_(str.size_)
    ,capacity_(str.capacity_)
    {
        strcpy(str_,str.str_);
    }

    template<class Iterator>
    String(Iterator first,Iterator last)
    {
        auto it = first;
        size_t count = 0;
        while(it != last)
        {
            count++;
            it++;
        }
        it = first;
        size_ = capacity_ =count;
        str_ = new char[capacity_+1];
        for(size_t i = 0; i <size_ ; i++ )
        {
            str_[i] = *it++;
        }
        str_[size_] = '\0';
    }

    ~String()
    {
        if(str_)
        {
            delete[] str_;
            str_ = nullptr;
            size_ = 0;
            capacity_ = 0;
        }
    }

    //迭代器相关
    Iterator  begin()
    {
        return str_;
    }

    Iterator end()
    {
        return str_+size_;
    }


    //容量相关操作
    size_t Size() const
    {
        return size_;
    }

    size_t Capacity()const
    {
        return capacity_;
    }

    bool Empty()const
    {
        return size_ == 0;
    }

    void resize(size_t new_size,char ch)
    {
        size_t old_size = size_;
        if(new_size > old_size)
        {
            if(new_size >capacity_)
            {
                reserve(new_size);
            }
            memset(str_+size_,ch,new_size-old_size);
        }
        size_ =new_size;
        str_[size_] = '\0';
    }

    void reserve(size_t new_capacity)
    {
        size_t old_capacity = capacity_;
        if(new_capacity > capacity_)
        {
            char* temp = new char[new_capacity];
            strcpy(temp,str_);
            delete[] str_;
            str_ = temp;
            capacity_ = new_capacity;
        }
    }

    char& operator[](int index)
    {
        assert(index < size_);
        return str_[index];
    }
    const char& operator[](int index)const
    {
        assert(index < size_);
        return str_[index];
    }

    void push_back(char ch)
    {
        *this += ch;
    }
    String& operator+=(char ch)
    {
        if(size_ == capacity_)
            reserve(capacity_*2);
        str_[size_++]=ch;
        str_[size_]='\0';
    }

    String& operator+=(const char* str)
    {
        size_t len = strlen(str);
        char * temp = new char[size_+len+1];
        strcpy(temp,str_);
        strcat(temp,str);
        delete[] str_;
        str_ =temp;
        size_ = size_+len;
        capacity_ =size_;
        return *this;
    }
    String& operator+=(const String& str)
    {
        *this+=str.str_;
        return *this;
    }

    String& insert(size_t pos,char ch)
    {
        if(size_ == capacity_)
            reserve(Capacity()*2);
        for(size_t i = size_; i > pos ; i--)
        {
            str_[i] = str_[i-1];
        }
        size_+=1;
        str_[pos] = ch;
        str_[size_] = '\0';
        return *this;
    }

    Iterator erase(Iterator pos)
    {
        Iterator cur = pos;
        while(pos != end())
        {
            *pos=*(pos++);
        }
        *pos = '\0';
        return cur--;
    }

    void clear()
    {
        size_ = 0;
        capacity_ = 0;
    }

    //
    const char* c_str()const
    {
        return  str_;
    }

    size_t find(char ch,size_t pos = 0)
    {
        while(pos < size_)
        {
            if(str_[pos] == ch)
                return pos;
            pos++;
        }
        return npos;
    }
    size_t rfind(char ch ,size_t pos = npos)
    {
        int cur = (npos == pos)? size_-1:pos;
        while(cur >= 0)
        {
            if(str_[cur] == ch)
                return cur;
            cur--;
        }
        return npos;
    }
    String sub_str(size_t pos =0 , size_t  n = npos)
    {
        if(n==npos)
            n = size_ - pos;
        char  *temp = new char[n+1];

    }

    //运算符重载
    String& operator=(const String& str)
    {
        if(this != &str)
        {
           delete []str_;
           size_=str.size_;
           capacity_ =str.capacity_;
           str_ = new char[str.size_+1];
            strcpy(str_,str.str_);
        }
        return *this;
    }
    bool operator<(const String& str)const
    {
        return (strcmp(str_,str.str_)<0);
    }
    bool operator>(const String& str)const
    {
        return strcmp(str_,str.str_)>0;
    }

    bool operator==(const String& str)const
    {
        return strcmp(str_,str.str_)==0;
    }

    bool operator!=(const String& str)const
    {
        return strcmp(str_,str.str_)!=0;
    }

    friend ostream & operator<<(ostream& _cout, String& str);

private:
    char* str_;
    size_t size_;
    size_t capacity_;
    static size_t npos;
};
size_t String::npos = -1;

ostream & operator<<(ostream& out, String& str)
{
    cout<<str.str_;
    return out;
}