C++ 从入门到精通（第七篇）：string 类的讲解和模拟实现

作者：雪芙花

2022-10-30
湖南
本文字数：7684 字
阅读完需：约 25 分钟

一.为什么要学习 string 类

C 语言中的字符串

C 语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C 标准库中提供了一些 str 系列的库函数，但是这些库函数与字符串是分离开的，不太符合 OOP 的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。

标准库中的 string 类

string 类(了解)

字符串是表示字符序列的类
标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
string 类是使用 char(即作为它的字符类型，使用它的默认 char_traits 和分配器类型(关于模板的更多信息，请参阅 basic_string)。
string 类是 basic_string 模板类的一个实例，它使用 char 来实例化 basic_string 模板类，并用 char_traits 和 allocator 作为 basic_string 的默认参数(根于更多的模板信息请参考 basic_string)。
注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如 UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。

总结：

string 是表示字符串的字符串类
该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作 string 的常规操作。比特科技 3. string 在底层实际是：basic_string 模板类的别名，typedef basic_string<char,
char_traits, allocator> string;
不能操作多字节或者变长字符的序列。

在使用 string 类时，必须包含 #include 头文件以及 using namespace std;

string 类的常用接口说明

string 类对象的常见构造

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

复制代码

string 类对象的容量操作

size（重点）

返回字符串有效字符长度

2.length

返回字符串有效字符长度

capacity

返回空间总大小

empty （重点）

检测字符串释放为空串，是返回 true，否则返回 false

clear （重点）

清空有效字符

reserve （重点）| | ||--|--|| | |

为字符串预留空间

resize （重点）

将有效字符的个数该成 n 个，多出的空间用字符 c 填充

注意：

size()与 length()方法底层实现原理完全相同，引入 size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用 size()。
clear()只是将 string 中有效字符清空，不改变底层空间大小。
resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到 n 个，不同的是当字符个数增多时：resize(n)用 0 来填充多出的元素空间，resize(size_t n, char c)用字符 c 来填充多出的元素空间。注意：resize 在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
reserve(size_t res_arg=0)：为 string 预留空间，不改变有效元素个数，当 reserve 的参数小于 string 的底层空间总大小时，reserver 不会改变容量大小。

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

void Teststring(){string s1("hello Bit");const string s2("Hello Bit");cout<<s1<<" "<<s2<<endl;cout<<s1[0]<<" "<<s2[0]<<endl;s1[0] = 'H';cout<<s1<<endl;// s2[0] = 'h'; 代码编译失败，因为const类型对象不能修改}void Teststring(){string s("hello Bit");// 3种遍历方式：// 需要注意的以下三种方式除了遍历string对象，还可以遍历是修改string中的字符，// 另外以下三种方式对于string而言，第一种使用最多// 1. for+operator[]for(size_t i = 0; i < s.size(); ++i)cout<<s[i]<<endl;// 2.迭代器string::iterator it = s.begin();while(it != s.end()){cout<<*it<<endl;++it;}string::reverse_iterator rit = s.rbegin();while(rit != s.rend())cout<<*rit<<endl;// 3.范围forfor(auto ch : s)cout<<ch<<endl;}

复制代码

string 类对象的修改操作

push_back

在字符串后尾插字符 c

append

在字符串后追加一个字符串

operator+= (重点)

在字符串后追加字符串 str

c_str(重点)

返回 C 格式字符串

find + npos(重点)

从字符串 pos 位置开始往后找字符 c，返回该字符在字符串中的位置

rfind

从字符串 pos 位置开始往前找字符 c，返回该字符在字符串中的位置

substr

在 str 中从 pos 位置开始，截取 n 个字符，然后将其返回

void Teststring(){string str;str.push_back(' '); // 在str后插入空格str.append("hello"); // 在str后追加一个字符"hello"str += 'b'; // 在str后追加一个字符'b'str += "it"; // 在str后追加一个字符串"it"cout<<str<<endl;cout<<str.c_str()<<endl; // 以C语言的方式打印字符串// 获取file的后缀string file1("string.cpp");size_t pos = file.rfind('.');string suffix(file.substr(pos, file.size()-pos));cout << suffix << endl;// npos是string里面的一个静态成员变量// static const size_t npos = -1;// 取出url中的域名sring url("http://www.cplusplus.com/reference/string/string/find/");cout << url << endl;size_t start = url.find("://");if (start == string::npos){cout << "invalid url" << endl;return;}start += 3;size_t finish = url.find('/', start);string address = url.substr(start, finish - start);cout << address << endl;// 删除url的协议前缀pos = url.find("://");url.erase(0, pos+3);cout<<url<<endl;}

复制代码

注意：

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

string 类非成员函数

operator+

尽量少用，因为传值返回，导致深拷贝效率低

operator>>

（重点）输入运算符重载

operator<< （重点）

输出运算符重载

getline （重点）

获取一行字符串

relational operators

（重点）大小比较

例题

仅仅反转字母

class Solution {public:string reverseOnlyLetters(string S) {char* pLeft = (char*)S.c_str();char* pRight = pLeft + (S.size()-1);while(pLeft < pRight){// 从前往后找，找到一个字母while(pLeft < pRight){// 找到有效字母后停下来if(isalpha(*pLeft))break;++pLeft;}// 从后往前找，找一个字母while(pLeft < pRight){// 找到有效字母后停下来if(isalpha(*pRight))break;--pRight;}if(pLeft < pRight){swap(*pLeft, *pRight);++pLeft;--pRight;}}return S;}};

复制代码

string 类的模拟实现

深拷贝和浅拷贝

上面已经对 string 类进行了简单的介绍，大家只要能够正常使用即可。在面试中，面试官总喜欢让学生自己来模拟实现 string 类，最主要是实现 string 类的构造、拷贝构造、赋值运算符重载以及析构函数。大家看下以下 string 类的实现是否有问题？

class string{public:/*string():_str(new char[1]){*_str = '\0';}*///string(const char* str = "\0") 错误示范//string(const char* str = nullptr) 错误示范string(const char* str = ""){// 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下if(nullptr == str){assert(false);return;}_str = new char[strlen(str) + 1];strcpy(_str, str);}~string(){if(_str){delete[] _str;_str = nullptr;}}private:char* _str;};// 测试void Teststring(){string s1("hello bit!!!");string s2(s1);}

复制代码

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

浅拷贝

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

深拷贝

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

传统版写法的 string 类

lass string{public:string(const char* str = ""){// 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下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;}return *this;}~string(){if(_str){delete[] _str;_str = nullptr;}}private:char* _str;};

复制代码

现代版写法的 string 类

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._str);}// 对比下和上面的赋值那个实现比较好？string& operator=(string s){swap(_str, s._str);return *this;}/*string& operator=(const string& s){if(this != &s){string strTmp(s);swap(_str, strTmp._str);}return *this;}*/~string(){if(_str){delete[] _str;_str = nullptr;}}private:char* _str;};

复制代码

string 类的模拟实现

头文件和接口展示

#pragma once#include<iostream>#include<string>#include<assert.h>namespace ymh{  class string  {    //友元函数    friend ostream& operator <<(ostream& cout, const string& s);    friend istream& operator <<(istream& cin,  string& s);    friend istream& getline(istream& cin, string& s);public:    //迭代器的定义    typedef char* iterator;    typedef const char* const_iterator;
    //构造函数    string(const char* s="");    string(const string& s);
    //赋值运算符重载    string& operator=(const string& s)    {      if (this != s)      {        this->clear();
      }    }
    //析构函数    ~string();
    //交换函数    void swap(string& s);
    //迭代器    iterator begin();    iterator end();    const_iterator begin() const;    const_iterator end() const; //;要给到外面
    //修改函数    void push_back(char c);    string& operator +=(const char* s);    string& operator +=(const char s);    void append(const char* s);    void clear();    const char* c_str()const ;
    //大小操作    size_t size() const;    size_t capacity() const;    void resize();    void reserve();    bool empty() const;
    //relational operator    bool operator<(const string& s);    bool operator<=(const string& s);    bool operator>(const string& s);    bool operator>=(const string& s);    bool operator==(const string& s);    bool operator!=(const string& s);
    // 返回c在string中第一次出现的位置    size_t find(char c, size_t pos = 0) const;    // 返回子串s在string中第一次出现的位置    size_t find(const char* s, size_t pos = 0) const;    // 在pos位置上插入字符c/字符串str，并返回该字符    string& insert(size_t pos, char c);    string& insert(size_t pos, const char* str);    // 删除pos位置上的长度个字符    string& erase(size_t pos, size_t len = npos);
  private:    char* _str;    size_t _capacity;    size_t _size;    static const size_t npos;  };  //初始化静态私有成员变量  const size_t string::npos = -1;}

复制代码

模拟实现

ostream& operator<<(ostream& _cout, const string& s){    for (auto ch : s)//会替换成string的迭代器    {        _cout << ch;    }    return _cout;}istream& operator>>(istream& _cin, string& s){    s.clear();//清理    char ch;    ch = _cin.get();//能够接收空格和结束符    while (ch != ' ' && ch != '\n')    {        s += ch;        ch = _cin.get();    }    return _cin;}
istream& getline(istream& _cin, string& s){    s.clear();    char ch;    ch = _cin.get();    while (ch != '\n')    {        s += ch;        ch = _cin.get();    }    return _cin;}//构造函数string::string(const char* str=""){    if(str==nullptr)        str="";    _str = new char[strlen(str) + 1];    _size = strlen(str);    _capacity = _size;    strcpy(_str, str);}//交换stringvoid string::swap(string& s){    ::swap(_str, s._str);    ::swap(_size, s._size);    ::swap(_capacity, s._capacity);}//拷贝构造string::string(const string& s)    :_str(nullptr)    , _size(0)    , _capacity(0){    string tmp(s._str);    swap(tmp);}//赋值重载string& string::operator=(const string& s)//传引用{    //避免自己给自己赋值    if (this != &s)    {        string tmp(s._str);        swap(tmp);    }    return *this;}//析构函数string::~string(){    delete[] _str;    _str = nullptr;    _size = 0;    _capacity = 0;}
// iterator（普通对象）string::iterator string::begin(){    return _str;}string::iterator string::end(){    return _str + _size;}// iterator（const对象）string::const_iterator string::begin()const{    return _str;}string::const_iterator string::end()const{    return _str + _size;}
// modify//尾插字符void string::push_back(char c){   // 满空间就扩容    //if (_size == _capacity)    //{    //    reserve(_capacity == 0 ? 4 : _capacity * 2);    //}    //_str[_size] = c;    //_size++;
    insert(_size, c);}string& string::operator+=(char c){    push_back(c);    return *this;}//追加字符串void string::append(const char* str){    /*size_t len = _size + strlen(str);    if (len > _capacity)    {        reserve(len);    }    strcpy(_str + _size, str);    _size = len;*/
    insert(_size, str);}string& string::operator+=(const char* str){    append(str);    return *this;}
void string::clear(){    _str[0] = '\0';    _size = 0;}
const char* string::c_str()const{    return _str;}size_t string::size()const{    return _size;}size_t string::capacity()const{    return _capacity;}bool string::empty()const{    return _size == 0;}//开空间+初始void string::resize(size_t n, char c){    if (n < _size)    {        _str[n] = '\0';        _size = n;    }    else    {        if (n > _capacity)        {            reserve(n);        }        int pos = _size;        while (pos < n)            _str[pos++] = c;        _str[n] = '\0';        _size = n;    }}//开空间void string::reserve(size_t n){    //需要的空间大于容量就开空间    if (n > _capacity)    {         char* tmp = new char[n + 1];        strncpy(tmp, _str, _size + 1);//strcpy不能将\0后的内容也拷贝        delete[] _str;        _str = tmp;        _capacity = n;    }}
// accesschar& string::operator[](size_t index){    assert(index < _size);    return _str[index];}const char& string::operator[](size_t index)const{    assert(index < _size);    return _str[index];}
//relational operatorbool string::operator<(const string& s){    return strcmp(_str, s._str) < 0;}bool string::operator<=(const string& s){    return *this < s || *this == s;}bool string::operator>(const string& s){    return !(*this <= s);}bool string::operator>=(const string& s){    return !(*this < s);}bool string::operator==(const string& s){    return strcmp(_str, s._str);}bool string::operator!=(const string& s){    return !(*this == s);}
// 返回c在string中第一次出现的位置size_t string::find(char c, size_t pos) const{    //pos的合理性    assert(pos < _size);    for (size_t i = pos; i < _size; i++)    {        if (_str[i] == c)            return i;    }    //没找到    return npos;}// 返回子串s在string中第一次出现的位置size_t string::find(const char* s, size_t pos) const{    //pos的合理性    assert(pos < _size);    const char* ret = strstr(_str + pos, s);    if (ret)        return ret - _str;    //没找到    return npos;}// 在pos位置上插入字符c/字符串strstring& string::insert(size_t pos, char c){    assert(pos <= _size);    if (_size == _capacity)    {        reserve(_capacity == 0 ? 4 : _capacity * 2);    }    char* end = _str + _size;    while (end >= _str + pos)    {        *(end + 1) = *end;        end--;    }    _str[pos] = c;    _size++;    return *this;}string& string::insert(size_t pos, const char* str){    assert(pos <= _size);    size_t len1 = strlen(str);    size_t len2 = len1 + _size;    if (len2 > _capacity)    {        reserve(len2);    }    char* end = _str + _size;    while (end >= _str + pos)    {        *(end + len1) = *end;        end--;    }    strncpy(_str + pos, str, len1);    _size += len1;
    return *this;}// 删除pos位置上的长度个字符string& string::erase(size_t pos, size_t len){    assert(pos < _size);    size_t leftlen = _size - pos - 1;    if (len >= leftlen)    {        _str[pos] = '\0';        _size = pos;    }    else    {        strcpy(_str + pos, _str + pos + len);        _size -= len;    }    return *this;}

复制代码

ps

想和博主一样刷优质面试和算法题嘛，快来刷题面试神器牛客吧，期待与你在牛客相见

发布于: 刚刚阅读数: 3

原文链接:【http://xie.infoq.cn/article/c778e562011c5b7db4c6f7f2a】。未经作者许可，禁止转载。

雪芙花

关注

还未添加个人签名 2022-04-28 加入

还未添加个人简介

发布

暂无评论

创作场景

C++ 从入门到精通（第七篇） ：string 类的讲解和模拟实现

一.为什么要学习 string 类

C 语言中的字符串

标准库中的 string 类

string 类(了解)

string 类的常用接口说明

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

string 类对象的修改操作

string 类非成员函数

例题

string 类的模拟实现

深拷贝和浅拷贝

浅拷贝

深拷贝

传统版写法的 string 类

现代版写法的 string 类

string 类的模拟实现

头文件和接口展示

模拟实现

ps

雪芙花

评论

C++ 从入门到精通（第七篇）：string 类的讲解和模拟实现