精通C++ STL（二）：string类的模拟实现

目录

string类各函数接口总览

默认成员函数

  构造函数

  拷贝构造函数

  赋值运算符重载函数

  析构函数

迭代器相关函数

  begin和end

容量和大小相关函数

  size和capacity

  reserve和resize

  empty

修改字符串相关函数

  push_back

  append

  operator+=

  insert

  erase

  clear

  swap

  c_str

访问字符串相关函数

  operator[ ]

  find和rfind

  find函数

  rfind函数

关系运算符重载函数

>>和<<运算符的重载以及getline函数

  >>运算符的重载

  <<运算符的重载 

    getline

string类各函数接口总览

namespace russ
{//模拟实现string类class string{public:typedef char* iterator;typedef const char* const_iterator;//默认成员函数string(const char* str = "");         //构造函数string(const string& s);              //拷贝构造函数string& operator=(const string& s);   //赋值运算符重载函数~string();                            //析构函数//迭代器相关函数iterator begin();iterator end();const_iterator begin()const;const_iterator end()const;//容量和大小相关函数size_t size();size_t capacity();void reserve(size_t n);void resize(size_t n, char ch = '\0');bool empty()const;//修改字符串相关函数void push_back(char ch);void append(const char* str);string& operator+=(char ch);string& operator+=(const char* str);string& insert(size_t pos, char ch);string& insert(size_t pos, const char* str);string& erase(size_t pos, size_t len);void clear();void swap(string& s);const char* c_str()const;//访问字符串相关函数char& operator[](size_t i);const char& operator[](size_t i)const;size_t find(char ch, size_t pos = 0)const;size_t find(const char* str, size_t pos = 0)const;size_t rfind(char ch, size_t pos = npos)const;size_t rfind(const char* str, size_t pos = 0)const;//关系运算符重载函数bool operator>(const string& s)const;bool operator>=(const string& s)const;bool operator<(const string& s)const;bool operator<=(const string& s)const;bool operator==(const string& s)const;bool operator!=(const string& s)const;private:char* _str;       //存储字符串size_t _size;     //记录字符串当前的有效长度size_t _capacity; //记录字符串当前的容量static const size_t npos; //静态成员变量（整型最大值）};const size_t string::npos = -1;//<<和>>运算符重载函数istream& operator>>(istream& in, string& s);ostream& operator<<(ostream& out, const string& s);istream& getline(istream& in, string& s);
}

注意：为了防止与标准库当中的string类产生命名冲突，模拟实现时需放在自己的命名空间当中。 

默认成员函数

  构造函数

        构造函数设置为缺省参数，若不传入参数，则默认构造为空字符串。字符串的初始大小和容量均设置为传入C字符串的长度（不包括’\0’）

//构造函数
string(const char* str = "")
{_size = strlen(str); //初始时，字符串大小设置为字符串长度_capacity = _size; //初始时，字符串容量设置为字符串长度_str = new char[_capacity + 1]; //为存储字符串开辟空间（多开一个用于存放'\0'）strcpy(_str, str); //将C字符串拷贝到已开好的空间
}

  拷贝构造函数

        模拟实现拷贝构造函数前，我们应该首先了解深浅拷贝：

浅拷贝（Shallow Copy）:

        当执行浅拷贝时，如果对象中包含指针变量，新旧对象将共享同一个指针所指向的内存空间。这意味着，如果其中一个对象修改了通过该指针所指向的数据，这种改变对于另一个对象也是可见的，因为他们实际上指向的是同一块内存。这对于只包含基本数据类型（如int、float、char等）的对象没有问题，但对于包含指针（指向动态分配的内存或其他复杂数据结构）的对象，则可能导致意料之外的行为。

深拷贝（Deep Copy）:

        深拷贝不仅会复制对象本身，还会递归地复制对象中指针所指向的所有内容，为源对象中指针所指向的每个对象分配新的内存空间。这样，即使在拷贝之后修改其中一个对象的数据，也不会影响到另一个对象。它们拥有各自独立的数据副本，确保了对象间的完全独立性。

        下面提供深拷贝的两种写法： 

传统写法：

步骤概述：

  1. 分配内存：在拷贝构造函数或赋值运算符中，首先为新对象（即拷贝对象）动态分配足够的内存来容纳源对象字符串的内容。这是通过new操作符完成的，例如：_str = new char[sourceSize]，其中sourceSize包括源字符串的长度加上结束符\0。

  2. 复制内容：接下来，逐字符地将源对象中的字符串内容复制到新分配的内存空间中。这可以通过循环或使用诸如strcpy之类的库函数来实现。例如：strcpy(_str, source->_str)。

  3. 复制其他成员变量：除了字符串内容外，还需要将源对象的其他成员变量（如_size和_capacity）复制到新对象中，保证新对象的这些状态信息与源对象一致。

  4. 处理源对象的特殊状况：在某些情况下（尤其是在赋值运算符重载中），可能还需要考虑源对象自身可能需要释放原有的内存，以防止内存泄漏。

//传统写法
string(const string& s):_str(new char[s._capacity + 1]), _size(0), _capacity(0)
{strcpy(_str, s._str);    //将s._str拷贝一份到_str_size = s._size;         //_size赋值_capacity = s._capacity; //_capacity赋值
}

 现代写法：

