STL容器之string类

文章目录

  • STL容器之string类
    • 1、 什么是STL
    • 2、STL的六大组件
    • 3、string类
      • 3.1、string类介绍
      • 3.2、string类的常用接口说明
        • 3.2.1、string类对象的常见构造
        • 3.2.2、string类对象的容量操作
        • 3.2.3、string类对象的访问及遍历操作
        • 3.2.4、 string类对象的修改操作
        • 3.2.5、 string类非成员函数
      • 3.3、 vs和g++下string结构的说明
    • 4、string类的模拟实现

img

STL容器之string类

1、 什么是STL

C++标准模板库（Standard Template Library，STL）是C++标准库的一部分，提供了一组通用的模板类和函数，以实现常见的数据结构和算法。

2、STL的六大组件

STL包含了多个模块，其中一些主要的包括：

  1. 容器（Containers）：

    • string：它被设计为一个动态数组，提供了一系列成员函数来操作字符串，同时自动处理内存的分配和释放。

    • vector： 动态数组，可动态调整大小。

    • list： 双向链表。

    • deque： 双端队列，支持在两端高效地插入和删除元素。

    • queue： 队列。

    • stack： 栈。

    • set： 集合，不允许重复元素。

    • map： 映射，键-值对的关联容器。

    • unordered_set 和 unordered_map： 使用哈希表实现的集合和映射。

  2. 算法（Algorithms）：

  • 提供了许多常见的算法，如排序、搜索、遍历等。
  • 包括了泛型算法，例如 sort、find、binary_search 等。

  1. 迭代器（Iterators）：

    • 提供了多种迭代器类型，用于遍历不同类型的数据结构。

  2. 函数对象（Function Objects）也称仿函数（functor）：

  • 包括了一些预定义的函数对象，如比较器等。

  1. 适配器（Adapters）：

    • 提供了用于修改容器接口的适配器，如 stack 、queue 和 priority_queue（优先队列，基于堆实现）。

  2. 空间配置器（allocator）：

  • std::allocator： 是STL中默认的空间配置器。它使用 new 和 delete 运算符来进行内存分配和释放。

3、string类

3.1、string类介绍

string类的文档介绍

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

总结：

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

注意：在使用string类时，必须包含#include头文件（#include <string>）以及using namespace std;。

3.2、string类的常用接口说明

string类对象其实就是字符串，但是字符串不一定是string类对象。

3.2.1、string类对象的常见构造
(constructor)函数名称功能说明
string()（重点）构造空的string类对象，即空字符串
string (const string& str)（重点）拷贝构造函数
string (const string& str, size_t pos, size_t len = npos)构造从string类对象str的pos位置向后len长度的string类对象
string (const char s)（重点）*用C-string（字符串，不是字符串对象）来构造string类对象
string (const char s, size_t n)*构造字符串s从开始位置到n位置的string类对象
string (size_t n, char c)构造n个连续字符c的string类对象
int main() {//构造函数/拷贝构造函数string s1;cout << s1 << endl;string s2("hello");cout << s2 << endl;string s3(s2);cout << s3 << endl;string s4(s3, 2, 10);cout << s4 << endl;string s5("world", 2);cout << s5 << endl;return 0;
}
3.2.2、string类对象的容量操作
函数名称功能说明
size（重点）返回string类对象有效字符长度
length返回string类对象有效字符长度
max_size返回string类对象可以达到的最大字符长度
resize（重点）将有效字符的个数改成n个，多出的空间用字符c填充（如果有参数字符c）
capacity返回当前已经分配给string类对象的存储空间大小，单位是字节
reserve（重点）要求string类对象的容量调整为计划好的容量（参数为n），如果n小于之前的容量，则不调整，大于则调整为n（看编译器，有些编译器可能大于n）
clear（重点）清空string类对象的内容，使其变成一个空字符串
empty（重点）判断string类对象是不是空
int main() {string s1("hello world a");cout << s1.capacity() << endl;//返回当前已经分配给字符串的存储空间大小，单位是字节cout << s1.size() << endl;//返回字符串有效字符长度cout << s1.length() << endl;//返回字符串有效字符长度cout << s1.max_size() << endl;//返回字符串可以达到的最大字符长度s1.resize(25, 'x');//将有效字符的个数该成n个，多出的空间用字符c填充（如果有参数字符c）cout << s1.size() << endl;cout << s1.capacity() << endl;s1.reserve(33);//要求字符串的容量调整为计划好的容量（参数为n），如果n小于之前的容量，则不调整，大于则调整为n（看编译器，有些编译器可能大于n）cout << s1 << endl;cout << s1.capacity() << endl;s1.clear();//清空字符串的内容，使其变成一个空字符串cout << s1.empty() << endl;//判断字符串是不是空return 0;
}

