C++初阶：模拟实现string类

已于 2024-04-11 19:52:25 修改
阅读量309 收藏
点赞数 3
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： c++
于 2024-03-19 22:02:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_71925940/article/details/136850819
本文详细介绍了C++中的string类的构造函数、拷贝构造函数、赋值重载、析构函数，以及字符串的容量管理、迭代器、修改操作、元素访问、比较运算符、查找功能、输入流处理和交换方法等关键部分。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

构造函数：

        //全缺省的构造函数
        string(const char* str = "")//有一个/0
        {
            if (str == nullptr)
            {
                assert(nullptr);
                return;
            }
            _size = strlen(str);
            _capacity = _size;
            _str = new char[_capacity + 1];
            strcpy(_str, str);
        }

拷贝构造函数：

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


        //现代写法
        string(const string& s)
            :_str(nullptr)
            ,_size(0)
            ,_capacity(0)
        {
            string tmp(s._str);
            swap(tmp);
        }

赋值重载：

        //传统写法
        string& operator=(const string& s)
        {
            char* tmp = new char[s._capacity + 1];
            strcpy(tmp,s._str);
            
            delete[] _str;
            _str = tmp;
            _size = s._size;
            _capacity = s._capacity;
            
            return *this;
        }


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

析构函数：

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

Capacity（容量）:

        // 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 c = '\0')
        {
            if (n > _size)
            {
                // 如果newSize大于底层空间大小，则需要重新开辟空间
                if (n > _capacity)
                {
                    reserve(n);
                }
                memset(_str + _size, c, n - _size);
            }
            _str[n] = '\0';
            _size = n;
        }

        void reserve(size_t n)
        {
            // 如果新容量大于旧容量，则开辟空间
            if (n > _capacity)
            {
                char* tmp = new char[n + 1];
                strcpy(tmp, _str);
                
            // 释放原来旧空间,然后使用新空间
                delete[] _str;
                _str = tmp;
                _capacity = n;
            }
        }

Iterators(迭代器):

begin+end

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

Modifiers(修改):

            // modify

        void push_back(char c)
        {
            //if (_size == _capacity)
            //{
            //    reserve(_capacity == 0 ? 4 : _capacity * 2);
            //}
            //_str[_size] = c;
            //_size++;
            //_str[_size] = '\0';

            insert(_size, c);
        }

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

        void append(const char* str)
        {
            //size_t len = strlen(str);
            //if (len + _size > _capacity)
            //{
            //    reserve(len + _size);
            //}
            //strcpy(_str + _size, str);
            //_size += len;
            insert(_size, str);
        }

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

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

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

        string& insert(size_t pos, char c)
        {
            assert(pos <= _size);

            if (_size == _capacity)
            {
                reserve(_capacity == 0 ? 4 : _capacity * 2);
            }
            
            //int end = _size;
            //while (end >=(int)pos)
            //{
            //    _str[end + 1] = _str[end];
            //    --end;
            //}
            //_str[pos] = c;
            //++_size;

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

            return *this;
        }

        string& 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 + len;
            //while(end>=pos+len)
            //while(end-(int)len>=(int)pos)
            while (end > pos+len-1)
            {
                _str[end] = _str[end - len];
                --end;
            }
            strncpy(_str + pos, str, len);
            _size+=len;

            return *this;
        }


        // 删除pos位置上的元素，并返回该元素的下一个位置

        string& erase(size_t pos, size_t len)
        {
            assert(pos < _size);
            if (len == std::string::npos || len >= _size - pos)//len+pos>=_size
            {
                _str[pos] = '\0';
                _size = pos;
            }
            else
            {
                strcpy(_str + pos, _str + pos + len);
                _size -= len;
            }
            return *this;
        }

Element access(元素访问):

        // access

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

            return _str[pos];
        }

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

            return _str[pos];
        }