步骤概述：

  1. 构造临时对象（tmp）: 在构造函数内部，首先根据传入的C字符串参数，创建一个局部临时的string对象（tmp）。这里，我们会利用现有的构造函数（可能是接受C字符串参数的构造函数），确保深拷贝字符串内容。

  2. 交换数据: 然后，设计一个swap成员函数来交换两个string对象的数据成员（_str、_size、_capacity等）。在构造函数内部调用这个swap函数，将临时对象tmp的数据与正在构造的对象的数据交换。

  3. 临时对象自动销毁: 构造完成后，局部临时对象tmp会自动销毁，由于数据已被交换到新对象中，因此不会导致资源泄露。

//现代写法
string(const string& s):_str(nullptr), _size(0), _capacity(0)
{string tmp(s._str); //调用构造函数，构造出一个C字符串为s._str的对象swap(tmp); //交换这两个对象
}

  赋值运算符重载函数

        与拷贝构造函数类似，赋值运算符重载函数的模拟实现也涉及深浅拷贝问题，我们同样需要采用深拷贝。

        下面也提供深拷贝的两种写法：

传统写法：

步骤概述：

  1. 自我赋值检测：首先检查是否是自我赋值情况（this == &s），如果是，则直接返回*this，避免无用操作。
  2. 释放资源：释放当前对象（左值）已有的动态分配资源，比如释放_str指向的内存。
  3. 资源分配：根据源对象（右值，即赋值操作数）的大小，重新为左值对象分配必要的内存空间。
  4. 深拷贝内容：将源对象的字符串内容及其他数据成员逐个复制到新分配的内存中。
  5. 完成：返回左值引用（*this），允许链式赋值操作。
//传统写法
string& operator=(const string& s)
{if (this != &s) //防止自己给自己赋值{delete[] _str; //将原来_str指向的空间释放_str = new char[s._capacity + 1]; //重新申请一块空间strcpy(_str, s._str);    //将s._str拷贝一份到_str_size = s._size;         //_size赋值_capacity = s._capacity; //_capacity赋值}return *this; //返回左值（支持连续赋值）
}

  现代写法：

步骤概述：

  1. 参数传递右值: 函数参数列表中直接采用 string s，这里利用了C++的右值引用或移动语义（取决于实际编译器和标准的实现）。当传递一个临时对象或右值给此函数时，编译器会自动调用拷贝构造函数（在C++11之前）或移动构造函数（在C++11及以后），来高效地创建一个临时的string对象s，这个对象包含了右侧表达式的副本。

  2. 交换成员: 直接调用 swap 成员函数（或等效的交换操作）来交换当前对象（*this）与临时对象s的内部状态。这一步骤涉及到 _str（指向字符串的指针）、_ size（字符串长度）和_capacity（分配的内存容量）等数据成员的交换。交换操作避免了显式复制字符串内容，提升了效率，并且能有效处理自我赋值情况。

  3. 返回左值引用: 函数最后返回 *this，这是一个左值引用，这样做允许连续赋值操作，如 a = b = c = d;，这是赋值运算符重载常见的需求。

//现代写法1
string& operator=(string s) //编译器接收右值的时候自动调用拷贝构造函数
{swap(s); //交换这两个对象return *this; //返回左值（支持连续赋值）
}

        但这种写法无法避免自己给自己赋值，就算是自己给自己赋值这些操作也会进行，虽然操作之后对象中_str指向的字符串的内容不变，但是字符串存储的地址发生了改变，为了避免这种操作我们可以采用下面这种写法： 

步骤概述：

  1. 检查自我赋值: 首先检查当前对象 (this) 是否与被赋值对象 (s) 相同，这是为了避免不必要的自我赋值操作，如果相同则直接跳过后续步骤，避免无用的拷贝与交换。

  2. 构造临时对象: 使用传入的字符串对象 s 来构造一个临时对象 tmp。这里会调用拷贝构造函数完成深拷贝，确保 tmp 是一个与 s 完全同内容但独立的对象。

  3. 交换内容: 调用 swap 函数交换当前对象（即 *this 指向的对象）与临时对象 tmp 的内容。交换包括字符串指针 _str、大小 _size 和容量 _capacity 等数据成员。这一步骤高效且安全地更新了当前对象的状态，同时确保了资源的正确管理，因为原来的资源将在临时对象 tmp 销毁时被释放。

  4. 返回左值引用: 最后，函数返回 *this，这允许连续赋值操作，如 a = b = c;。

//现代写法2
string& operator=(const string& s)
{if (this != &s) //防止自己给自己赋值{string tmp(s); //用s拷贝构造出对象tmpswap(tmp); //交换这两个对象}return *this; //返回左值（支持连续赋值）
}

  析构函数

        string类的析构函数需要我们进行编写，因为每个string对象中的成员_str都指向堆区的一块空间，当对象销毁时堆区对应的空间并不会自动销毁，为了避免内存泄漏，我们需要使用delete手动释放堆区的空间。