注意：

  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(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。只影响容量，不影响数据。
3.2.3、string类对象的访问及遍历操作
函数名称功能说明
operator[]（重点）返回string类对象在pos位置的字符引用，分const和非const，const则字符串内容（字符）不能被修改
at和opreator功能一样
back取string类对象象的末尾字符
front取string类对象的最前面字符
begin返回一个迭代器指向string类对象最前面的字符，分const和非const，const是使得this指向的内容不能改变
end返回一个迭代器指向string类对象最后面的字符的后面一个位置，和begin一样，分const和非const
rbegin反向迭代器，和begin差不多，就是这是指向string类对象最末尾字符位置
rend反向迭代器，和begin差不多，就是这是指向string类对象最前面字符的前一个位置
cbegin和begin差不多，但是这是专门用于const迭代器的
crbegin和cbegin差不多,就是这是指向string类对象最末尾字符位置
范围forC++11支持更简洁的范围for的新遍历方式
int main() {const string str1("hello ynu");string str2("hello ynu");//    str1[1] = '1';//常量string对象，这里调用的是const char& operator[] (size_t pos) const;str2[1] = 'n';str2.at(2) = 'y';char ch1 = str2.back();char ch2 = str2.front();string::iterator it2 = str2.begin();while (it2 != str2.end()) {cout << *it2;fflush(stdout);//将缓冲区数据刷新到终端it2++;}cout << endl;//const迭代器string::const_iterator it1 = str1.begin();while (it1 != str1.end()) {cout << *it1;it1++;}cout << endl;//反向迭代器string::reverse_iterator it3 = str2.rbegin();while (it3 != str2.rend()) {cout << *it3;it3++;}cout << endl;//专属/const迭代器string::const_iterator it = str1.cbegin();while (it != str1.end()) {cout << *it;it++;}cout << endl;//范围forfor (auto e: str2) {cout << e;}cout << endl;return 0;
}

3.2.4、 string类对象的修改操作
函数名称功能说明
operator+=（重点）在string类对象末尾追加字符、字符串或者string类对象
append在string类对象末尾追加字符（参数需要加上添加字符的个数n）、字符串或者string类对象
push_back在string类对象末尾增加一个字符
npos（重点）大小为无符号数的最大值，用int表示即-1
insert在string类对象pos位置之前插入字符（参数需要加上添加字符的个数n）、字符串或者string类对象
erase从string类对象pos位置开始删除长度为len的字符串，若不指定len，则len为npos（最大无符号int值）
replace从string类对象pos位置开始向后长度为len的字符串替换为新字符（参数需要加上添加字符的个数n）、新字符串或者新string类对象
swap用一个新string类对象交换本string类对象的内容。注意这里是引用，可以减少对象拷贝
c_str（重点）返回C格式字符串，这个比data常用
data和c_str一样
copy将string类对象从pos位置开始向后的n个字符复制到新字符数组里，并返回这个复制的字符串长度
findstring类对象从pos位置开始向后查找字符、字符串或者string类对象，返回第一次出现的起始字符位置。pos不指定，则从string类对象的第一个字符开始查找。没找到则返回npos
rfind和find差不多，这是pos位置从后往前找，找到返回返回第一次出现的起始字符位置。没找到返回npos
find_first_of在string类对象中找到字符、字符串和string类对象里的匹配的任意字符的第一个位置
substr返回一个string类对象，这个string类对象是原string类对象从pos位置开始向后len长度的截取的字符串副本
int main() {string s1("hello world");string s2("no no no");//operator+=s2 += "hh";s2 += 'x';s2 += s1;//appends1.append(1, 'x');s1.append("hh");s1.append(s2);//push_backs2.push_back('x');//inserts1.insert(0, "xx");s1.insert(0, 2, 'x');//erases1.erase(0, 4);//replaces1.replace(0, 4, "x");//swaps1.swap(s2);//c_strconst char *str = s1.c_str();//dataconst char *str1 = s1.data();string s3("hello world");//copychar buffer[20] = {0};size_t length = s3.copy(buffer, 8, 0);buffer[length] = '\0';cout << buffer << endl;//findsize_t found1 = s3.find('d', 3);cout << found1 << endl;size_t found2 = s3.find('f');//测试是不是用int表示的-1int test = found2;cout << found2 << endl;cout << test << endl;//rfindsize_t found3 = s3.rfind("ll", 5);cout << found3 << endl;string s4("hello gun qnd world haha no --skas wcl cb ");//find_first_ofsize_t found4 = s4.find_first_of("gunwcqnd", 0);while (found4 != std::string::npos) {s4[found4] = '*';found4 = s4.find_first_of("gunwcqnd", found4 + 1);}cout << s4 << endl;//substrstring sub_str = s4.substr(0, 9);cout << sub_str << endl;return 0;
}

注意：

  1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。

  2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

3.2.5、 string类非成员函数
函数名称功能说明
operator+返回一个string类对象，这是string类对象是（字符、字符串、string类对象）的其中两个的串联
relational operators（重点）包含操作符==、!=、<、<=、>、>=，返回值都是bool类型
swap交换两个string类对象的值。这是非成员函数，还有一个成员函数swap
operator>>（重点）从输入流中提取字符串，并存储到string类对象str中，str中之前到数据将会被覆盖。即输入运算符重载
operator<<（重点）将string类对象str的字符序列插入到输出流中。即即输出运算符重载
getline（重点）获取一行字符串。弥补了operator>>的缺陷（遇到第一个空格就只读到第一个空格之前的字符串）
int main() {//operator+string s1("hello");string s2("world");string s3 = s1 + s2;cout << s3 << endl;string s4 = s1 + 'x';cout << s4 << endl;//operator==bool b = s1 == s2;cout << b << endl;//swapcout << s1 << endl;cout << s2 << endl;swap(s1, s2);cout << s1 << endl;cout << s2 << endl;//operator>>cin >> s1;cout << s1 << endl;//operator<<cout << s2 << endl;string s5("hello ynu");//getlinegetline(cin, s5);cout << s5 << endl;return 0;
}

3.3、 vs和g++下string结构的说明

注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。

  • vs下string的结构
    string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义string中字符串的存储空间：

    • 当字符串长度小于16时，使用内部固定的字符数组来存放

    • 当字符串长度大于等于16时，从堆上开辟空间

      union _Bxty
{ // storage for small buffer or pointer to larger onevalue_type _Buf[_BUF_SIZE];pointer _Ptr;char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;

      这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。

      其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量。

      最后：还有一个指针做一些其他事情。

      故总共占16+4+4+4=28个字节。

  • g++下string的结构
    g++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针将来指向一块堆空间，内部包含了如下字段：

    • 空间总大小

    • 字符串有效长度

    • 引用计数

      struct _Rep_base
{size_type _M_length;size_type _M_capacity;_Atomic_word _M_refcount;
};

      指向堆空间的指针，用来存储字符串。

  • CLion下string的结构

    CLion下string对象总共占12个字节，是在_rep里存储了三个指针，分别是__l、__s、__r。因此总共12+4+4+4 = 24字节。

4、string类的模拟实现

  • main.cpp文件

    #include "string.h"int main() {
//    xp::test_string1();
//    xp::test_string2();
//    xp::test_string3();
//    xp::test_string4();
//    xp::test_string5();
//    xp::test_string6();
//    xp::test_string7();
//    xp::test_string8();
//    xp::test_string9();
//    xp::test_string10();
//    xp::test_string11();xp::test_string12();return 0;
}

  • string.cpp文件

    //
// Created by 徐鹏 on 2023/11/29.
//#include "string.h"namespace xp {string::string(const char *s) {_size = strlen(s);//这里还没有size()呢，size()得自己写_capacity = _size;_str = new char[_capacity + 1];//多开一个空间存\0strcpy(_str, s);}//拷贝构造函数 --   传统写法
//    string::string(const string &str) {
//        _size = str._size;
//        _capacity = str._capacity;
//        _str = new char[_capacity + 1];
//        strcpy(_str, str._str);
//    }//  现代写法string::string(const string &str) : _str(nullptr), _size(0),_capacity(0) {//这里得使用初始化列表或者在private里得成员变量进行缺省，防止交换后tmp指向随机值，调用析构就会出错string tmp(str._str);swap(tmp);}void string::swap(string &str) {std::swap(_str, str._str);std::swap(_size, str._size);std::swap(_capacity, str._capacity);}void string::reserve(size_t n) {if (n > _capacity) {//扩容char *new_str = new char[n + 1];strcpy(new_str, _str);delete[] _str;_str = new_str;_capacity = n;}//小于等于则不改变容量}void string::resize(size_t n) {if (n > _capacity) {//需要重新开辟空间reserve(n);} else {//缩小容量和有效字符_capacity = n;_size = n;_str[n] = '\0';}}char &string::operator[](size_t pos) {assert(pos < _size);return _str[pos];}const char &string::operator[](size_t pos) const {assert(pos < _size);return _str[pos];}char &string::at(size_t pos) {
//        assert(pos < _size);
//        抛异常return _str[pos];}const char &string::at(size_t pos) const {
//        assert(pos < _size);
//        抛异常return _str[pos];}void string::append(const string &str) {size_t total_size = _size + str._size;//如果新插入的字符串加上之前的字符串的长度大于容量，则需要扩容if (total_size > _capacity) {reserve(total_size);}//把字符加进来for (int i = 0; i < str._size; ++i) {_str[_size++] = str[i];}_str[_size] = '\0';}void string::append(const char *s) {size_t total_size = _size + strlen(s);//如果新插入的字符串加上之前的字符串的长度大于容量，则需要扩容if (total_size > _capacity) {reserve(total_size);}//把字符加进来strcpy(_str + _size, s);_size += strlen(s);}string &string::operator+=(const string &str) {append(str);return *this;}string &string::operator+=(const char *s) {string str(s);append(str);return *this;}string &string::operator+=(char c) {push_back(c);return *this;}void string::push_back(char c) {size_t total_size = _size + 1;//如果新插入的字符加上之前的字符串的长度大于容量，则需要扩容if (total_size > _capacity) {reserve(total_size);}//把字符加进来_str[_size++] = c;_str[_size] = '\0';}string &string::insert(size_t pos, const string &str) {assert(pos < _size);
//        size_t total_size = _size + str._size;
//        //如果新插入的字符串加上之前的字符串的长度大于容量，则需要扩容
//        if (total_size > _capacity) {
//            reserve(total_size);
//        }
//        int end = _size;
//        //pos后面数据先后移，每个元素后移str._size，这里end最后等于-1
//        while (end >= (int) pos) {
//            _str[end + str._size] = _str[end];
//            --end;
//        }
//
        size_t end = total_size;
        //pos后面数据先后移，每个元素后移str._size，这里end最后等于0
        while (end > pos) {
            //当end减去str._size的时候，也就是预留的给插入的长度小于str._size时候，说明pos后面的数据移动完成，直接退出就行
            if (end - str._size < 0)
                break;
            _str[end] = _str[end - str._size];
            --end;
        }
//        //插入数据
//        strncpy(_str + pos, str._str, str._size);
//        _size = total_size;insert(pos, str.c_str());//复用return *this;}string &string::insert(size_t pos, const char *s) {assert(pos < _size);size_t total_size = _size + strlen(s);if (total_size > _capacity) {reserve(total_size);}size_t end = total_size;//pos后面数据先后移，每个元素后移str._size，这里是相当于元素后移，这里end最后等于0while (end > pos) {//当end减去strlen(str)的时候，也就是预留的给插入的长度小于strlen(str)时候，说明pos后面的数据移动完成，直接退出就行if (end - strlen(s) < 0)break;_str[end] = _str[end - strlen(s)];--end;}//插入数据strncpy(_str + pos, s, strlen(s));_size = total_size;return *this;}string &string::insert(size_t pos, size_t n, char c) {assert(pos < _size);size_t total_size = _size + n;if (total_size > _capacity) {reserve(total_size);}size_t end = total_size;//pos后面数据先后移，每个元素后移str._size，这里是相当于元素后移，这里end最后等于0while (end > pos) {if (end - n < 0)break;_str[end] = _str[end - n];--end;}//插入数据while (n--) {_str[pos++] = c;}_size = total_size;return *this;}string &string::erase(size_t pos, size_t len) {assert(pos < _size);if (len == std::string::npos || len + pos >= size()) {_str[pos] = '\0';//pos后面数据全部不要了_size = pos;} else {strcpy(_str + pos, _str + pos + len);_size -= len;}return *this;}size_t string::find(const string &str, size_t pos) const {assert(pos < _size);const char *ret = strstr(_str + pos, str._str);if (nullptr == ret) return std::string::npos;return ret - _str;}size_t string::find(const char *s, size_t pos) const {assert(pos < _size);const char *ret = strstr(_str + pos, s);if (nullptr == ret) return std::string::npos;return ret - _str;}size_t string::find(char c, size_t pos) const {assert(pos < _size);while (pos < _size) {if (_str[pos] == c) return pos;pos++;}//没找到return std::string::npos;}string string::substr(size_t pos, size_t len) const {assert(pos < _size);size_t end = pos + len;if (len == npos || end >= _size) {end = _size;}string str;str.reserve(end - pos);//开辟空间while (pos < end) {str += _str[pos++];}//把\0也带进去str._str[_size] = '\0';return str;}// 传统写法
//    string &string::operator=(const string &str) {
//        if (this != &str) {
//            reserve(str._capacity);
//            strcpy(_str, str._str);
//            _size = str._size;
//        }
//
//        return *this;
//    }//  现代写法string &string::operator=(string str) {//这里不会改变赋值的值，这里str只是临时拷贝swap(str);return *this;}string &string::operator=(const char *s) {reserve(strlen(s));strcpy(_str, s);_size = strlen(s);return *this;}string &string::operator=(char c) {reserve(1);_str[0] = c;_str[1] = '\0';_size = 1;return *this;}ostream &operator<<(ostream &out, string &str) {for (auto e: str) {out << e;}return out;}istream &operator>>(istream &in, string &str) {str.clear();char buffer[128];//缓冲一下char c = in.get();int i = 0;while (c != ' ' && c != '\n') {buffer[i++] = c;if (i == 127) {buffer[i] = '\0';str += buffer;i = 0;//重置}c = in.get();}//提前读到' ' 或者 '\n'if (i > 0) {buffer[i] = '\0';str += buffer;}return in;}string::~string() {delete[] _str;_str = nullptr;_capacity = 0;_size = 0;}void test_string1() {string s1;cout << s1.c_str() << endl;string s2("hello world");cout << s2.c_str() << endl;string s3(s2);cout << s3.c_str() << endl;}void test_string2() {string s1;string s2("hello world");cout << s2.capacity() << endl;s2.reserve(2);cout << s2.capacity() << endl;s2.resize(15);cout << s2.capacity() << endl;s2.resize(7);cout << s2.capacity() << endl;cout << s2.c_str() << endl;}void test_string3() {string s1("hello world");const string s2("nihao liangzai");string::iterator it1 = s1.begin();while (it1 != s1.end()) {cout << *it1 << " ";++it1;}cout << endl;string::const_iterator it2 = s2.begin();while (it2 != s2.end()) {cout << *it2 << " ";++it2;}cout << endl;}void test_string4() {string s1("hello world");const string s2("nihao liangzai");//        s1.append(s2);
//        s1.append("hh");
//        s1 += s2;
//        s1 += "hh";
//        s1 += 'x';s1.push_back('v');cout << s1.c_str() << endl;}void test_string5() {string s1("hello world");const string s2("nihao liangzai");//        s1.insert(0, s2);
//        s1.insert(2, "hh");s1.insert(11, 5, 'x');cout << s1.c_str() << endl;}void test_string6() {string s1("hello world");const string s2("nihao liangzai");s1.erase();cout << s1.c_str() << endl;}void test_string7() {string s1("hello world");string s2("nihao liangzai");cout << s1.c_str() << endl;cout << s2.c_str() << endl;s1.swap(s2);cout << s1.c_str() << endl;cout << s2.c_str() << endl;}void test_string8() {string s1("hello world");const string s2("wo");size_t pos1 = s1.find(s2);size_t pos2 = s1.find("d");size_t pos3 = s1.find("f");size_t pos4 = s1.find('o');cout << pos1 << endl;cout << pos2 << endl;cout << (int) pos3 << endl;cout << (int) pos4 << endl;}void test_string9() {string s1("hello world");string s2(s1.substr(5, 2));const string s3("nihao liangzai");string s4(s3.substr(2, 5));cout << s2.c_str() << endl;cout << s4.c_str() << endl;}void test_string10() {string s1("hello world");const string s2("nihao liangzai");cout << s1.c_str() << endl;s1 = s2;cout << s1.c_str() << endl;s1 = "woshixp";cout << s1.c_str() << endl;s1 = '1';cout << s1.c_str() << endl;}void test_string11() {string s;cin >> s;cout << s << endl;}void test_string12() {string s1("111");string s2(s1);cout << s1 << endl;cout << s2 << endl;string s3;s3 = s2;cout << s3 << endl;}}

  • string.h文件

    //
// Created by 徐鹏 on 2023/11/29.
//#include <cstring>
#include <iostream>
#include <assert.h>
#include <vector>using namespace std;#ifndef DEMO_42_STRING_H
#define DEMO_42_STRING_H#endif  DEMO_42_STRING_Hnamespace xp {class string {public://构造函数string() : _str(new char[1]), _size(0), _capacity(0) {_str[0] = '\0';//空字符串也包含一个\0}string(const char *s);//拷贝构造函数string(const string &str);//字符串大小size_t size() const {return _size;}//总容量size_t capacity() const {return _capacity;}//string转char*const char *c_str() const {return _str;}//要求string类对象的容量调整为计划好的容量void reserve(size_t n);//将有效字符的个数改成n个void resize(size_t n);//清空字符串void clear() {_str[0] = '\0';_size = 0;//只清空数据，不清空容量}//判断字符串是不是空字符串bool empty() {return _size == 0;}//下标访问char &operator[](size_t pos);const char &operator[](size_t pos) const;char &at(size_t pos);const char &at(size_t pos) const;const char &back() const {return _str[_size - 1];}const char &front() const {return _str[0];}//迭代器typedef char *iterator;typedef const char *const_iterator;iterator begin() {return _str;}iterator end() {return _str + _size;}const_iterator begin() const {return _str;}const_iterator end() const {return _str + _size;}//尾插字符或者字符串void append(const string &str);void append(const char *s);//尾插字符或者字符串string &operator+=(const string &str);string &operator+=(const char *s);string &operator+=(char c);//尾插字符void push_back(char c);//从某个位置前插字符string &insert(size_t pos, const string &str);string &insert(size_t pos, const char *s);string &insert(size_t pos, size_t n, char c);//从某个位置向后删除n个字符string &erase(size_t pos = 0, size_t len = std::string::npos);//交换void swap(string &str);//从某个位置开始查找字符、字符串、string对象位置size_t find(const string &str, size_t pos = 0) const;size_t find(const char *s, size_t pos = 0) const;size_t find(char c, size_t pos = 0) const;//取子串string substr(size_t pos = 0, size_t len = npos) const;//赋值string &operator=(string str);string &operator=(const char *s);string &operator=(char c);~string();private:char *_str;size_t _capacity;size_t _size;static const size_t npos = -1;};//重载流插入ostream &operator<<(ostream &out, string &str);//重载流提取istream &operator>>(istream &in, string &str);void test_string1();void test_string2();void test_string3();void test_string4();void test_string5();void test_string6();void test_string7();void test_string8();void test_string9();void test_string10();void test_string11();void test_string12();}

OKOK，C++ STL容器之string类就到这里。如果你对Linux和C++也感兴趣的话，可以看看我的主页哦。下面是我的github主页，里面记录了我的学习代码和leetcode的一些题的题解，有兴趣的可以看看。

Xpccccc的github主页

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/714251.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

车辆维护和燃油里程跟踪器LubeLogger

车辆维护和燃油里程跟踪器LubeLogger

什么是 LubeLogger &#xff1f; LubeLogger 是一个自托管、开源、基于网络的车辆维护和燃油里程跟踪器。 LubeLogger 比较适合用来跟踪管理您的汽车的维修、保养、加油的历史记录&#xff0c;比用 Excel 强多了 官方提供了在线试用&#xff0c;可以使用用户名 test 和密码 123…
阅读更多...
机器学习-4

机器学习-4

文章目录 前言数组创建切片索引索引遍历切片编程练习 总结 前言 本篇将介绍数据处理 Numpy 库的一些基本使用技巧&#xff0c;主要内容包括 Numpy 数组的创建、切片与索引、基本运算、堆叠等等。 数组创建 在 Python 中创建数组有许多的方法&#xff0c;这里我们使用 Numpy 中…
阅读更多...
14.最长公共前缀

14.最长公共前缀

题目&#xff1a;编写一个函数来查找字符串数组中的最长公共前缀。 如果不存在公共前缀&#xff0c;返回空字符串""。 解题思路&#xff1a;横向扫描&#xff0c;依次遍历每个字符串&#xff0c;更新最长公共前缀。另一种方法是纵向扫描。纵向扫描时&#xff0c;从前…
阅读更多...
基于tomcat的JavaWeb实现

基于tomcat的JavaWeb实现

Tomcat服务器 免费&#xff0c;性能一般的服务器 安装配置 基于Java&#xff0c;故需要配置环境变量&#xff0c;新加系统路径JAVA_HOME&#xff0c;路径为jdk的主目录。 而后打开bin目录下的startup.bat文件出现如下窗口说明配置成功 idea继承tomcat服务器 使用java开发…
阅读更多...
Linux 之压缩与解压相关命令的基础用法

Linux 之压缩与解压相关命令的基础用法

目录 1、zip 与 unzip 2、gzip 命令 3、tar 命令 1、zip 与 unzip 在桌面新建一个文件和文件夹用于测试 在 test 目录下有一个 1.txt 文件 我们使用 zip 命令对其压缩 用法&#xff1a; zip 自定义压缩包名 被压缩文件路径位置 zip myon.zip 1.txt 因为我们这里就是在 …
阅读更多...
linux_day04

linux_day04

大纲&#xff1a;命令&#xff0c;vim&#xff0c;gcc&#xff0c;编译工具&#xff0c;生成代码&#xff0c;调试&#xff0c;库makefile&#xff0c;系统编程 文件系统&#xff1a;文件属性&#xff0c;文件内容&#xff0c;万物皆文件&#xff08;不在内存中的是文件&#…
阅读更多...
ProtoBuf 是什么？

ProtoBuf 是什么？

1. 序列化概念 序列化和反序列化 序列化&#xff1a;把对象转换为字节序列的过程称为对象的序列化。 反序列化&#xff1a;把字节序列恢复为对象的过程称为对象的反序列化。 什么情况下需要序列化 存储数据&#xff1a;当你想把的内存中的对象状态保存到⼀个⽂件中或者存到数…
阅读更多...
怎么压缩成mp4视频?

怎么压缩成mp4视频?

在数字化时代&#xff0c;视频已经成为我们日常生活中不可或缺的一部分。然而&#xff0c;有时候我们可能会遇到视频文件太大的问题&#xff0c;不便于传输、存储或分享。那么&#xff0c;如何将视频压缩成MP4格式&#xff0c;以减小文件大小呢&#xff1f;本文将为您介绍几种简…
阅读更多...
docker学习第一步：基于Linux安装docker！

docker学习第一步：基于Linux安装docker！

要求Linux下的CentOS 7.0 以上的版本 01、安装docker版本仓库 1、设置仓库 sudo yum install -y yum-utils device-mapper-persistent-data lvm2 2、稳定仓库 sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo 现在我也找了很…
阅读更多...
医学大数据|文献阅读|有关“胃癌+机器学习”的研究记录

医学大数据|文献阅读|有关“胃癌+机器学习”的研究记录

目录 1.基于32基因特征构建的机器学习模型可有效预测胃癌患者的预后和治疗反应 2.胃癌患者术后90天死亡率的机器学习风险预测模型 3.使用机器学习模型预测幽门螺杆菌根除患者胃癌患病风险 4.利用初始内窥镜检查和组织学结果进行个性化胃癌发病率预测 1.基于32基因特征构建的…
阅读更多...
查看网络连接的netstat

查看网络连接的netstat

netstat是一个监控TCP/IP网络的非常有用的工具&#xff0c;可以显示路由表、实际的网络连接&#xff0c;以及每一个网络接口设备的状态信息&#xff0c;可以让用户得知目前都有哪些网络连接正在运作。netstat用户显示与IP、TCP、UDP和ICMP协议相关的统计数据&#xff0c;一般用…
阅读更多...
【Vue3】PostCss 适配

【Vue3】PostCss 适配

px 固定的单位&#xff0c;不会进行自适应。rem r root font-size16px 1rem16px&#xff0c;但是需要手动进行单位的换算vw vh 相对于视口的尺寸&#xff0c;不同于百分比&#xff08;相对于父元素的尺寸&#xff09;375屏幕 1vw 3.75px 利用插件进行 px&#xff08;设计稿&…
阅读更多...
Docker自定义JDK镜像并拉取至阿里云镜像仓库全攻略

Docker自定义JDK镜像并拉取至阿里云镜像仓库全攻略

前言 随着容器技术的日益成熟&#xff0c;Docker已经成为现代软件开发和部署的标配工具。其中&#xff0c;自定义Docker镜像是满足特定项目需求的关键步骤。特别是在Java开发环境中&#xff0c;我们可能需要为不同的项目配置不同版本的JDK。这时&#xff0c;通过Docker自定义J…
阅读更多...
List＜Object＞集合对象属性拷贝工具类

List＜Object＞集合对象属性拷贝工具类

目录 问题现象&#xff1a; 问题分析&#xff1a; 解决方法&#xff1a; 问题现象&#xff1a; 最近在项目中经常会使用到BeanUtils工具类来作对象的属性字段拷贝&#xff0c;但如果应用到List集合的话就需要遍历去操作了&#xff0c;如下&#xff1a; 打印结果&#xff1a; …
阅读更多...
Cocos Creator 3.8.x 后效处理（前向渲染）

Cocos Creator 3.8.x 后效处理（前向渲染）

关于怎么开启后效效果我这里不再赘述&#xff0c;可以前往Cocos官方文档查看具体细节&#xff1a;后效处理官网 下面讲一下怎么自己定义一个后处理效果&#xff0c;想添加自己的后效处理的话只需要在postProcess节点下添加一个BlitScreen 组件即可&#xff0c;然后自己去添加自…
阅读更多...
Selenium基础：自动化你的网页交互！

Selenium基础：自动化你的网页交互！

在构建Python爬虫的过程中&#xff0c;你可能会遇到需要与网页进行交互的情况&#xff0c;比如填充表单、点击按钮等。这时&#xff0c;Selenium库就成了你的有力工具。Selenium是一个强大的工具&#xff0c;能够模拟用户在网页上的各种操作。本篇博客将向你介绍Selenium的基础…
阅读更多...
EdgeX Foundry 设备服务

EdgeX Foundry 设备服务

文章目录 1.设备服务2.设备配置文件3.设备资源4.资源属性&#xff08;Attributes&#xff09;5.资源属性&#xff08;Properties&#xff09;6.设备命令7.资源操作8.REST 命令端点9.推送事件 EdgeX Foundry # EdgeX Foundryhttps://iothub.org.cn/docs/edgex/ https://iothub.…
阅读更多...
好用的AI模型集合

好用的AI模型集合

AI-Chat 这个网站提供的AI-Chat 3.5和AI-Chat 4.0聊天机器人&#xff0c;每天都可以免费使用。 不管是学习、工作还是日常生活&#xff0c;都能给我们带来很大的帮助&#xff0c;效率真的可以说是翻倍了。我觉得&#xff0c;如果你想让自己的生活更加高效、更加有序&#xff0…
阅读更多...
WEB漏洞 SSRF简单入门实践

WEB漏洞 SSRF简单入门实践

一、漏洞原理 SSRF 服务端请求伪造 原理&#xff1a;在某些网站中提供了从其他服务器获取数据的功能&#xff0c;攻击者能通过构造恶意的URL参数&#xff0c;恶意利用后可作为代理攻击远程或本地的服务器。 二、SSRF的利用 1.对目标外网、内网进行端口扫描。 2.攻击内网或本地的…
阅读更多...
戏说c第二十六篇: 测试完备性衡量(代码覆盖率)

戏说c第二十六篇: 测试完备性衡量(代码覆盖率)

前言 师弟&#xff1a;“师兄&#xff0c;我又被鄙视了。说我的系统太差&#xff0c;测试不过关。” 我&#xff1a;“怎么说&#xff1f;” 师弟&#xff1a;“每次发布版本给程夏&#xff0c;都被她发现一些bug&#xff0c;太丢人了。师兄&#xff0c;有什么方法来衡量测试的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023