relational operators：
 

       bool operator<(const string& s)
        {
            int ret = strcmp(_str, s._str);
            return ret < 0;
        }

        bool operator<=(const string& s)
        {
            int ret = strcmp(_str, s._str);
            return ret < 0 || ret == 0;
        }

        bool operator>(const string& s)
        {
            int ret = strcmp(_str, s._str);
            return ret > 0;

        }

        bool operator>=(const string& s)
        {
            int ret = strcmp(_str, s._str);
            return ret > 0 || ret == 0;
        }

        bool operator==(const string& s)
        {
            int ret = strcmp(_str,s._str);
            return ret == 0;
        }

        bool operator!=(const string& s)
        {
            int ret = strcmp(_str, s._str);
            return ret != 0;
        }

String operations（字符串操作）:

        // 返回c在string中第一次出现的位置

        size_t find(char c, size_t pos = 0) const
        {
            assert(pos < _size);
            for (size_t i = pos; i < _size; i++)
            {
                if (_str[i] == c)
                    return i;
            }
            return std::string::npos;
        }

        // 返回子串s在string中第一次出现的位置

        size_t find(const char* s, size_t pos = 0) const
        {
            assert(pos < _size);
            const char* p = strstr(_str + pos, s);
            if (p)
            {
                return p - _str;
            }
            else
            {
                return std::string::npos;
            }
        }

        //生成子字符串
        //返回一个新构造的对象，其值初始化为此对象的子字符串的副本
        string substr(size_t pos = 0, size_t len = std::string::npos)const
        {
            string sub;
            //if (len == npos || len >= _size-pos)
            if (len >= _size - pos)
            {
                for (size_t i = pos; i < _size; i++)
                {
                    sub += _str[i];
                }
            }
            else
            {
                for (size_t i = pos; i < pos + len; i++)
                {
                    sub += _str[i];
                }
            }
            return sub;
        }


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

非成员函数重载：


    ////低效率版本(如果输入数据太多的话，会造成频繁扩容，效率低)
    //istream& operator>>(istream& in, string& s)
    //{
    //    s.clear();
    //    char ch;
    //    //in>>ch;// cin 和 printf 取不到空格和换行这样的分隔符，所以用get()
    //    ch = in.get();
    //    while (ch != ' ' && ch != '\n')
    //    {
    //        s += ch;
    //        ch = in.get();
    //    }
    //    return in;
    //}

    //高效率版本  （一把开空间）
    istream& operator>>(istream& in, string& s)
    {
        s.clear();
        char ch;
        ch = in.get();
        char buff[128];
        size_t i = 0;
        while (ch != ' ' && ch != '\n')
        {
            buff[i++] = ch;
            if (i == 127)
            {
                buff[127] = '\0';
                s += buff;
                i = 0;
            }
            ch = in.get();
        }
        if (i > 0)
        {
            buff[i] = '\0';
            s += buff;
        }
        return in;
    }


    istream& getline(istream& in, string& s)
    {
        s.clear();
        char ch;
        ch = in.get();
        char buff[128];
        size_t i = 0;
        while (ch != '\n')
        {
            buff[i++] = ch;
            if (i == 127)
            {
                buff[127] = '\0';
                s += buff;
                i = 0;
            }
            ch = in.get();
        }
        if (i > 0)
        {
            buff[i] = '\0';
            s += buff;
        }
        return in;
    }


    void swap(string& x, string& y)
    {
        x.swap(y);
    }

完整代码：

#pragma once
#include<assert.h>
#include<iostream>
using namespace std;
namespace xx

{
    class string

    {
        //不用友元函数也行
        //friend ostream& operator<<(ostream& _cout, const bit::string& s);
        //friend istream& operator>>(istream& _cin, bit::string& s);

    public:

        typedef char* iterator;
        typedef const char* const_iterator;

    public:

        //全缺省的构造函数
        string(const char* str = "")//有一个/0
        {
            if (str == nullptr)
            {
                assert(nullptr);
                return;
            }
            _size = strlen(str);
            _capacity = _size;
            _str = new char[_capacity + 1];
            strcpy(_str, str);
        }

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

