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;

   //范围for
   for (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;

    //append
    s1.append(1, 'x');
    s1.append("hh");
    s1.append(s2);

    //push_back
    s2.push_back('x');

    //insert
    s1.insert(0, "xx");
    s1.insert(0, 2, 'x');


    //erase
    s1.erase(0, 4);

    //replace
    s1.replace(0, 4, "x");

    //swap
    s1.swap(s2);

    //c_str
    const char *str = s1.c_str();

    //data
    const char *str1 = s1.data();

    string s3("hello world");

    //copy
    char buffer[20] = {0};
    size_t length = s3.copy(buffer, 8, 0);
    buffer[length] = '\0';
    cout << buffer << endl;

    //find
    size_t found1 = s3.find('d', 3);
    cout << found1 << endl;

    size_t found2 = s3.find('f');
    //测试是不是用int表示的-1
    int test = found2;
    cout << found2 << endl;
    cout << test << endl;

    //rfind
    size_t found3 = s3.rfind("ll", 5);
    cout << found3 << endl;

    string s4("hello gun qnd world haha no --skas wcl cb ");

    //find_first_of
    size_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;

    //substr
    string 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;

    //swap
    cout << 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");
    //getline
    getline(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 one
 value_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];//多开一个空间存\0
        strcpy(_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最后等于0
        while (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最后等于0
        while (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_H

namespace 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主页

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

springBoot整合Redis（二、RedisTemplate操作Redis）

springBoot整合Redis（二、RedisTemplate操作Redis）

Spring-data-redis是spring大家族的一部分&#xff0c;提供了在srping应用中通过简单的配置访问redis服务&#xff0c;对reids底层开发包(Jedis, JRedis, and RJC)进行了高度封装&#xff0c;RedisTemplate提供了redis各种操作、异常处理及序列化&#xff0c;支持发布订阅&…
阅读更多...
支持向量机算法（带你了解原理 实践）

支持向量机算法（带你了解原理 实践）

引言 在机器学习和数据科学中&#xff0c;分类问题是一种常见的任务。支持向量机&#xff08;Support Vector Machine, SVM&#xff09;是一种广泛使用的分类算法&#xff0c;因其出色的性能和高效的计算效率而受到广泛关注。本文将深入探讨支持向量机算法的原理、特点、应用&…
阅读更多...
Unity（第二十一部）动画的基础了解（感觉不了解其实也行）

Unity（第二十一部）动画的基础了解（感觉不了解其实也行）

1、动画组件老的是Animations 动画视频Play Automatically 是否自动播放Animate Physics 驱动方式&#xff0c;勾选后是物理驱动Culling Type 剔除方式 默认总是动画化就会一直执行下去&#xff0c;第二个是基于渲染播放&#xff08;离开镜头后不执行&#xff09;&#xff0c; …
阅读更多...
蓝桥杯倒计时 43天 - 前缀和，单调栈

蓝桥杯倒计时 43天 - 前缀和，单调栈

最大数组和 算法思路&#xff1a;利用前缀和化简 for 循环将 n^2 简化成 nn&#xff0c;以空间换时间。枚举每个 m&#xff0c;m是删除最小两个数&#xff0c;那k-m就是删除最大数&#xff0c;m<k&#xff0c;求和最大的值。暴力就是枚举 m-O(n)&#xff0c;计算前 n-(k-m)的…
阅读更多...
Revit-二开之创建TextNote-(1)

Revit-二开之创建TextNote-(1)

Revit二开之创建TextNote TextNode在Revit注释模块中&#xff0c;具体位置如图所示 图中是Revit2018版本 【Revit中的使用】 Revit 中的操作是点击上图中的按钮在平面视图中点击任意放置放置就行&#xff0c; 在属性中可以修改文字 代码实现 创建TextNode ExternalComm…
阅读更多...
有趣的CSS - 故障字体效果

有趣的CSS - 故障字体效果

大家好&#xff0c;我是 Just&#xff0c;这里是「设计师工作日常」&#xff0c;今天分享的是用 css 实现一个404故障字体效果。 《有趣的css》系列最新实例通过公众号「设计师工作日常」发布。 目录 整体效果核心代码html 代码css 部分代码 完整代码如下html 页面css 样式页面…
阅读更多...
2024年全国乙卷高考理科数学备考：十年选择题真题和解析

2024年全国乙卷高考理科数学备考：十年选择题真题和解析

今天距离2024年高考还有三个多月的时间&#xff0c;今天我们来看一下2014~2023年全国乙卷高考理科数学的选择题&#xff0c;从过去十年的真题中随机抽取5道题&#xff0c;并且提供解析。后附六分成长独家制作的在线练习集&#xff0c;科学、高效地反复刷这些真题&#xff0c;吃…
阅读更多...
Linux上搭建并使用ffmpeg（Java）

Linux上搭建并使用ffmpeg（Java）

关于MacOs和Windows系统上使用ffmpeg就不多说了&#xff0c;有很多相关文章&#xff0c;今天给大家分享一个在Linux环境下使用Java语言来使用ffmpeg 一、首先去官网下载一个Linux对应的ffmpeg包 1、进入ffmpeg官网&#xff1a;官网 2、点击左侧导航栏Download 3、选择Linux对…
阅读更多...
什么是人才储备？如何做人才储备？

什么是人才储备？如何做人才储备？

很多小伙伴都会有企业面试被拒的情况&#xff0c;然后HR会告诉你&#xff0c;虽然没有录用你&#xff0c;但是你进入了他们的人才储备库&#xff0c;那么这个储备库有什么作用和特点呢&#xff1f;我们如何应用人才测评系统完善人才储备库呢&#xff1f; 人才储备一般有以下三…
阅读更多...
软考重点题解析-基础知识

软考重点题解析-基础知识

1.加密技术&#xff1a;分为对称加密技术&#xff1a;文件的加密和解密使用相同的密钥 和 非对称加密技术&#xff1a;加密和解密不同的密钥&#xff0c;分别是公开密钥和私有密钥。 例题&#xff1a;若A,B两人分别在认证机构&#xff08;CA&#xff09;M,N处获得证书&…
阅读更多...
liunx安装jdk、redis、nginx

liunx安装jdk、redis、nginx

jdk安装 下载jdk,解压。 sudo tar -zxvf /usr/local/jdk-8u321-linux-x64.tar.gz -C /usr/local/ 在/etc/profile文件中的&#xff0c;我们只需要编辑一下&#xff0c;在文件的最后加上java变量的有关配置&#xff08;其他内容不要动&#xff09;。 export JAVA_HOME/usr/l…
阅读更多...
云轴科技ZStack与华东师范大学共建产教融合基地

云轴科技ZStack与华东师范大学共建产教融合基地

近日&#xff0c;上海云轴信息科技有限公司&#xff08;云轴科技ZStack&#xff09;与华东师范大学上海国际首席技术官学院宣布&#xff0c;共同打造产教融合基地&#xff0c;以促进人才培养与产业需求的全方位融合。这一举措旨在深化教育与产业的合作关系&#xff0c;培养更多…
阅读更多...
Maven编译报processing instruction can not have PITarget with reserveld xml name

Maven编译报processing instruction can not have PITarget with reserveld xml name

在java项目中&#xff0c;平时我们会执行mvn clean package命令来编译我们的java项目&#xff0c;可是博主今天执行编译时突然报了 processing instruction can not have PITarget with reserveld xml name 这个错&#xff0c;网上也说法不一&#xff0c;但是绝大绝大部分是因…
阅读更多...
Yii2中如何使用scenario场景，使rules按不同运用进行字段验证

Yii2中如何使用scenario场景，使rules按不同运用进行字段验证

Yii2中如何使用scenario场景&#xff0c;使rules按不同运用进行字段验证 当创建news新闻form表单时&#xff1a; 添加新闻的时候执行create动作。 必填字段&#xff1a;title-标题&#xff0c;picture-图片&#xff0c;description-描述。 这时候在model里News.php下rules规则…
阅读更多...
2024年2月最新微信域名检测拦截接口源码

2024年2月最新微信域名检测拦截接口源码

这段PHP代码用于检测指定域名列表中的域名是否被封。代码首先定义了一个包含待检测域名的数组 $domainList&#xff0c;然后遍历该数组&#xff0c;对每个域名发送HTTP请求并检查响应内容以判断域名是否被封。 具体步骤如下&#xff1a; 1. 定义待检测的域名列表。 2. 遍历域名…
阅读更多...
Linux服务：Nginx反向代理与负载均衡

Linux服务：Nginx反向代理与负载均衡

一、Nginx反向代理 1、什么是反向代理&#xff1f; 代理分为两类&#xff0c;正向代理和反向代理。 ①正向代理&#xff1a;帮助用户访问服务器&#xff0c;缓存服务器内容。 ②反向代理&#xff1a;代理服务器处理用户的请求&#xff0c;决定转发请求给谁处理负载均衡的作…
阅读更多...
Node.js基础---Express中间件

Node.js基础---Express中间件

1. 概念 1.什么是中间件 中间件(Middleware)&#xff0c;特指业务流程的中间处理环节 2. Express 中间件的调用流程 当一个请求到达 Express 的服务器后&#xff0c;可以连续调用多个中间件&#xff0c;从而对这次请求进行预处理 3. Express 中间件格式 Express 的中间件&…
阅读更多...
DB-GPT：大模型 + 数据库，全流程自动化

DB-GPT：大模型 + 数据库，全流程自动化

DB-GPT&#xff1a;大模型 数据库&#xff0c;全流程自动化 提出背景DB-GPT 结构具体问题与解法背景分析对比其他工具DB-GPT系统设计 提出背景 论文&#xff1a;https://arxiv.org/pdf/2312.17449.pdf 代码&#xff1a;https://github.com/eosphoros-ai/DB-GPT 本文介绍了D…
阅读更多...
Laravel Octane 和 Swoole 协程的使用分析

Laravel Octane 和 Swoole 协程的使用分析

之前在工作中使用 Laravel Octane 的 concurrently 处理并发时&#xff0c;发现在队列和定时任务中不会触发并发效果。经过分析&#xff0c;作了如下猜测&#xff1a;队列和定时任务都属于一个独立的进程&#xff0c;与 Octane 服务无关&#xff0c;而 Octane concurrently 恰恰…
阅读更多...
msvcr120.dll丢失的解决办法，分享解决文件丢失的问题

msvcr120.dll丢失的解决办法，分享解决文件丢失的问题

msvcr120.dll文件丢失有这三种方法可以解决&#xff0c;学会这三种方法的任何一种&#xff0c;以后再出现dll文件丢失的情况都能很好地解决&#xff0c;第一种方法最为简单。先给大家说说msvcr120.dll文件为什么会丢失&#xff1f;丢失的原因是什么&#xff1f; 一.msvcr120.d…
阅读更多...
最新文章

Copyright @ 2022~2023