【C++杂货铺】详解string

🕗 发布于 2024-03-08 15:30 c++ 开发语言 笔记 c语言 学习

🌈前言🌈

📁 为什么学习string

📂 string类对象的访问以及遍历操作编辑

📂 string类对象的修改操作

📁 模拟实现string

📁 总结

🌈前言🌈

欢迎观看本期【C++杂货铺】，本期内容将全面string，包含了解string，如何操作string，最后会模拟实现string。

因为计算机行业的不断发展，许多程序员不仅仅要掌握string这些容器的使用方法，有的公司会要求阅读底层源码，模拟实现这些容器，所以本期内容将会从零开始，带大家了解使用string。

当然，本篇内容的参考文献主要来源于网站：<string> - C++ Reference (cplusplus.com)

如果，你只想掌握string的具体使用方法，可以阅读下面这篇文章：

【C++杂货铺】详解string的接口-CSDN博客

📁 为什么学习string

在C语言中，字符串是以‘\0’结尾的一些字符的结合，为了操作方便，C标准库提供了一些str系列的库函数，但这些库函数与字符串是分开的，底层空间需要用户自己管理，可能造成越界访问等。

在日常生活中，为了简单，方便，快捷，基本都会使用string类，很少会有人去使用C库中的字符串操作函数。

📁 认识string（了解）

string是表示字符串的字符串类。该类的接口与常规容器的接口基本相同，在添加了一系列专门用来操作string的常规操作。

string是basic_string模板类的一个别名，用char来实例化basic_string模板类。

string不能操作多字节或者边长字符的序列。

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

📁 string的常用接口

string接口有上百种，这里我们只介绍常用的，以及需要了解的。

📂 构造函数

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

string s1;                //构造空的string类对象s1

string s2("hello string");    //用C风格字符串构造string类对象s2
    
string s3(s2);            //拷贝构造s3

📂 string类对象的容量操作

1. size()

size函数求的是字符串中元素的个数，不包含‘\0’。

//打印 5
string s("hello");
cout<<s.size()<<endl;

其中length 和 size作用都是一样的，都是求有效字符串的字符长度，不包含 ‘\0’。size和length方法底层实现原理完全相同。引入size的原因是为了和其他容器接口保持一致。基本使用size。

2. reserve()

reverse的作用就是为字符串预留空间，应用场景就是已知数据元素有多少，可以减少扩容的操作，减少消耗。

但reserve()相当于手动扩容，但要注意的是，扩容量不能小于现有的容量。

    string  s;
size_t cnt = s.capacity();
cout << cnt << endl;
cout<<"change:" << endl;
for (int i = 0;i < 100;i++)
{
s.push_back('a');
if (cnt != s.capacity())
{
cout << s.capacity() << endl;
cnt = s.capacity();
}
}

以上是没有reserve的对象，第一次扩容两倍，之后是扩容1.5倍每次（vs是1.5倍扩容，Linux下按照2倍扩容）。

    string  s;
s.reserve(100);
size_t cnt = s.capacity();
cout << cnt << endl;
cout<<"change:" << endl;
for (int i = 0;i < 100;i++)
{
s.push_back('a');
if (cnt != s.capacity())
{
cnt = s.capacity();
cout << cnt << endl;
}
}

上图可知reseve的结果并不一定是准确的扩容数，可能会增加一些。

3. resize()

resiz的功能是将有效字符的个数改成n；如果n大于有效字符个数，即n>size，则会插入；如果空间不够，即n>capacity，则会扩容+插入。当然传参没有char c则没有插入。

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

1. operator[ ]

string类对象支持下标访问，[ ]支持读写pos位置的数据；const修饰为只读，不能修改。

//非const的对象使用[]，可读可写
string s1("hello world");

for(int i =0;i<s1.size();i++)
{
    s1[i] = 'a';
}

for(int i=0;i<s1.size();i++)
{
    cout<<s1[i]<<' '<<endl;
}

//const对象，只读
const string s2("hello world");
for(int i =0;i<s2.size();i++)
{
    cout<<s2[i]<<' '<<endl;
}

2. 迭代器 begin + end

迭代器iterator，容器中类似与指针的东西，通过迭代器可以访问容器中的数据，使用方法也类似于指针。迭代器可能是指针，也可能不是。

begin指向容器中第一个数据的位置；end指向容器中最后一个有效字符的下一个位置，即‘\0’（ '\0'不算有效字符）。

string  s("hello world");

for (string::iterator it = s.begin();it != s.end();it++)
{
cout << *it << ' ';
}

//打印 h e l l o  w o r l d

3. 迭代器 rbegin + rend

