轻松掌握string类常用接口(附模拟实现)(附图解)

目录:

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

-> string类对象的容量操作

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

-> string类对象的修改操作

-> string类非成员函数 

--> 深浅拷贝

--> 写时拷贝 Copy-On-Write


如果对C++的类还很陌生可以看看下面这些类和对象的博客 

                                                        类和对象(上)https://blog.csdn.net/Obto_/article/details/127245441?spm=1001.2014.3001.5501https://blog.csdn.net/Obto_/article/details/127245441?spm=1001.2014.3001.5501                                                                类和对象(中)

https://blog.csdn.net/Obto_/article/details/127261735?spm=1001.2014.3001.5501https://blog.csdn.net/Obto_/article/details/127261735?spm=1001.2014.3001.5501                                                        类和对象(下)

https://blog.csdn.net/Obto_/article/details/127303410?spm=1001.2014.3001.5501https://blog.csdn.net/Obto_/article/details/127303410?spm=1001.2014.3001.5501

前言:string是表示字符串的的字符串类,该类的接口和常规容器接口基本相同,string的底层实际是:basic_string模板类的别名,typedef basic_string string; , 且不可以操作多字节或者变长字符的序列。

 

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

(constructor)函数名称                 功能说明
string() (重点) 构造空的string类对象,即空字符串     
string(const char* s)(重点) 用C-string(字符串)来构造string对象
string(size_t n,char c) string类对象中包含n个字符c
string(const string&s)(重点) 拷贝构造函数

void Teststring()
{
    string s1; // 构造空的string类对象s1
    string s2("hello bit"); // 用C格式字符串构造string类对象s2
    string s3(s2); // 拷贝构造s3
}

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

namespace my_string
{
    class string
    {
    public:
        string(const char* str = "") //构造函数
        {                            //构造函数可以是缺省的 
            _size = strlen(str);     //当没有传初始化值的时候默认初始化成空串
            _capacity = _size;
            _str = new char[_capacity + 1];
        }
         string(const string& s)     //拷贝构造函数
            :_str(new char[s._capacity + 1]) //是用一个string类去初始化宁一个string类              
            , _size(s._size) 
            , _capacity(s._capacity)
        {
            strcpy(_str, s._str); //C库中的复制s._str到_str中
        }
    private:
        char* _str;//字符串

        size_t _capacity;//容量

        size_t _size;//大小
    public:
        const static int npos = -1;
    };
}

 注意:上列的拷贝构造函数是古典式写法,下面提供一种现代式写法,也是老板式写法

这些都在上面的namespace my_string中 分开写为了强调代码
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)
    {
        tring tmp(s._str);
        swap(tmp);
    }
}
/

 操作解析:首先要知道我们模拟的string类中有一个保存字符串的私有成员:_str 这时候要给_str赋值可以先建立一个打工人tmp 用 传过来的string类s来调用构造函数来构造tmp,再交换tmp和_str的各项的数值 与 下列代码一个意思

void m_swap(int a,int b)
{
    int tmp = a;
    a=b;
    b=a;
}

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


 string类对象的容量操作

函数名称 功能说明
size(重点) 返回字符串有效长度
length 返回字符串有效长度
capacity 返回总空间大小
empty(重点) 检测字符串是否为空串,是返回true否则返回flase
clear(重点) 清除有效字符
reserve(重点) 为字符串预留空间
resize(重点) 将有效字符个数改成n个,多出的空间用字符c填充

  

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 ) resize(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类对象的访问及遍历操作

函数名称 功能说明
operator[ ](重点 ) 返回pos的位置的字符,const string类对象调用
begin+end begin获取一个字符迭代器+end获取最后一个字符下一个位置的迭代器
rbegin+rend begin获取一个字符迭代器+end获取最后一个字符下一个位置的迭代器
范围for C++11支持更简洁的范围for新遍历方式

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类对象的修改操作

函数名称        功能说明
push_back 在字符串后尾插字符c
append 在字符串后追加一个字符串
operator+=(重点) 在字符串后追加字符串str
c_str(重点) 返回C格式字符串
find+npos(重点) 从字符串pos位置开始找字符c,返回该字符的位置
rind 从字符串pos位置开始找字符c,返回该字符的位置
substr 在str中从pos位置开始,截取n个字符,然后将其返回        

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

 注意:

  1. 在string尾部追加字符时,s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多,一般情况下string类的+=操作用的比较多,+=操作不仅可以连接单个字符,还可以连接字符串。
  2. 对string操作时,如果能够大概预估到放多少字符,可以先通过reserve把空间预留好。

string类非成员函数 

函数 功能说明
operator+ 尽量少用,传值返回,导致深拷贝效率低
operator>>(重点) 输入运算符重载
operator<<(重点) 输出运算符重载
relation operators(重点) 大小比较

  


 

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


模拟到此结束 下面为string类的进一步探索 !!!




 

 深浅拷贝

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

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

轻松掌握string类常用接口(附模拟实现)(附图解)_第1张图片

 

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

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

轻松掌握string类常用接口(附模拟实现)(附图解)_第2张图片

写时拷贝 Copy-On-Write

Q1:Copy-On-Write的原理是什么?

A1: Copy-On-Write一定使用了“引用计数”当第一个类构造时,string的构造函数会根据传入的参数从堆上分配内存,当有其它类需要这块内存时,这个计数为自动累加,当有类析构时,这个计数会减一,直到最后一个类析构时,此时的RefCnt为1或是0,此时,程序才会真正的Free这块从堆上分配的内存。

Q2:string类是在什么时候共享内存的呢?

A2:如果一个类要用另一个类的数据,那就可以共享被使用类的内存了。无非有两种情况

1)用别的类构造自己 ,2)以别的类进行赋值。第一种情况会触发拷贝构造,第二种情况会触发赋值操作符。对于第一种情况,只需要在string类的拷贝构造函数中做点处理,让其引用计数累加;同样,对于第二种情况,只需要重载string类的赋值操作符,同样在其中加上一点处理。

Q3:string类在什么情况下才触发写时拷贝

A3:很显然,当然是在共享同一块内存的类发生内容改变时,才会发生Copy-On-Write,比如string类的 [] 、= 、+= 、 + 、操作符赋值,还有一些成员函数insert,replace,append也包括类的析构。如果不修改数据就不会触发Copy-On-Write。这就是拖延战术的真谛,非到万不得已才去做

Q4:Copy-On-Write具体是怎样实现的

A4:我们要让h1,h2,h3共享一块内存.w1,w2共享一块内存。因此在h1,h2,h3中我们要维护一个引用计数,在w1,w2中也要维护一个引用计数。由于string类是在堆上动态开辟的一块空间,那么我们为什么不在这块去上多分配一点来存放引用计数呢?这样共享的同一个内存区的类都有一个引用计数,也就知道这块内存有多少人使用了

string h1 = “hello”;
string h2= h1;
string h3;
h3 = h2;
 
string w1 = “world”;
string w2(“”);
w2=w1;

轻松掌握string类常用接口(附模拟实现)(附图解)_第3张图片
 

提上一嘴,很多string类的实现都采用了Copy-On-Write,虽然这是一个很有效率的技术,但是因为内存的共享导致程序在“多线程”环境中容易出现错误如果分别在两个线程中的 string 实例共享着同一块内存,很有可能发生潜在的内存问题 。


你可能感兴趣的:(c++,java,开发语言,c语言,算法,c++)