c++容器之string简介及其模拟实现

s1.push_back('a')//只能插入一个字符

s1.append("asdf")//能插入字符串

s1+=字符/字符串

s2.push_back('c')  /  s2.append(1,c)  /  s+='c'三种方式差不多，一般用string+=操作比较多，既可以加蛋哥字符，又可以加字符串。

管理动态增长字符串数组的类，与字符串相关的东西都封装在里面

typedef basic_string<char> string，用basic_string是因为涉及到编码问题，

string本质上是一个模板

template<class T>

class basic_string

{

private:

T* _str;

size_t _size;//Linux下没有size

size_t _capacity;

};

cout<<sizeof(wchar_t)<<endl;//wide characters，宽字节，两个字节

构造：

string s1;
string s2("hello");
string s3(s2);
string s4 = "word";//单参数的构造函数的隐式类型转换，关键字：explicit，先构造再拷贝构造，优化成直接构造

cout<<s1<<endl;
cout<<s2<<endl;
cout<<s3<<endl;
cout<<s4<<endl;

s2 = s4;

string迭代器：

访问和修改

正向迭代器：iterator begin();

string s1"1234"
string::iterator it = s1.begin();
int value = 0;
while(it != s1.end())
{
    value*=10;
    value += *it-'0';
    +it;
}
cout<<value<<endl;
//begin指向第一个位置迭代器
//end指向最后一个数据的下一个的迭代器，左闭右开的区间

逆向迭代器：reverse_iterator rbegin();

string::reverse_iterator rit = s1.rbegin();

while(rit != s1.rend())

const迭代器：const_iterator cbegin() const;//这个const修饰this

string::const_iterator cit = s1.cbegin();//当对象被const修饰时，用const迭代器。只读不可写

迭代器的优势：

迭代器给出了统一的方式去访问容器，屏蔽掉底层复杂的结构细节。

新的访问方式

1. 迭代器（不常用，跟其他容器保持统一的方式）
2. for+下标（更常用），operator[]，string，vector，deque有operator[]
3. C++11语法糖

string s1("1234");
int value = 0;
for(size_t i = 0; i<s1.size(); ++i)
{
    value *= 10;
    value += (s1[i] - '0');
}
cout<<value<<endl;

 

string s1("1234");
int value = 0;
for(auto e : s1)
{
    value *= 10;
    value += (e - '0');
}
cout<<value<<endl;

如果能预估到大概放多少个字符，可以先通过reserve把空间预留好。

string类的实现

传统写法:

class String
{
public:
    String(const T* str = "")//构造
    {
        if(nullptr == str)
           {
               assert(false);
               return;
           }
        _str = new char[strlen(str)+1];
        strcpy(_str,str);
    }

    String(const String& s)//拷贝构造
        :_str(new char[strlen(s._str)+1])    
    {
        strcpy(_str, s._str)    
    }
    
    String& operator=(const String& s)//赋值运算符重载
    {
        if(this != &s)
        {
            char* pstr = new char[strlen(s._str)+1];
            strcpy(pstr,s._str);
            delete[]_str;
            _str = pstr;
        }
    }

    ~String()
    {
        if(_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }

private:
    char* _str;
};

现代写法：

class String
{
public:
    String(const char* str = "")
    {
        if(nullptr==str)
            str = "";
        _str = new char[strlen(str)+1];
        strcpy(_str, str);
    }

    String(const String& s)
        :_str(nullptr)
    {
        String strtmp(s._str);
        swap(_str,strtmp);
    }

    String& operator=(String s)
    {
        if(this != &s)
        swap(_str,s._str);   
        return *this;
    }

    ~String()
    {
        if(_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

完整的string类实现：https://github.com/1214wuai/String-