rbegin就是reverse_begin的缩写，rbegin和rend主要用于逆序遍历。反向迭代器则是reverse_iterator.

string s("hello world");
for (string::reverse_iterator it = s.rbegin();it != s.rend();it++)
{
cout << *it << ' ';
}

4. 范围for

范围for的底层就是迭代器，将s的迭代器赋值给e(auto类型是编译器自动推导的数据类型)。

string  s("hello world");
for (auto e : s)
{
cout << e << ' ';
}
cout << endl;

📂 string类对象的修改操作

1. push_back()

尾部插入一个字符

//打印 hello w
string s("hello ");

s.push_back('w');

cout<<s<<endl;

2. append()

尾部插入一个字符串。

string s1("hello ");
s.append("world");
//打印 hello  world

string s2("hello ");
s2.append(10, 'x');
//打印helloxxxxxxxxxx

string s3("hello ");
s3.append(s1.begin(),s1.end());
//打印hello hello world

3. operator+=

尾部插入一个字符或者字符串。

string s1("hello ");
s1 += "world";

string s2("aaaaa");
s2 += ' ';

string s3("bbbbb");
s3 += s2;

4. insert()

前面之前插入字符或者字符串。

5. erase()

删除从pos位置开始，len个字符，如果len没有传参赋初值，npos就代表着有多少删多少。

npos是string里面的一个静态成员变量
 
static const size_t npos = -1; size_t是无符号整数，所以-1代表整数最大值。

从pos位置开始，删除len个字符。或者从first迭代器开始，到last迭代器结束的字符删除。

string s("a bcd");
s.erase(0,1);
cout << s << endl;
//打印 bcd

6. replace()

将字符替换。

string s1("a bcd");
s1.replace(1,1,"a");
cout << s1 << endl;
//打印aabc

string s2("a bcd");
s2.replace(1,1,1,'a');
cout << s2 << endl;
//打印aabc

insert，earse，replace等函数尽量少用，因为涉及数据元素的移动，效率太低。

7. c_str()

因为C++是要兼容C语言的，在C语言中，表示字符串使用char* 来表示的，所以C语言库中许多操作使用的是char* 来操作的。而在C++中，我们大多数使用的是string，那么如何将string类型转为C语言字符串类型呢？

c_str()的作用就是从string中返回C格式字符串。

string filename("test.txt");
/*
FILE* file = fopen(filename,"r");
filename是string类型，而fopen函数的第一个参数类型是C格式字符串。
*/
FILE* file = fopen(filename.c_str(),"r");

8. find()

find()作用就是查找字符或者字符串，从pos位置开始。默认情况下，pos位置是从0开始。

rfind()作用与find几乎相同，不过是从字符串尾开始查找。

9. sub_str()

在str中从pos位置开始，截取len个字符，将其作为字符串返回。如果len没有给或者大于npos（-1）,含义则是从pos位置截取到字符串尾。

#include <iostream>
#include <string>

int main ()
{
  std::string str="We think in generalities, but we live in details.";
                                           // (quoting Alfred N. Whitehead)

  std::string str2 = str.substr (3,5);     // "think"

  std::size_t pos = str.find("live");      // position of "live" in str

  std::string str3 = str.substr (pos);     // get from "live" to the end

  std::cout << str2 << ' ' << str3 << '\n';

  return 0;
}

📁 模拟实现string

下面会有大量的string接口的模拟实现，模拟实现是为了更好的从里层理解string，使用string。

📂 拓展知识 : 编码

常见的编码有：ASCII编码，GBK编码，UTF编码。

所谓的编码，就是文字在计算机中的存储和表示。我们通过编码将计算机0 1 表示成日常生活中的文字。

但随着越来越多国家的加入，简单的ASCII编码已经不能满足需求。所以有了UTF编码，UTF编码有UTF-8,UTG-16（2B）,UTF-32（4B），它们主要的区别就是UTF-8是可变字节，utf-16和utf-32是不变字节。

我们常用的string的底层就是使用utf-8的编码方式的char实例化的。

模拟实现string类，并完成测试

namespace bit

{

  class string

  {

    friend ostream& operator<<(ostream& _cout, const bit::string& s);

    friend istream& operator>>(istream& _cin, bit::string& s);

  public:

    typedef char* iterator;

  public:

    string(const char* str = "")；

    string(const string& s)；

    string& operator=(const string &s)；

    ~string()；



    //

    // iterator

    iterator begin()；

    iterator end()；



    /

    // modify

    void push_back(char c);

    string& operator+=(char c);

    void append(const char* str);

    string& operator+=(const char* str);

