string类的构建

  class string


    {


        friend ostream& operator<<(ostream& _cout, const bit::string& s);


        friend istream& operator>>(istream& _cin, bit::string& s);


    public:


        typedef char* iterator;


    public:


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


        string(const string& s)
        {
            _str = new char[s._capacity + 1];
            strcpy(_str, s._str);
            _size = s._size;
            _capacity = s._capacity;
        }


        ~string()
        {
            delete[] _str;
            _str = nullptr;
            _size = _capacity = 0;
        }


        const char* c_str() const
        {
            return _str;
        }






            //


            // iterator


        iterator begin() {
            return _str;
        }


        iterator end() {
            return _str + _size;
        }






            /


            // modify


        void push_back(char c)
        {
            if (_size == _capacity)
            {
                // 2倍扩容
                reserve(_capacity == 0 ? 4 : _capacity * 2);
            }


            _str[_size] = c;


            ++_size;
            _str[_size] = '\0';
        }


        string& operator+=(char c) {
            push_back(c);
            return *this;
        }


        void append(const char* str)
        {
            size_t len = strlen(str);
            if (_size + len > _capacity)
            {
                // 至少扩容到_size + len
                reserve(_size + len);
            }


            strcpy(_str + _size, str);
            _size += len;
        }


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


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


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


        const char* c_str()const {
            return _str;
        }






        /


        // capacity


        size_t size()const {
            return _size;
        }


        size_t capacity()const {
            return _capacity;
        }


        bool empty()const {
            return _size == 0;
        }


        void resize(size_t n, char ch = '\0')
        {
            if (n < _size)
            {
                _size = n;
                _str[_size] = '\0';
            }
            else
            {
                reserve(n);


                for (size_t i = _size; i < n; i++)
                {
                    _str[i] = ch;
                }


                _size = n;
                _str[_size] = '\0';
            }
        }


        void reserve(size_t n)
        {
            if (n > _capacity)
            {
                cout << "reserve()->" << n << endl;


                char* tmp = new char[n + 1];
                //strcpy(tmp, _str);
                memcpy(tmp, _str, _size + 1);


                delete[] _str;
                _str = tmp;
                _capacity = n;
            }
        }






        /


        // access


        char& operator[](size_t index)
        {
            assert(index < _size);


            return _str[index];
        }


        const char& operator[](size_t index)const {
            assert(index < _size);


            return _str[index];
        }






        /


        //relational operators


        bool operator<(const string& s) const
        {
            int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);


            // "hello" "hello"   false
            // "helloxx" "hello" false
            // "hello" "helloxx" true
            return ret == 0 ? _size < s._size : ret < 0;
        }




        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);
        }


        bool operator==(const string& s) const
        {
            return _size == s._size
                && memcmp(_str, s._str, _size) == 0;
        }


        bool operator!=(const string& s) const
        {
            return !(*this == s);
        }




        size_t find(char ch, size_t pos = 0)
        {
            assert(pos < _size);


            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)
        {
            assert(pos < _size);


            const char* ptr = strstr(_str + pos, str);
            if (ptr)
            {
                return ptr - _str;
            }
            else
            {
                return npos;
            }
        }


        void insert(size_t pos, size_t n, char ch)
        {
            assert(pos <= _size);


            if (_size + n > _capacity)
            {
                reserve(_size + n);
            }
            size_t end = _size;
            while (end >= pos && end != npos)
            {
                _str[end + n] = _str[end];
                --end;
            }


            for (size_t i = 0; i < n; i++)
            {
                _str[pos + i] = ch;
            }


            _size += n;
        }


        void insert(size_t pos, const char* str)
        {
            assert(pos <= _size);


            size_t len = strlen(str);
            if (_size + len > _capacity)
            {
                reserve(_size + len);
            }
            size_t end = _size;
            while (end >= pos && end != npos)
            {
                _str[end + len] = _str[end];
                --end;
            }


            for (size_t i = 0; i < len; i++)
            {
                _str[pos + i] = str[i];
            }


            _size += len;
        }




        void erase(size_t pos, size_t len = npos)
        {
            assert(pos <= _size);


            if (len == npos || pos + len >= _size)
            {
                //_str[pos] = '\0';
                _size = pos;


                _str[_size] = '\0';
            }
            else
            {
                size_t end = pos + len;
                while (end <= _size)
                {
                    _str[pos++] = _str[end++];
                }
                _size -= len;
            }
        }


    private:


        char* _str;


        size_t _capacity;


        size_t _size;


    };