步骤概述：

  1. 释放字符串内存: 通过delete[] _str;语句，释放_str指针所指向的动态分配的字符数组（字符串）的内存空间。这里使用了数组形式的delete[]，因为_str指向的是一块连续内存，由new[]分配而来，确保正确匹配。

  2. 置空指针: 执行_ str = nullptr;，将字符串指针置为nullptr（C++11后推荐替代NULL的写法），防止野指针错误。这一步骤可以避免在对象析构后，指针成为悬挂指针，若不小心被再次访问时引发运行时错误或崩溃。

  3. 清零大小和容量: 设置_ size = 0;和_capacity = 0;，将对象的大小和容量成员变量重置为0。这一步是可选的，主要是为了增加代码的清晰性和未来可能的调试便利，确保对象状态明确地被重置为初始状态，尽管在对象即将销毁后这些值并无实际意义。

//析构函数
~string()
{delete[] _str;  //释放_str指向的空间_str = nullptr; //及时置空，防止非法访问_size = 0;      //大小置0_capacity = 0;  //容量置0
}

迭代器相关函数

        string类中的迭代器实际上就是字符指针，只是给字符指针起了一个别名叫iterator而已。

typedef char* iterator;
typedef const char* const_iterator;

  begin和end

        begin函数的作用就是返回字符串中第一个字符的地址：

iterator begin()
{return _str; //返回字符串中第一个字符的地址
}
const_iterator begin()const
{return _str; //返回字符串中第一个字符的const地址
}

        end函数的作用就是返回字符串中最后一个字符的后一个字符的地址（即’\0’的地址）：

iterator end()
{return _str + _size; //返回字符串中最后一个字符的后一个字符的地址
}
const_iterator end()const
{return _str + _size; //返回字符串中最后一个字符的后一个字符的const地址
}

容量和大小相关函数

        因为string类的成员变量是私有的，我们并不能直接对其进行访问，所以string类设置了size和capacity这两个成员函数，用于获取string对象的大小和容量。

  size和capacity

        size函数用于获取字符串当前的有效长度（不包括’\0’）。

//大小
size_t size()const
{return _size; //返回字符串当前的有效长度
}

        capacity函数用于获取字符串当前的容量。

//容量
size_t capacity()const
{return _capacity; //返回字符串当前的容量
}

  reserve和resize

        reserve和resize这两个函数的执行规则一定要区分清楚。

reserve函数目的与规则：

  1. 扩容：** 当请求的容量n大于当前的_ capacity时，函数会将容量扩展到至少为n或略大于n的某个值，确保有足够的空间存储未来的字符而不必立即再次扩容。

  2. 不变：** 若请求的容量n小于或等于当前的_ capacity，函数不做任何操作，因为已有足够的容量满足需求。

//改变容量，大小不变
void reserve(size_t n)
{if (n > _capacity) //当n大于对象当前容量时才需执行操作{char* tmp = new char[n + 1]; //多开一个空间用于存放'\0'strncpy(tmp, _str, _size + 1); //将对象原本的C字符串拷贝过来（包括'\0'）delete[] _str; //释放对象原本的空间_str = tmp; //将新开辟的空间交给_str_capacity = n; //容量跟着改变}
}

 注意：代码中使用strncpy进行拷贝对象C字符串而不是strcpy，是为了防止对象的C字符串中含有有效字符’\0’而无法拷贝（strcpy拷贝到第一个’\0’就结束拷贝了）。

resize函数目的与规则：

  1. 扩容并填充：当请求的大小n大于当前的_size时，函数会将字符串的大小调整到n，新增的部分用指定字符ch填充（默认为\0）。
  2. 缩减：若请求的大小n小于当前的_size，函数会直接将字符串的大小缩减到n，超出部分的字符被移除（但实际实现中，通常并不物理移除，而是通过更新size来隐式实现“截断”）。
//改变大小
void resize(size_t n, char ch = '\0')
{if (n <= _size) //n小于当前size{_size = n; //将size调整为n_str[_size] = '\0'; //在size个字符后放上'\0'}else //n大于当前的size{if (n > _capacity) //判断是否需要扩容{reserve(n); //扩容}for (size_t i = _size; i < n; i++) //将size扩大到n，扩大的字符为ch{_str[i] = ch;}_size = n; //size更新_str[_size] = '\0'; //字符串后面放上'\0'}
}

  empty

        empty是string的判空函数，我们可以调用strcmp函数来实现，strcmp函数是用于比较两个字符串大小的函数，当两个字符串相等时返回0。

//判空
bool empty()
{return strcmp(_str, "") == 0;
}

修改字符串相关函数

  push_back

        push_back函数的作用就是在当前字符串的后面尾插上一个字符，尾插之前首先需要判断是否需要增容，若需要，则调用reserve函数进行增容，然后再尾插字符，注意尾插完字符后需要在该字符的后方设置上’\0’，否则打印字符串的时候会出现非法访问，因为尾插的字符后方不一定就是’\0’。

//尾插字符
void push_back(char ch)
{if (_size == _capacity) //判断是否需要增容{reserve(_capacity == 0 ? 4 : _capacity * 2); //将容量扩大为原来的两倍}_str[_size] = ch; //将字符尾插到字符串_str[_size + 1] = '\0'; //字符串后面放上'\0'_size++; //字符串的大小加一
}

注：增容时以二倍的形式进行增容，避免多次调用push_back函数时每次都需要调用reserve函数。 

        实现push_back还可以直接复用下面即将实现的insert函数。 