    void clear();

    void swap(string& s);

    const char* c_str()const;



    /

    // capacity

    size_t size()const

    size_t capacity()const

    bool empty()const

    void resize(size_t n, char c = '\0');

    void reserve(size_t n);



    /

    // access

    char& operator[](size_t index);

    const char& operator[](size_t index)const;



    /

    //relational operators

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

  private:

    char* _str;

    size_t _capacity;

    size_t _size;

  }

}；

📂 默认成员函数的模拟实现

//构造函数
string(const char* str = "")
:_size(strlen(str))
{
_str = new char[_size + 1];
strcpy(_str, str);
_capacity = _size;
}

//拷贝构造函数
string(const string& s)
{
string temp(s._str);
swap(temp);
}

//赋值重载
string& operator=(string temp)
{
swap(temp);
return *this;
}

//析构函数
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}

📂 iterator模拟实现

        iterator begin()
{
return _str;
}

iterator end()
{
return _str + _size;
}

const_iterator begin() const
{
return _str;
}

const_iterator end() const
{
return _str + _size;
}

📂 insert 和 erase的模拟实现

//再字符串的pos位置插入字符
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0? 4:2 * _capacity);
}

size_t end = _size + 1;

while (end > pos)
{
_str[end] = _str[end - 1];
end--;
}
_str[end] = ch;
_size++;
return *this;
}

string& insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);

if (_size + len > _capacity)
{
reserve(_size + len);
}

size_t end = _size + len;

while (end > pos+len-1)
{
_str[end] = _str[end - len];
end--;
}
strncpy(_str + pos, str, len);
_size += len;

return *this;
}

//删除pos位置后len个元素
string& erase(size_t pos=0, size_t len=npos)
{
assert(pos < _size);
if (len >= _size - pos || len == npos)
{
_str[pos] = '\0';
_size = pos;
return *this;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
return *this;
}
}

📂 modify模拟实现

//modify
void swap(string& s)
{
std::swap(this->_str, s._str);
std::swap(this->_size, s._size);
std::swap(this->_capacity, s._capacity);
}

const char* c_str() const
{
return _str;
}

void clear()
{
_size = 0;
_str[_size] = '\0';
}

void push_back(char ch)
{
//扩容2倍
/*if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';*/

insert(_size, ch);
}

void append(const char* str)
{
//扩容
/*size_t len = strlen(str);
if(_size >= _capacity - len)
{
reserve(_size + len);
}

strcpy(_str + _size, str);
_size += len;*/
insert(_size, str);
}

string& operator+=(char ch)
{
push_back(ch);
return *this;
}

string& operator+=(const char* str)
{
append(str);
return *this;
}

📂 capacity模拟实现

//capacity
size_t size() const
{
return _size;
}

size_t capacity() const 
{
return _capacity;
}

bool empty() const
{
return _size == 0;
}

void reserve(size_t n)
{
if (n > _capacity)
{
char* temp = new char[n + 1];
strcpy(temp, _str);
delete[] _str;
_str = temp;
_capacity = n;
}
}

void resize(size_t n, const char ch = '\0')
{
if (n <= _size)
{
_str[n] = '\0';
_size = n;
}
else
{
reserve(n);

for (size_t i = _size;i < n;i++)
{
_str[i] = ch;
}
_str[n] = '\0';
_size = n;
}
}

📂 relational operators的模拟实现

//relational operators
bool operator<(const string& s)
{
return strcmp(this->c_str(), s.c_str()) < 0;
}

bool operator<=(const string& s)
{
return *this < s  || *this == s;
}

bool operator>(const string& s)
{
return !(*this <= s);
}

bool operator>=(const string& s)
{
return !(*this < s);
}

bool operator==(const string& s)
{
return strcmp(this->c_str(), s.c_str()) == 0;
}

bool operator!=(const string& s)
{
return !(*this == s);
}

📂 find 的模拟实现

//返回字符c在字符串中出现的第一次位置
size_t find(char ch, int pos = 0)
{
assert(pos < _size);
for (size_t i = pos;i < _size;i++)
{
if (_str[i] == ch)
{
return i;
}
}
return npos;
}

//返回子串s在字符串中出现的第一次位置
size_t find(const char* s, size_t pos = 0)
{
assert(pos < _size);

char* ps = strstr(_str + pos, s);
if (ps != nullptr)
{
return ps - _str;
}
else
{
return npos;
}
}

📂 substr的模拟实现

string substr(size_t pos=0, size_t len=npos)
{
string temp;
if (len == npos || _size - pos < len)
{
for (size_t i = pos;i < _size;i++)
{
temp += _str[i];
}
}
else
{
for (size_t i = pos;i < pos + len;i++)
{
temp += _str[i];
}
}

return temp;
}

