轻松学习string类常用接口(附模拟实现)

目录

String的常用接口说明(最常用的)

 string类对象的容量操作

string类对象的访问及遍历操作

string类对象的修改操作

 string类非成员函数 

深浅拷贝

---

简介：C++string 是C++中的字符串。 字符串对象是一种特殊类型的容器，专门设计来操作的字符序列。 不像传统的c-strings,只是在数组中的一个字符序列，我们称之为字符数组，而C + +字符串对象属于一个类，这个类有很多内置的特点，在操作方式，更直观，另外还有很多有用的成员函数。 string 的定义为：typedef basic_string string。

String的常用接口说明(最常用的)

下面是对常用接口的模拟：

构造函数

namespace my_string
{
    class string
    {
    public:
        string(const char* str = "") //构造函数
        {                            //构造函数可以是缺省的 
            _size = strlen(str);     //当没有传初始化值的时候默认初始化成空串
            _capacity = _size;
            _str = new char[_capacity + 1];
        }
    private:
        char* _str;//字符串
 
        size_t _capacity;//容量
 
        size_t _size;//大小
    public:
        const static int npos = -1;
    };
}

拷贝构造函数

namespace my_string
{
    class string
    {
    public:
         string(const string& s)     //拷贝构造函数
            :_str(new char[s._capacity + 1]) //是用一个string类去初始化宁一个string类              
            , _size(s._size) 
            , _capacity(s._capacity)
        {
            strcpy(_str, s._str); //s._str复制到_str
        }
        void swap(string &tmp)
        {
            ::swap(_str, tmp._str);//这里使用::是使用c++库中的swap函数
            ::swap(_size, tmp._size);
            ::swap(_capacity, tmp._capacity);
        }
        string(const string& s)//要把string类s 给 _str 所以要清除_str
         :_str(nullptr)
         ,_size(0)
         ,_capacity(0)
        {
            string tmp(s._str);
            swap(tmp);
        }
    private:
        char* _str;//字符串
 
        size_t _capacity;//容量
 
        size_t _size;//大小
    public:
        const static int npos = -1;
    };
}

这里第一个是普通写法，第二个是打工人写法，首先要知道我们模拟的string类中有一个保存字符串的私有成员：_str 这时候要给_str赋值可以先建立一个打工人tmp 用 传过来的string类s来调用构造函数来构造tmp，再交换tmp和_str的各项的数值。

注意 ：如果String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会生成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。

析构函数

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

 string类对象的容量操作

namespace my_string
{
    class string
    {
        size_t size()const            //由于length跟size一个性质 就实现size
        {
            return _size;
        } 
        size_t capacity()const        //返回my_string类中私有成员_capacity
        {
            return _capacity;
        }
        bool empty()const
        {
            return _size == 0;        //如果_size为0代表有效字符为0 字符串为空
        }
        void clear()                  
        {
            _str[0] = '\0';           //清除my_string中的有效字符，但容量不变
            _size = 0;
        }
        void reserve(size_t n)        //给函数扩容n个
        {
            if (_capacity < n)        //如果输入的n小于_capacity就不扩容
            {
                char* tmp = new char[n + 1];//有效字符为n开n+1是为了给'\0'留个位置
                _size = n;
                _capacity = n;
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
            }
        }
        void resize(size_t n, char c = '\0')//调整容器的有效数量 hello 
        {
            if (n <= _capacity)//截取 小于等于 容量
            {
                _str[n] = '\0';
            }
            else {
                reserve(n);                    //扩容
                _capacity = n;
                for (int i = _size; i < n; i++)//填充
                {
                    push_back(c);//尾插
                }
                
            }
        }
 
    private:
        char* _str;//字符串
 
        size_t _capacity;//容量
 
        size_t _size;//大小
    public:
        const static int npos = -1;
    };
}

注意：

 1 )  size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。

 2 )  clear()只是将string中有效字符清空，不改变底层空间大小

 3 ) reserve(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变

 4 ) 当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小

string类对象的访问及遍历操作