//尾插字符
void push_back(char ch)
{insert(_size, ch); //在字符串末尾插入字符ch
}

  append

        append函数的作用是在当前字符串的后面尾插一个字符串，尾插前需要判断当前字符串的空间能否容纳下尾插后的字符串，若不能，则需要先进行增容，然后再将待尾插的字符串尾插到对象的后方，因为待尾插的字符串后方自身带有’\0’，所以我们无需再在后方设置’\0’。

//尾插字符串
void append(const char* str)
{size_t len = _size + strlen(str); //尾插str后字符串的大小（不包括'\0'）if (len > _capacity) //判断是否需要增容{reserve(len); //增容}strcpy(_str + _size, str); //将str尾插到字符串后面_size = len; //字符串大小改变
}

        实现append函数也可以直接复用下面即将实现的insert函数。

//尾插字符串
void append(const char* str)
{insert(_size, str); //在字符串末尾插入字符串str
}

  operator+=

        +=运算符的重载是为了实现字符串与字符、字符串与字符串之间能够直接使用+=运算符进行尾插。
        +=运算符实现字符串与字符之间的尾插直接调用push_back函数或append函数即可。

//+=运算符重载
string& operator+=(char ch)
{push_back(ch); //尾插字符串return *this; //返回左值（支持连续+=）
}//+=运算符重载
string& operator+=(const char* str)
{append(str); //尾插字符串return *this; //返回左值（支持连续+=）
}

  insert

        insert函数的作用是在字符串的任意位置插入字符或是字符串。

insert函数在字符串类中插入单个字符的基本逻辑。具体步骤如下：

  1. 合法性检查：首先确保给定的插入位置pos是合法的，意味着它应该在字符串当前有效长度的范围内。这一步通常通过断言或者条件语句来完成，以确保不会发生越界访问。

  2. 容量检查：在实际插入字符之前，需要检查当前字符串对象是否有足够的容量来容纳新增的字符。如果现有的容量不足以存放插入字符后的字符串，程序将调用reserve方法来增加字符串的容量。这个过程可能会使字符串的容量加倍，以减少频繁扩容带来的效率损失。

  3. 字符移动：为了在指定位置pos插入字符，需要将pos位置及之后的所有字符向后移动一个位置，为新字符腾出空间。这个过程通常涉及一个循环，逐个将字符向后复制。

  4. 字符插入：在腾出的空间中插入新的字符。这一步通常直接通过指针或迭代器操作完成，将字符写入到已经为空的指定位置。

  5. 更新状态：完成字符插入后，需要更新字符串的实际大小（即有效字符数量），并确保字符串末尾有终止符\0，以保持C风格字符串的完整性。

//在pos位置插入字符
string& insert(size_t pos, char ch)
{assert(pos <= _size); //检测下标的合法性if (_size == _capacity) //判断是否需要增容{reserve(_capacity == 0 ? 4 : _capacity * 2); //将容量扩大为原来的两倍}char* end = _str + _size;//将pos位置及其之后的字符向后挪动一位while (end >= _str + pos){*(end + 1) = *(end);end--;}_str[pos] = ch; //pos位置放上指定字符_size++; //size更新return *this;
}

insert函数用于插入字符串的基本逻辑。具体步骤如下：

  1. 合法性检查：在尝试插入字符串之前，首先验证提供的插入位置pos是否合法。这意味着pos必须在字符串现有长度范围内，以确保不会发生数组越界错误。通常，这通过一个断言或条件语句来实现。

  2. 容量评估：接下来，程序会检查当前字符串是否有足够的容量来容纳插入新字符串后的结果。如果当前的容量不足以满足需求，程序会调用reserve方法来预先分配足够的内存。这个过程可能涉及将现有容量至少增加到足以容纳新字符串后的总长度，通常采取倍增策略以优化性能。

  3. 字符移动：为了在指定位置pos插入字符串，需要将pos位置及其之后的所有字符向右移动len个位置，这里len是待插入字符串的长度。这一操作通常通过一个循环实现，逐个将字符复制到它们的新位置。

  4. 字符串插入：在腾出的空间中，使用类似strncpy的函数将待插入的字符串复制进去。注意，直接使用strcpy是不合适的，因为它会连同源字符串的终止符\0一起复制，导致字符串提前结束。正确做法是明确指定复制的字符数。

  5. 更新状态：插入完成后，需要更新字符串的大小（有效字符数量）以及确保字符串末尾有正确的终止符\0。此外，如果_size和_capacity是类的成员变量，它们也需要相应地更新以反映最新的字符串状态。

//在pos位置插入字符串
string& insert(size_t pos, const char* str)
{assert(pos <= _size); //检测下标的合法性size_t len = strlen(str); //计算需要插入的字符串的长度（不含'\0'）if (len + _size > _capacity) //判断是否需要增容{reserve(len + _size); //增容}char* end = _str + _size;//将pos位置及其之后的字符向后挪动len位while (end >= _str + pos){*(end + len) = *(end);end--;}strncpy(_str + pos, str, len); //pos位置开始放上指定字符串_size += len; //size更新return *this;
}

注意：插入字符串的时候使用strncpy，不能使用strcpy，否则会将待插入的字符串后面的’\0’也插入到字符串中。 

  erase

        erase函数的作用是删除字符串任意位置开始的n个字符。