📁 总结

以上，我们就对string进行了全面的讲解，介绍了string的常用接口，string的底层实现，以及string相关的拓展知识。

如果你能看到这里，恭喜你，你已经对string有了全面的了解，可以说已经上手了string。剩下的就是不断调试模拟实现string了，当然模拟实现只是为了更好的理解string。

如果感觉本期内容对你有帮助，欢迎点赞，收藏，关注。Thanks♪(･ω･)ﾉ

原文地址：https://blog.csdn.net/jupangMZ/article/details/136321398

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Kafka 面试题及答案整理，最新面试题
下一篇：利用API接口进行竞品价格监控

认识磁盘存储与内存存储
磁盘存储是指将数据保存在物理磁盘（如硬盘或固态硬盘）上的一种方式。这种方式可以实现大容量的数据持久化，但在访问速度和延迟方面通常低于内存存储。持久性：数据在磁盘上持久保存，即使在系统崩溃或重启后，数据
阅读更多2024-10-19
Linux中前台、后台和守护进程区别
介绍前台、后台以及守护进程的区别
阅读更多2024-10-19
#数据结构（二）
/ 用于存储栈中的元素int top;// 栈顶指针，指向栈顶元素的索引} SqStack;
阅读更多2024-10-19
241011-在jupyter中实现文件夹压缩后下载
在使用jupyter notebook过程中，我们经常会遇到成堆的文件无法批量下载的问题，这里提供压缩文件夹代码，压缩后即可右键文件选择download实现批量下载。
阅读更多2024-10-19
云计算与SaaS赋能的工业软件服务新形态
SaaS（软件即服务）模式通过互联网将软件作为服务提供给用户，有效降低了企业的初期投入和运维成本，实现了软件的按需使用与灵活扩展，为工业软件的应用带来了革命性的变革。
阅读更多2024-10-19
基于STM32设计的实验室安全预警系统(OneNet)(246)
通过部署高精度传感器，如MQ2烟雾传感器、火焰检测传感器、红外热释电人体检测传感器以及DHT11温湿度传感器，实现对实验室环境的实时监测与精准感知。一旦发现异常，系统立即通过本地蜂鸣器与云端平台发出报
阅读更多2024-10-19
服务器数据恢复—服务器硬盘指示灯亮黄灯，raid崩溃的数据恢复案例
服务器数据恢复环境：一台浪潮服务器中有一组由6块SAS硬盘组建的RAID。服务器上划分了1个卷，存放Oracle数据库文件。服务器故障&检测：服务器上有两个硬盘指示灯亮黄灯，RAID崩溃，服务
阅读更多2024-10-19
华为流量监管
流量监管可以对不同流量进行监督，对超出部分的流量进行“惩罚”，使进入的流量被限制在一个合理的范围之内，从而保护网络资源和用户的利益。
阅读更多2024-10-19
滚雪球学Redis[9.1讲]：Redis常见问题排查指南：解决错误、优化性能与确保数据一致性
在上一节【8.2 Redis的未来发展趋势】中，我们探讨了Redis在高性能计算、分布式系统以及云原生环境中的潜在发展方向。随着Redis的持续演进，它在应用场景中将面临更多新的需求和挑战，特别是在内
阅读更多2024-10-19
无人机之融合集群技术篇
在农业植保方面，无人机集群可以用于农田巡查、病虫害监测和防治等任务，提高农业生产效率和质量。无人机的融合集群技术是一个涉及多个领域的复杂技术体系，它结合了无人机技术、自组网技术、集群控制技术以及反制设
阅读更多2024-10-19

【C++杂货铺】详解string

🌈前言🌈

📁 为什么学习string

📁 认识string（了解）

📁 string的常用接口

📂 构造函数

📂 string类对象的容量操作

1. size()

2. reserve()

3. resize()

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

1. operator[ ]

2. 迭代器 begin + end

3. 迭代器 rbegin + rend

4. 范围for

📂 string类对象的修改操作

1. push_back()

2. append()

3. operator+=

4. insert()

5. erase()

6. replace()

7. c_str()

8. find()

9. sub_str()

📁 模拟实现string

📂 拓展知识 : 编码

📂 默认成员函数的模拟实现

📂 iterator模拟实现

📂 insert 和 erase的模拟实现

📂 modify模拟实现

📂 capacity模拟实现

📂 relational operators的模拟实现

📂 find 的模拟实现

📂 substr的模拟实现

📁 总结

相关文章