        //现代写法
        string(const string& s)
            :_str(nullptr)
            ,_size(0)
            ,_capacity(0)
        {
            string tmp(s._str);
            swap(tmp);
        }

        ////传统写法
        //string& operator=(const string& s)
        //{
        //    char* tmp = new char[s._capacity + 1];
        //    strcpy(tmp,s._str);
        //    
        //    delete[] _str;
        //    _str = tmp;
        //    _size = s._size;
        //    _capacity = s._capacity;
        //    
        //    return *this;
        //}

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


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



            //////////////////////////////////////////////////////////////

            // iterator

        iterator begin()
        {
            return _str;
        }

        iterator end()
        {
            return _str + _size;
        }
        const_iterator begin() const
        {
            return _str;
        }
        const_iterator end()const
        {
            return _str + _size;
        }


            /////////////////////////////////////////////////////////////

            // modify

        void push_back(char c)
        {
            //if (_size == _capacity)
            //{
            //    reserve(_capacity == 0 ? 4 : _capacity * 2);
            //}
            //_str[_size] = c;
            //_size++;
            //_str[_size] = '\0';

            insert(_size, c);
        }

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

        void append(const char* str)
        {
            //size_t len = strlen(str);
            //if (len + _size > _capacity)
            //{
            //    reserve(len + _size);
            //}
            //strcpy(_str + _size, str);
            //_size += len;
            insert(_size, str);
        }

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

        void clear()
        {
            _size = 0;
            _str[_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 c = '\0')
        {
            if (n > _size)
            {
                // 如果newSize大于底层空间大小，则需要重新开辟空间
                if (n > _capacity)
                {
                    reserve(n);
                }
                memset(_str + _size, c, n - _size);
            }
            _str[n] = '\0';
            _size = n;
        }

        void reserve(size_t n)
        {
            // 如果新容量大于旧容量，则开辟空间
            if (n > _capacity)
            {
                char* tmp = new char[n + 1];
                strcpy(tmp, _str);

                // 释放原来旧空间,然后使用新空间
                delete[] _str;
                _str = tmp;
                _capacity = n;
            }
        }




        /////////////////////////////////////////////////////////////

        // access

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

            return _str[pos];
        }

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

            return _str[pos];
        }



        /////////////////////////////////////////////////////////////

        //relational operators

        bool operator<(const string& s)
        {
            int ret = strcmp(_str, s._str);
            return ret < 0;
        }

        bool operator<=(const string& s)
        {
            int ret = strcmp(_str, s._str);
            return ret < 0 || ret == 0;
        }

        bool operator>(const string& s)
        {
            int ret = strcmp(_str, s._str);
            return ret > 0;

        }

        bool operator>=(const string& s)
        {
            int ret = strcmp(_str, s._str);
            return ret > 0 || ret == 0;
        }

        bool operator==(const string& s)
        {
            int ret = strcmp(_str,s._str);
            return ret == 0;
        }

        bool operator!=(const string& s)
        {
            int ret = strcmp(_str, s._str);
            return ret != 0;
        }



        // 返回c在string中第一次出现的位置

        size_t find(char c, size_t pos = 0) const
        {
            assert(pos < _size);
            for (size_t i = pos; i < _size; i++)
            {
                if (_str[i] == c)
                    return i;
            }
            return std::string::npos;
        }

        // 返回子串s在string中第一次出现的位置

        size_t find(const char* s, size_t pos = 0) const
        {
            assert(pos < _size);
            const char* p = strstr(_str + pos, s);
            if (p)
            {
                return p - _str;
            }
            else
            {
                return std::string::npos;
            }
        }

        //生成子字符串
        //返回一个新构造的对象，其值初始化为此对象的子字符串的副本
        string substr(size_t pos = 0, size_t len = std::string::npos)const
        {
            string sub;
            //if (len == npos || len >= _size-pos)
            if (len >= _size - pos)
            {
                for (size_t i = pos; i < _size; i++)
                {
                    sub += _str[i];
                }
            }
            else
            {
                for (size_t i = pos; i < pos + len; i++)
                {
                    sub += _str[i];
                }
            }
            return sub;
        }