判断pos的合法性

        在执行删除操作前，首先需要确保给定的索引pos是有效的，即它应该在字符串的大小范围内（0 到 size()-1 之间）。这一步骤通常通过断言或条件语句来实现，以确保不会引发数组越界错误。

删除操作的两种情况

1. 删除从pos位置到字符串末尾的所有字符

  • 操作方式：如果需要删除从pos位置直到字符串末尾的所有字符，实际上只需要调整字符串的_size成员变量（表示字符串的有效长度），使其等于pos。这是因为字符串对象通常在其分配的内存末尾已经有一个终止符\0，因此不需要额外添加。通过这种方式，从pos位置开始的所有字符虽然还在内存中，但已经被视作无效，不会影响字符串的正常行为。

2. 删除pos位置开始的特定数量的字符

  • 操作方式：当只需要删除从pos开始的特定数量的字符时，操作稍微复杂一些。首先，同样需要确认pos加上要删除的字符数len不会超过当前字符串的有效长度。之后，可以使用如strcpy这样的函数，将从pos+len位置开始的有效字符覆盖到pos位置上，以此来实现删除效果。由于字符串末尾原本就有\0，所以覆盖操作后字符串仍然是有效格式化的，无需额外添加\0。

更新字符串状态

        无论是哪种情况，在删除操作后，都需要更新字符串的_size成员变量，以反映删除操作后的实际有效字符数量。同时，如果删除操作导致大量空间不再使用，某些实现可能会考虑调用类似于shrink_to_fit的方法来释放未使用的内存，但这通常不是删除操作的直接部分，而是作为一个可选的优化步骤。

//删除pos位置开始的len个字符
string& erase(size_t pos, size_t len = npos)
{assert(pos < _size); //检测下标的合法性size_t n = _size - pos; //pos位置及其后面的有效字符总数if (len >= n) //说明pos位置及其后面的字符都被删除{_size = pos; //size更新_str[_size] = '\0'; //字符串后面放上'\0'}else //说明pos位置及其后方的有效字符需要保留一部分{strcpy(_str + pos, _str + pos + len); //用需要保留的有效字符覆盖需要删除的有效字符_size -= len; //size更新}return *this;
}

 

  clear

        clear函数用于将对象中存储的字符串置空，实现时直接将对象的_size置空，然后在字符串后面放上’\0’即可。

//清空字符串
void clear()
{_size = 0; //size置空_str[_size] = '\0'; //字符串后面放上'\0'
}

  swap

        swap函数用于交换两个对象的数据，直接调用库里的swap模板函数将对象的各个成员变量进行交换即可。

//交换两个对象的数据
void swap(string& s)
{//调用库里的swap::swap(_str, s._str); //交换两个对象的C字符串::swap(_size, s._size); //交换两个对象的大小::swap(_capacity, s._capacity); //交换两个对象的容量
}

注意：若想让编译器优先在全局范围寻找某函数，则需要在该函数前面加上“ :: ”（作用域限定符）。 

  c_str

        c_str函数用于获取对象C类型的字符串，实现时直接返回对象的成员变量_str即可。

//返回C类型的字符串
const char* c_str()const
{return _str;
}

访问字符串相关函数

  operator[ ]

        [ ]运算符的重载是为了让string对象能像C字符串一样，通过[ ] +下标的方式获取字符串对应位置的字符。

读写访问的重载

char& operator[](size_t i) 
{assert(i < _size); // 确保下标合法return _str[i]; // 返回字符的引用，允许修改
}

        这段代码重载了[]运算符，它接收一个size_t类型的下标i作为参数，并返回该下标处字符的引用。这样，用户就可以通过s[i]的形式读取或修改字符串中的字符，如s[0] = 'A';。但是，这样的实现没有对const对象提供保护，也就是说，即使对象是常量，也能通过此重载修改其内容，这通常是不期望的行为。

只读访问的重载

        为了支持对const对象的安全访问，即允许读取但禁止修改，需要提供一个额外的重载版本：

//[]运算符重载（只读）
const char& operator[](size_t i)const
{assert(i < _size); //检测下标的合法性return _str[i]; //返回对应字符
}

        这个版本通过添加const关键字在函数声明的最后，表明该函数适用于const对象，并且返回值是一个指向const char的引用，这意味着即使尝试通过s[i]对字符串内容进行修改，也会因赋值给常量引用而导致编译错误，从而保护了数据的不可变性。

 

  find和rfind

        find函数和rfind函数都是用于在字符串中查找一个字符或是字符串，find函数和rfind函数分别用于正向查找和反向查找，即从字符串开头开始向后查找和从字符串末尾开始向前查找。

  find函数

查找单个字符

size_t find(char ch, size_t pos = 0)
{assert(pos < _size); // 确保pos是合法的，即在字符串长度范围内for (size_t i = pos; i < _size; ++i) // 从pos位置开始遍历字符串{if (_str[i] == ch) // 如果找到匹配的字符{return i; // 返回字符在字符串中的索引}}return npos; // 没有找到匹配字符，返回npos（表示未找到）
}

这段代码通过线性搜索的方式从指定位置pos开始在字符串中查找字符ch。如果找到，返回其在字符串中的索引；否则，返回npos。

查找子字符串