namespace my_string
{
    class string
    {
    public:
        char& operator[](size_t index)   //重载[]
        {
            assert(index < _size);
            return _str[index];
        }
 
        const char& operator[](size_t index)const
        {
            assert(index < _size);
            return _str[index];
        }
 
        typedef char* iterator;          //iterator就是char* 类型的指针      
        typedef const char* const_iterator; //const_iterator就是 const char* 类型的指针
 
        const_iterator begin() const
        {
            return _str;
        }
        const_iterator end() const
        {
            return _str + _size;
        }
 
        iterator begin()
        {
            return _str;
        }
 
        iterator end()
        {
            return _str + _size;
        }
 
    private:
        char* _str;//字符串
 
        size_t _capacity;//容量
 
        size_t _size;//大小
    public:
        const static int npos = -1;
    };
}

string类对象的修改操作

namespace my_string
{
    class string
    {
    public:
 
       void push_back(char c)
        {
            if (_size == _capacity) //日常检测空间满了没有
            {
                reserve(_capacity == 0 ? 4 : 2 * _capacity);//调用reserve开空间
            }
            _str[_size] = c;
            _size++;
            _str[_size] = '\0';
        }
 
        void append(const char* str) //追加字符串
        {
            int len = strlen(str);
            if (len + _size > _capacity)//老规矩检查容量
            {
                reserve(len + _size);
            }
            strcpy(_str+_size, str);
            _size += len;
        }
 
        string& operator+=(const char* str)
        {
            append(str);   //直接复用
            return *this;  //返回是为了可以连续+= a+=b+=c
        }
 
        const char* c_str()const
        {
            return _str;   //返回字符串(返回的是char*)
        }
 
        size_t find(char c, size_t pos = 0) const //返回的是第一次找到字符c的位置
        {
            for (int i = 0; i < _size; i++)
            {
                if (_str[i] == 'c')
                    return i;
            }
            return npos;        //没找到返回npos值为-1
        }
 
        size_t find(const char* s, size_t pos = 0) const //返回字符串第一次出现的位置
        {
            const char* ptr = strstr(_str + pos, s); //c库中找子串的函数
            if (ptr == nullptr)
            {
                return npos;
            }
            else {
                return ptr - _str; //指针相减得出位置
            }
        }
 
    private:
        char* _str;//字符串
 
        size_t _capacity;//容量
 
        size_t _size;//大小
    public:
        const static int npos = -1;
    };
}

 string类非成员函数 

namespace my_string
{
    class string
    {
    public:
        string& operator+(const char* str)
        {
            string tmp(*this);
            tmp += str;
            return tmp;
        }
 
        friend ostream& operator<<(ostream& _cout, const my_string::string& s);
 
        friend istream& operator>>(istream& _cin, gch::string& s);
 
        bool operator<(const string& s)
        {
            return strcmp(_str, s._str) < 0;
        }
 
        bool operator<=(const string& s)
        {
            return !(_str > s._str);
        }
 
        bool operator>(const string& s)
        {
            return strcmp(_str, s._str) > 0;
        }
 
        bool operator>=(const string& s)
        {
            return !(_str < s._str);
        }
 
        bool operator==(const string& s)
        {
            return strcmp(_str, s._str) == 0;
        }
 
        bool operator!=(const string& s)
        {
            return !(_str == s._str);
        }
               
    private:
        char* _str;//字符串
 
        size_t _capacity;//容量
 
        size_t _size;//大小
    public:
        const static int npos = -1;
    };
}
 
ostream& operator<<(ostream& _cout, const my_string::string& s)
{
    for (size_t i = 0; i < s.size(); i++)
    {
        _cout << s[i]; //_cout就是输出流里cout的别名 下面cin同理
    }
    return _cout;
}
 
istream& operator>>(istream& _cin, my_string::string& s)
{
    for (size_t i = 0; i < s.size(); i++)
    {
        _cin >> s[i];
    }
    return _cin;
}

深浅拷贝

浅拷贝 ：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规

图中为浅拷贝，s1和s2指向同一块空间

深拷贝：如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供

图中为深拷贝s1与s2分别指向不同的的空间。