String类模拟实现

#define _CRT_SECURE_NO_WARNINGS 1
#include<assert.h>
#include<iostream>
//using namespace std;
namespace swr
{
    class string
    {
    public:
        //1.迭代器
        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;
        }

        //2.string空类
        /*string()
            :_str(new char[1])
            , _capacity(0)
            , _size(0)
        {
            _str[0] = '\0';
        }*/

        
        string(const char* str = "")
        {
            _size = strlen(str);
            _capacity = _size;
            _str = new char[_capacity + 1];

            strcpy(_str, str);
        }

        //3.拷贝构造
        /*string(const string& s)
            :_str(new char[s._capacity + 1])
            , _size(s._size)
            , _capacity(s._capacity)
        {
            strcpy(_str, s._str);
        }*/

        //4.赋值（传统写法）
    /*    string& operator=(const string& s)
        {
            if (this != &s)
            {
                char* tmp = new char[_capacity + 1];
                strcpy(tmp, s._str);

                delete[] _str;
                _str = tmp;
                _capacity = s._capacity;
                _size = s._size;
            }
            return *this;
        }*///避免自己给自己赋值，不要先把自己原来的释放了，假如new失败了呢？

        //
        void swap(string& s)
        {
            std::swap(_str, s._str);
            std::swap(_size, s._size);
            std::swap(_capacity, s._capacity);
        }//全局的swap函数是深拷贝，代价很大，所以我们自己写，成员变量的交换用库里面的

        //s2(s1)
        string(const string& s)
            :_str(nullptr)
            , _size(0)
            ,_capacity(0)
        {
            string tmp(s._str);//调用构造函数
            swap(tmp);
        }

        //s1=s3（现代写法1）
        /*string& operator=(const string& s)
        {
            if (this != &s)
            {
                string tmp(s);
                swap(tmp);
            }
            return *this;
        }*/

        //s1=s3 (现代写法2）
        string& operator=(string s)
        {
            swap(s);
            return *this;
        }


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


        //6.C形式字符串
        const char* c_str()const
        {
            return _str;
        }


        //7.下标访问
        char& operator[](size_t pos)const
        {
            return _str[pos];
        }


        //8.reverse开空间
        void reverse(size_t n=4)
        {
            if (n > _capacity)
            {
                char* tmp = new char[n+1];
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
                _capacity = n;
            }
        }

        //9.resize增加删除数据
        void resize(size_t n,char ch ='\0')
        {
            if (n > _size)//大于size就要修改数据
            {
                reverse(n);//至少n个空间
                //修改数据,增加
                for (size_t i =_size; i < n; i++)
                {
                    _str[i] = ch;
                }
                _str[n] = '\0';
                _size = n;
            }
            else
            {//删除数据
                _str[n] = '\0';
                _size = n;
            }//resize不改变capacity
        }


        //10.尾插
        void push_back(char ch)
        {
            //1.判满
            if (_size == _capacity)
            {
                reverse(_capacity == 0 ? 4 : 2 * _capacity);
            }
            _str[_size] = ch;
            ++_size;
            _str[_size] = '\0';
        }

        void append(const char* s)
        {
            size_t len = strlen(s);
            reverse(_size + len);
            strcpy(_str + _size, s);
            _size += len;
        }

        void append(const string& s)
        {
            append(s._str);
        }


        //11.任意位置插入
        string& insert(size_t pos, char ch)
        {
            assert(pos <=_size);

            if (_size == _capacity)
            {
                reverse(_capacity == 0 ? 4 : 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)
        {
            assert(pos <= _size);

            size_t len = strlen(str);

            if (_size+len> _capacity)
            {
                reverse(_size + len);
            }

            size_t end = _size + len;
            while (end >= pos+len)
            {
                _str[end] = _str[end - len];
                end--;
            }

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

            return *this;

        }

        //12.从pos位置删除n个字符
        void erase(size_t pos,size_t len=npos)
        {
            assert(pos < _size);
            if (len = npos || pos + len >= _size)
            {
                _str[pos] = '\0';//直接pos位置以后全都没了
                _size = pos;//_size发生变化
            }
            else
            {
                strcpy(_str + pos, _str + pos + len);
                _size -= len;
            }
        }

        //13.find 一个字符或者字串
        size_t find(char ch, size_t pos = 0)
        {
            assert(pos < _size);
            for (size_t i = pos; i < _size; i++)
            {
                if (ch == _str[i])
                    return i;
            }
            return npos;
        }

        size_t find(const char* sub, size_t pos = 0)const
        {
            assert(pos < _size);
            assert(sub);

            const char* ptr = strstr(_str + pos, sub);
            if (ptr)
            {
                return ptr - _str;
            }
            else
                return npos;//找不到
        }

        //14.切割子串,从pos的位置切割len个字符
        string substr(size_t pos, size_t len = npos)const
        {
            assert(pos < _size);
            size_t reallen = len;
            if (len == npos || len + pos > _size)//会把后面的全部切割出来
            {
                reallen = _size - pos;
            }
            //string s(_str + pos + reallen);
            string s;
            for (size_t i = 0; i < reallen; i++)
            {
                s.push_back(_str[pos + i]);
            }
            return s;
        }

        //15.+=
        string& operator+=(const char* str)
        {
            append(str);
            return *this;
        }

        size_t size()const
        {
            return _size;
        }

        void clear()
        {
            _str[0] = '\0';
            _size = 0;//清空要处理'\0'和_size
        }

    private:
        char* _str;
        int _capacity;
        int _size;

    public:
        const static size_t npos = -1;

    };



std::ostream& operator<<(std::ostream& out, const string& str)
{
    for (size_t i = 0; i < str.size(); i++)
    {
        out << str[i];
    }
    return out;
}

std::istream& operator>>(std::istream& in, string& str)
{
    str.clear();//源字符串要不能有数据

    char ch;
    ch = in.get();

    const size_t N = 32;
    char buffer[N];

    size_t i = 0;

    while (ch != ' ' && ch != '\n')
    {
        buffer[i++] = ch;
        if (i == N - 1)
        {
            buffer[i] = '\0';//代表结尾标志才能有加等操作
            str += buffer;
            i = 0;//i就是buffer的末尾位置
        }

        ch = in.get();//ch获取一个字符就做一次判断
    }
    buffer[i] = '\0';
    str += buffer;//+=一个字符数组都需要\0结尾
    return in;

}

 void test()
{
    string url = "https://cplusplus.com/reference/string/string/";
    size_t pos1 = url.find("://");
    string protocol = url.substr(0, pos1);
    std::cout << protocol << std::endl;
    size_t pos2 = url.find('/', pos1 + 3);
    string domain = url.substr(pos1 + 3, pos2 - pos1 - 3);
    std::cout << domain << std::endl;
    string uri = url.substr(pos2 + 1);
    std::cout << uri <<std:: endl;
}

}
int main()
{
    swr::test();

    return 0;
}

实现了C++stl的string类的基本功能，并且测试了字符串分割查找功能，其他功能未测试但应该是对的，以后进一步学习了内存池和右值引用可以提供更多的接口