size_t find(const char* str, size_t pos = 0)
{assert(pos < _size); // 同样确保pos的合法性const char* ret = strstr(_str + pos, str); // 使用strstr标准库函数从_pos位置开始查找子字符串strif (ret) // strstr返回非空指针表示找到了子字符串{return ret - _str; // 计算并返回子字符串在原字符串中的起始位置索引}else // 没有找到{return npos; // 返回npos表示未找到}
}

        此版本的find函数利用了C标准库中的strstr函数来查找子字符串。strstr函数直接返回子字符串在原字符串中的起始地址，如果未找到则返回NULL。找到子字符串后，通过计算地址差得到子字符串在原字符串中的起始索引并返回。如果没有找到，同样返回npos。

  rfind函数

        实现rfind函数时，我们可以考虑复用已经写好了的两个find函数，但rfind函数是从后先前找，所以我们需要将对象的C字符串逆置一下。若是查找字符串，还需将待查找的字符串逆置一下，然后调用find函数进行查找，但注意传入find函数的pos以及从find函数接收到的pos都需要镜像对称一下。

反向查找单个字符 这个过程包括几个关键步骤：

  1. 创建临时对象：为了避免原字符串被修改，首先通过拷贝构造函数创建了一个临时字符串tmp。
  2. 逆置字符串：利用reverse函数将tmp的字符顺序颠倒，以便从后向前查找。
  3. 调整查找起始位置：如果给定的pos超出字符串有效长度，将其调整为字符串末尾。接着，计算出相对于逆置后字符串的起始查找位置。
  4. 调用正向查找：在逆置后的字符串tmp上使用find函数查找字符。
  5. 返回结果：如果找到匹配字符，计算其在原始字符串中的位置并返回；如果未找到，返回npos。
//反向查找第一个匹配的字符
size_t rfind(char ch, size_t pos = npos)
{string tmp(*this); //拷贝构造对象tmpreverse(tmp.begin(), tmp.end()); //调用reverse逆置对象tmp的C字符串if (pos >= _size) //所给pos大于字符串有效长度{pos = _size - 1; //重新设置pos为字符串最后一个字符的下标}pos = _size - 1 - pos; //将pos改为镜像对称后的位置size_t ret = tmp.find(ch, pos); //复用find函数if (ret != npos)return _size - 1 - ret; //找到了，返回ret镜像对称后的位置elsereturn npos; //没找到，返回npos
}

反向查找子字符串 除了上述步骤外，还额外包括：

  1. 逆置待查找字符串：因为是在逆置后的字符串中查找，所以待查找的子字符串也需要被逆置。
  2. 内存管理：为逆置的子字符串分配新的内存，并确保在查找结束后正确释放这块内存。
  3. 结果调整：找到子字符串的最后一个字符位置后，需要进一步调整计算，找到其在原字符串中的起始位置，即返回_size - ret - len。
//反向查找第一个匹配的字符串
size_t rfind(const char* str, size_t pos = npos)
{string tmp(*this); //拷贝构造对象tmpreverse(tmp.begin(), tmp.end()); //调用reverse逆置对象tmp的C字符串size_t len = strlen(str); //待查找的字符串的长度char* arr = new char[len + 1]; //开辟arr字符串（用于拷贝str字符串）strcpy(arr, str); //拷贝str给arrsize_t left = 0, right = len - 1; //设置左右指针//逆置字符串arrwhile (left < right){::swap(arr[left], arr[right]);left++;right--;}if (pos >= _size) //所给pos大于字符串有效长度{pos = _size - 1; //重新设置pos为字符串最后一个字符的下标}pos = _size - 1 - pos; //将pos改为镜像对称后的位置size_t ret = tmp.find(arr, pos); //复用find函数delete[] arr; //销毁arr指向的空间，避免内存泄漏if (ret != npos)return _size - ret - len; //找到了，返回ret镜像对称后再调整的位置elsereturn npos; //没找到，返回npos
}

关系运算符重载函数

        关系运算符有 >、>=、<、<=、==、!= 这六个，但是对于C++中任意一个类的关系运算符重载，我们均只需重载其中的两个，剩下的四个关系运算符可以通过复用已经重载好了的两个关系运算符来实现。

        对于string类，我们可以选择只重载 > 和 == 这两个关系运算符。

//>运算符重载
bool operator>(const string& s)const
{return strcmp(_str, s._str) > 0;
}//==运算符重载
bool operator==(const string& s)const
{return strcmp(_str, s._str) == 0;
}

        剩下的四个关系运算符的重载，就可以通过复用这两个已经重载好了的关系运算符来实现了。 

//>=运算符重载
bool operator>=(const string& s)const
{return (*this > s) || (*this == s);
}//<运算符重载
bool operator<(const string& s)const
{return !(*this >= s);
}//<=运算符重载
bool operator<=(const string& s)const
{return !(*this > s);
}//!=运算符重载
bool operator!=(const string& s)const
{return !(*this == s);
}

 

>>和<<运算符的重载以及getline函数

  >>运算符的重载

        重载>>运算符是为了让string对象能够像内置类型一样使用>>运算符直接输入。输入前我们需要先将对象的C字符串置空，然后从标准输入流读取字符，直到读取到’ ‘或是’\n’便停止读取。