        // 在pos位置前插入字符c/字符串str，并返回该字符的位置

        string& insert(size_t pos, char c)
        {
            assert(pos <= _size);

            if (_size == _capacity)
            {
                reserve(_capacity == 0 ? 4 : _capacity * 2);
            }
            
            //int end = _size;
            //while (end >=(int)pos)
            //{
            //    _str[end + 1] = _str[end];
            //    --end;
            //}
            //_str[pos] = c;
            //++_size;

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

            return *this;
        }

        string& 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 + len;
            //while(end>=pos+len)
            //while(end-(int)len>=(int)pos)
            while (end > pos+len-1)
            {
                _str[end] = _str[end - len];
                --end;
            }
            strncpy(_str + pos, str, len);
            _size+=len;

            return *this;
        }


        // 删除pos位置上的元素，并返回该元素的下一个位置

        string& erase(size_t pos, size_t len)
        {
            assert(pos < _size);
            if (len == std::string::npos || len >= _size - pos)//len+pos>=_size
            {
                _str[pos] = '\0';
                _size = pos;
            }
            else
            {
                strcpy(_str + pos, _str + pos + len);
                _size -= len;
            }
            return *this;
        }

    private:

        char* _str;

        size_t _capacity;

        size_t _size;

    };

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


    ////低效率版本(如果输入数据太多的话，会造成频繁扩容，效率低)
    //istream& operator>>(istream& in, string& s)
    //{
    //    s.clear();
    //    char ch;
    //    //in>>ch;// cin 和 printf 取不到空格和换行这样的分隔符，所以用get()
    //    ch = in.get();
    //    while (ch != ' ' && ch != '\n')
    //    {
    //        s += ch;
    //        ch = in.get();
    //    }
    //    return in;
    //}

    //高效率版本  (一把开空间)
    istream& operator>>(istream& in, string& s)
    {
        s.clear();
        char ch;
        ch = in.get();
        char buff[128];
        size_t i = 0;
        while (ch != ' ' && ch != '\n')
        {
            buff[i++] = ch;
            if (i == 127)
            {
                buff[127] = '\0';
                s += buff;
                i = 0;
            }
            ch = in.get();
        }
        if (i > 0)
        {
            buff[i] = '\0';
            s += buff;
        }
        return in;
    }

    istream& getline(istream& in, string& s)
    {
        s.clear();
        char ch;
        ch = in.get();
        char buff[128];
        size_t i = 0;
        while (ch != '\n')
        {
            buff[i++] = ch;
            if (i == 127)
            {
                buff[127] = '\0';
                s += buff;
                i = 0;
            }
            ch = in.get();
        }
        if (i > 0)
        {
            buff[i] = '\0';
            s += buff;
        }
        return in;
    }

    void swap(string& x, string& y)
    {
        x.swap(y);
    }
    
}

