STL::string简单介绍

STL6大组件:仿函数、算法、容器、空间配置器、迭代器、配接器

2、string常用接口

a、初始化

$STL::string简单介绍,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,没有,li,使用,第2张$

哎呀，这部分，再写一遍很没有必要，所以就不写了。毕竟文档介绍的已经足够清晰，不会就查看文档，单词不会就查。主要的是要懂得底层的实现，懂得底层实现的细节，就能够更好的使用。而不仅仅只是一个接口工程师。
string - C++ Reference (cplusplus.com) $STL::string简单介绍,icon-default.png?t=N7T8,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,没有,li,使用,第1张$ https://legacy.cplusplus.com/reference/string/string/?kw=string

string提供的接口非常多，也很冗余。但是不影响，只要用主要的几个就好。

返回值不同不构成函数重载

3、string底层简单实现

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include
#include
#include
using namespace std;
namespace bit
{
    class string
    {
        friend ostream& operator(istream& _cin, bit::string& s);
    public:
        typedef char* iterator;
        typedef const char* const_iterator;
    public:
        void swap( string& s)
        {
            std::swap(_str,s._str);
            std::swap(_size,s._size);
            std::swap(_capacity,s._capacity);
        }
        //s1("xxx")
        string(const char* str = "")
        {
            _size = strlen(str);
            _capacity = _size;
            _str = new char[_capacity + 1];
            strcpy(_str,str);
        }
        //s2(s1)拷贝
        string(const string& s) 
        {
           /* _size = s._size;
            _capacity = _size;
            _str = new char[_capacity + 1];
            strcpy(_str,s._str);*/
            //这里的将s1交s2，同理，也可以直接使用swap交换
            //但是s是一个const，需要拷贝一份非const
            string tmp(s._str);
            swap(tmp);
        }
        //s2 = s1
        string& operator=( string& s)
        {
            /*_size = s._size;
            _str = new char[_size];
            strcpy(_str,s._str);
            _capacity = s._capacity;*/
            string tmp(s);
            swap(tmp);
            return  *this;
        }
        //析构
        ~string()
        {
            delete[] _str;
            _size = _capacity = 0;
        }
      const  char* c_str()const
        {
            return _str;
        }
            //
            // iterator
        iterator begin()
        {
            return _str;
        }
        iterator end()
        {
            return _str + _size;
        }
        const_iterator begin() const
        {
            return _str;
        }
        const_iterator end() const
        {
            return _str + _size;
        }
      const  char& operator[]( size_t pos)const
        {
            assert(pos = _size - pos )
            {
                _str[len] = '';
                _size = pos;
            }
            else
            {
                //从pos位置开始，往后len个位置，往前覆盖
                strcpy(_str + pos, _str + pos + len);
                _size -= len;
            }
            return pos + 1;
        }
        void print()
        {
            for (auto e : *this)
            {
                cout =(const string& s1, const string& s2)
    {
        return !(s1