//>>运算符的重载
istream& operator>>(istream& in, string& s)
{s.clear(); //清空字符串char ch = in.get(); //读取一个字符while (ch != ' '&&ch != '\n') //当读取到的字符不是空格或'\n'的时候继续读取{s += ch; //将读取到的字符尾插到字符串后面ch = in.get(); //继续读取字符}return in; //支持连续输入
}

  <<运算符的重载 

        重载<<运算符是为了让string对象能够像内置类型一样使用<<运算符直接输出打印。实现时我们可以直接使用范围for对对象进行遍历即可。

//<<运算符的重载
ostream& operator<<(ostream& out, const string& s)
{//使用范围for遍历字符串并输出for (auto e : s){cout << e;}return out; //支持连续输出
}

    getline

        getline函数用于读取一行含有空格的字符串。实现时于>>运算符的重载基本相同，只是当读取到’\n’的时候才停止读取字符。

//读取一行含有空格的字符串
istream& getline(istream& in, string& s)
{s.clear(); //清空字符串char ch = in.get(); //读取一个字符while (ch != '\n') //当读取到的字符不是'\n'的时候继续读取{s += ch; //将读取到的字符尾插到字符串后面ch = in.get(); //继续读取字符}return in;
}

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

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

相关文章

跨平台之用VisualStudio开发APK嵌入OpenCV（一）

跨平台之用VisualStudio开发APK嵌入OpenCV（一）

序 本篇是杂谈以及准备工作&#xff08;此处应无掌声&#xff09; 暂时不管iOS&#xff08;因为开发hello world都要年费&#xff09; 软件&#xff1a; Visual Studio 2019&#xff08;含Android SDK和NDK编译器等&#xff09; OpenCV 这是一个女仆级的系列文章&#xf…
阅读更多...
探索数据结构：单链表的实践和应用

探索数据结构：单链表的实践和应用

&#x1f511;&#x1f511;博客主页&#xff1a;阿客不是客 &#x1f353;&#x1f353;系列专栏&#xff1a;渐入佳境之数据结构与算法 欢迎来到泊舟小课堂 &#x1f618;博客制作不易欢迎各位&#x1f44d;点赞⭐收藏➕关注 ​ 一、前言 前面我们学习了数据结构中的顺序表&…
阅读更多...
扭蛋机小程序开发，数字化发展对行业带来的优势

扭蛋机小程序开发，数字化发展对行业带来的优势

随着科技的不断进步和大众对娱乐消费需求的提高&#xff0c;线上扭蛋机得到了快速发展&#xff0c;市场规模不断扩大。线上扭蛋机是基于淘宝的小程序&#xff0c;它以电商的模式让消费者进行虚拟扭蛋&#xff0c;获得各类商品&#xff0c;扭蛋机小程序中的商品包括玩具、IP周边…
阅读更多...
线段（线性dp）

线段（线性dp）

题目链接&#xff1a;[TJOI2007] 线段 - 洛谷 思路&#xff1a; f[i][0]表示走完第i行且停在第i行的左端点最少用的步数 f[i][1]同理&#xff0c;停在右端点的最少步数。 那么转移就很简单了&#xff0c;走完当前行且停到左端点&#xff0c;那么一定是从右端点过来的&#x…
阅读更多...
算法课程笔记——高斯消元

算法课程笔记——高斯消元

算法课程笔记——高斯消元 先乘后除&#xff0c;精度 #include<bist/stdc.h>usingnamespacestd; #definemaxn 2800intn,m,x,ans; bitset<N>a[N]; voidgauss(){ intcnt0; for(inti1;i<n;i){ intmaxxcnt1; for(intji1;j<n;j){ …
阅读更多...
2024年上半年软件系统架构师考试【回忆版】

2024年上半年软件系统架构师考试【回忆版】

文章目录 考试时间考试地点综合知识案例分析1、微服务架构的优点和缺点2、质量属性的6个要素3、分布式锁 Redis的缺点4、MongoDB 存储矢量图的优势 论文回忆版论文一、论单元测试的设计与应用论文二、论大数据模型的设计与应用论文三、论模型驱动的架构设计及应用论文四、论云自…
阅读更多...
Android端 可使用Yolov5训练 路标识别

Android端 可使用Yolov5训练 路标识别

相信大家对于路标识别&#xff0c;红绿灯识别&#xff0c;图形识别opencv中也是一件烦人的事情&#xff0c;其参数是及其受到现实环境因素的影响的&#xff0c;那么今天我就给大家推荐一种方式&#xff0c;缺点是周期长&#xff0c;但其优点是如果训练效果好久对于环境的各种变…
阅读更多...
django在线考试系统-计算机毕业设计源码78268

django在线考试系统-计算机毕业设计源码78268

摘 要 本论文主要论述了如何使用python语言、Django框架开发一个在线考试系统&#xff0c;本系统将严格按照软件开发流程&#xff0c;进行各个阶段的工作&#xff0c;面向对象编程思想进行项目开发。在引言中&#xff0c;作者将论述该系统的当前背景以及系统开发的目的&#xf…
阅读更多...
阿里云产品DTU评测报告（三）

阿里云产品DTU评测报告（三）

这阿里云产品DTU评测报告&#xff08;三&#xff09; 连接物联网平台创建项目 连接物联网平台 在开始连接物联网平台之前&#xff0c;首先需要下载开发工具Visual Studio Code 开发工具&#xff0c;开发工具可以到https://code.visualstudio.com/ 去查找下载&#xff0c;下载完…
阅读更多...
安泰电子：功率放大器的选择方法有哪些