C++初阶：模拟实现vector类
qq_71925940的博客
03-29 533
既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy。是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中。构建动态二维数组时与上图实际是一致的。实现代码+测试样例:vector.h。进行的拷贝，以下代码会发生什么问题？类型的，每行没有包含任何元素，如果n。如果拷贝的是自定义类型的元素，实现代码：vector.h。的拷贝实际是浅拷贝。个元素，每个元素都是。
C++初阶：string类模拟实现
Crazy_Rabbits的博客
03-25 589
本节内容主要针对的是在STL之前的string类的实现，通过模拟实现string类的一些功能来更好地使用string。
C++初阶：STL之string类
weixin_36194037的博客
11-17 412
C++初阶：STL之string类
【C++初阶：STL —— string】string类 | 浅拷贝和深拷贝(传统写法和现代写法) | string类的模拟实现
DanceBit的博客
03-29 2639
到这里我们就要学会能自己能看文档了，因为就这个 string 类来说就有一百多个接口函数，那肯定记不住呀，我们平时用的大概就二十个，一般我们都是学习它比较常用的，其它的大概熟悉它们有哪些功能，真要用到时再去查文档。可以看到其实 string 就是一个管理字符数组的顺序表，因为字符数组的使用广泛，C++ 就专门给了一个 string 类，由于编码原因，它写的是一个模板。针对 string，一般情况它有三个成员 —— char* _str、size_t _size、size_t _capacity，我们在下面模
C++初阶:6.string类
Open__Ai的博客
04-10 1101
string类的文档介绍 字符串是表示字符序列的类 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。 string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。 string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_strin
C++初阶：适合新手的手撕string类（模拟实现string类）
weixin_70067429的博客
09-20 520
先看一下大概有哪些部分：基本结构: 2.构造函数，析构函数，拷贝函数，c_str()函数 2.1构造函数 2.2拷贝构造 2.3析构函数 2.4c_str()函数 目前还没有进行流插入和流提取的重构，只能利用这个来输出string里的内容 测试text1()函数： 结果：返回有效字符大小 3.2 ""和"=" 3.4 "="和"!="和"==" 测试text2():
C++初阶：string类的模拟自实现
qq_71806743的博客
03-19 956
string类的结构，成员变量。
C++初阶：string
yourfriendyo的博客
03-14 2229
C语言中，字符串以'\0'结尾的一些字符的集合。为操作方便，同时提供了一些关于 str 库函数，但这些库函数和字符串是分离的，并不符合面向对象的思想。string 是 C++ 中管理字符数组的一个类，是 STL中的一个容器，把字符串交由 string 管理，减轻了编程难度。是表示字符串的类。在底层上实际上是的别名。在使用 string 类时，必须包含头文件，以及展开命名空间。
C++初阶：STL之vector类模板
weixin_36194037的博客
12-14 1881
C++初阶：STL之vector类模板
【C++初阶】string类讲解：含常用接口使用及原理模拟实现
twlw13的博客
03-16 1293
1、C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。2、在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。
（C++）（持续更新）C++期末复习重点补充
fly_jiangwb的博客
08-14 572
期末复习自用错题本
【C++】缺省参数
最新发布
leilei050213的博客
08-15 237
为函数的。
C++中的STL标准模板库和string
2301_79976271的博客
08-13 835
大致介绍了STL六大组件的基础构成，以及string类的功能及模拟实现
UE官方文档学习 C++ TAarry 查询（三）Contain，Find函数的使用
m0_64217692的博客
08-12 228
但ContainsByPredicate 不仅能判断，这个元素的长度，还能断言打日志。这里就使用Lamda函数值传递，一直对每个下标累加，标记。从头开始找，直到找到满足条件的就返回，为true。找不到就为false。可以从前面找或者后面找，返回下标。找到第一个，最好默认为-1。Contain只是判断是否有这个元素.
C++查找法超超超详细解析
正在在摸鱼的博客
08-13 1178
二叉排序树（BST）是一种动态数据结构左子树中所有节点的值小于根节点的值；右子树中所有节点的值大于根节点的值；左、右子树本身也是二叉排序树。节点结构int val;AVL树是最早提出的自平衡二叉搜索树，由Adelson-Velsky和Landis于1962年发明。其核心特性是每个节点的平衡因子（Balance Factor, BF）绝对值不超过1。平衡因子：BF(node) = 左子树高度 - 右子树高度。失衡条件：插入或删除操作导致某个节点的BF绝对值超过1（即BF=±2）。
C++ #if
qq_46279058的博客
08-15 184
（Preprocessor Directive），用于。，即在编译阶段根据条件决定是否包含某段代码。跨平台适配（Windows/Linux/macOS）如果条件成立（非零），则编译。（决定哪些代码参与编译）。被定义且非零，则输出。（编译时可确定的值）。防止头文件重复包含（
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值