安泰电子：功率放大器的选择方法有哪些

选择适合的功率放大器是实现电子系统中的关键步骤之一。以下是一些选择功率放大器的常用方法和考虑因素&#xff1a; 功率需求&#xff1a;首先确定你的系统需要多大的功率输出。功率输出需求通常由被驱动设备的功率要求决定。计算出所需功率后&#xff0c;选择一个具有适当功率…
阅读更多...
GaussDB数据库的备份与恢复

GaussDB数据库的备份与恢复

1.逻辑备份-gs_dump gs_dump是一款用于导出数据库相关信息的工具&#xff0c;支持导出完整一致的数据库对象&#xff08;数据库、模式、表、视图等&#xff09;数据&#xff0c;同时不影响用户对数据库的正常访问。 备份sql语句 gs_dump是openGauss用于导出数据库相关信息的工…
阅读更多...
Redis使用Set实现点赞功能

Redis使用Set实现点赞功能

文章目录 set 数据类型介绍不排序实现排序实现 set 数据类型介绍 Redis中的set类型是一组无序的字符串值。 set通过其独特的数据结构和丰富的命令提供了在存储和处理集合元素方面的一些非常有用的功能。下面列出了主要的set类型命令&#xff1a; SADD key member1 [member2]&a…
阅读更多...
不可错过的数据存储指南：JVS物联网平台存储策略详解

不可错过的数据存储指南：JVS物联网平台存储策略详解

在物联网时代&#xff0c;数据的采集、存储和分析成为了关键环节。随着设备点位不断生成大量数据&#xff0c;如何高效地管理和保存这些数据&#xff0c;同时考虑存储成本和后续的数据分析价值&#xff0c;成为了亟待解决的问题。JVS物联网平台提供了灵活多样的存储策略&#x…
阅读更多...
【BI 可视化插件】怎么做？ 手把手教你实现

【BI 可视化插件】怎么做？ 手把手教你实现

背景 对于现在的用户来说&#xff0c;插件已经成为一个熟悉的概念。无论是在使用软件、 IDE 还是浏览器时&#xff0c;插件都是为了在原有产品基础上提供更多更便利的操作。在 BI 领域&#xff0c;图表的丰富性和对接各种场景的自定义是最吸引人的特点。虽然市面上现有的 BI 软…
阅读更多...
常见web安全漏洞

常见web安全漏洞

一、信息泄露 概念 信息泄露是由于Web服务器或应用程序没有正确处理一些特殊请求&#xff0c;泄露Web服务器的一些敏感信 息&#xff0c;如用户名、密码、源代码、服务器信息、配置信息等。 造成信息泄露主要的三个原因: ①Web服务器配置存在问题&#xff0c;导致一些系统…
阅读更多...
爬山算法教程（个人总结版）

爬山算法教程（个人总结版）

背景与简介 爬山算法&#xff08;Hill Climbing Algorithm&#xff09;是一种用于解决优化问题的启发式搜索方法。它是一种局部搜索算法&#xff0c;通过不断尝试从当前解出发&#xff0c;在其邻域内寻找更优的解&#xff0c;直到无法找到更优解为止。该算法得名于其类似于登山…
阅读更多...
油猴（Tampermonkey）如何实现网站的自动化操作

油猴（Tampermonkey）如何实现网站的自动化操作

1. 安装油猴插件&#xff1a;首先&#xff0c;在你使用的浏览器上安装油猴插件。油猴支持多种浏览器&#xff0c;如Chrome、Firefox等。你可以在对应的插件商店中搜索并安装油猴插件。 2. 创建用户脚本&#xff1a;打开油猴插件的管理界面&#xff0c;点击"新建脚本"…
阅读更多...
外贸电商数据分析实战指南

外贸电商数据分析实战指南

亮数据浏览器https://www.bright.cn/proxy-types/?utm_sourcebrand&utm_campaignbrnd-mkt_cn_csdn_yingjie 引言 在行业竞争激烈、市场变化快速的跨境电商领域&#xff0c;数据采集可以帮助企业深入了解客户需求和行为&#xff0c;分析市场趋势和竞争情况&#xff0c;从而…
阅读更多...
kyuubi/spark3的catalog 多个数据源配置

kyuubi/spark3的catalog 多个数据源配置

在使用kyuubi 的时候&#xff0c;有多个集群&#xff0c;老集群上是hive2,新集群hive3 ,想通过一个网关访问多个集群&#xff0c;或者通过jdbc访问mysql&#xff0c;oracle的数据&#xff0c;这样不用来回数据导入导出。spark 支持跨库访问数据&#xff0c;在spark 中提供两种方…
阅读更多...
QtXlsx库编译使用

QtXlsx库编译使用

文章目录 一、前言二、Windows编译使用2.1 用法①&#xff1a;QtXlsx作为Qt的附加模块2.1.1 检验是否安装Perl2.1.2 下载并解压QtXlsx源码2.1.3 MinGW 64-bit安装模块2.1.4 测试 2.2 用法②&#xff1a;直接使用源码 三、Linus编译使用3.1、安装Qt5开发软件包&#xff1a;qtbas…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023