文章目录
1.string的模拟实现需要注意问题
1.内存管理:std::string 类是一个动态分配内存的容器,模拟实现需要正确地处理内存的分配和释放。你可以使用动态数组、指针或其他数据结构来模拟动态内存的管理。
2.字符串操作:模拟实现需要支持字符串的拼接、插入、删除、查找等操作,以及其他字符串处理的函数(如 size()、substr()、find() 等)。
3.异常处理:std::string 在一些情况下可能会引发异常,例如内存分配失败或访问越界等。模拟实现需要考虑如何正确处理异常情况,以确保程序的稳定性和安全性。
4.内存拷贝:std::string 采用了深拷贝(deep copy)语义,即在复制时会复制整个字符串的内容。模拟实现需要正确地处理内存的拷贝,以避免悬空指针和资源泄漏等问题。
5.迭代器支持:std::string 支持迭代器用于访问字符串的内容,模拟实现需要提供相应的迭代器支持。
6.性能优化:std::string 的标准实现通常会对性能进行优化,例如采用了扩容策略来减少频繁的内存分配。模拟实现可以考虑一些优化策略,提高性能和效率。
7.边界条件:在进行模拟实现时,需要特别注意边界条件和特殊情况,确保实现的正确性和鲁棒性。
8.完整性:std::string 类是一个非常复杂的数据类型,模拟实现时需要尽可能完整地实现其功能和接口。
2.经典的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共用同一块内存空间,在释放时同一块空间被释放多次而引起程序崩溃,这种拷贝方式,称为浅拷贝。
什么是浅拷贝
浅拷贝:也称位拷贝,编译器只是将对象中的值拷贝过来。如果对象中管理资源,最后就会导致多个对象共享同一份资源,当一个对象销毁时就会将该资源释放掉,而此时另一些对象不知道该资源已经被释放,以为还有效,所以当继续对资源进项操作时,就会发生发生了访问违规。其实我们可以采用深拷贝解决浅拷贝问题,即:每个对象都有一份独立的资源,不要和其他对象共享。
什么是深拷贝
深拷贝是指在进行对象拷贝时,不仅复制对象本身的成员变量,还复制对象所指向的动态分配的资源(例如堆内存)到新的对象中。这意味着拷贝后的对象和原对象拥有独立的资源副本,彼此之间不会相互影响。
当对象中含有动态分配的资源,如指针指向的内存块,或者其他动态分配的资源(文件句柄、网络连接等),进行深拷贝是非常重要的,以避免多个对象共享同一块资源导致释放重复、悬挂指针等问题。
如果一个类中涉及到资源的管理,其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。
3.写时拷贝
“写时拷贝”(Copy on Write,简称为 COW)是一种优化技术,通常应用于操作系统的内存管理或数据结构中,目的是节省内存和提高性能。在 COW 中,当多个对象共享同一份资源时,只有在某个对象试图修改资源内容时,才会进行实际的拷贝操作,否则所有对象共享相同的原始资源。这样可以避免在修改前对整个资源进行拷贝,节省了内存和执行时间。
COW 最常见的应用是在操作系统中的进程管理和内存分配。当一个进程 fork(复制)自身时,通常会采用 COW 机制。在 fork 时,子进程会与父进程共享相同的内存空间,即物理页框。只有当子进程或父进程中的一个试图修改其中的内容时,操作系统才会执行实际的拷贝,将要修改的页框内容复制到新的页框中,使得两个进程的内存空间独立开来。这样,父子进程可以共享大部分资源,而无需进行大规模的内存拷贝,从而提高了 fork 操作的效率。
在编程语言或数据结构中,写实拷贝也可以用于优化数据结构的复制操作。例如,在某些容器类(如字符串、数组、向量等)中,当多个对象共享相同的数据时,只有在其中一个对象试图修改数据时,才会进行实际的拷贝操作,确保各个对象之间的数据相互独立。
需要注意的是,COW 并不是适用于所有情况的通用优化技术,它的有效性取决于具体的应用场景。在某些情况下,COW 可以带来显著的性能优势,但在其他情况下,可能会增加复杂性和开销。因此,在实现时需要仔细权衡利弊,根据实际需求选择合适的优化策略。
其实写时拷贝就是一种拖延症,是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数:用来记录资源使用者的个数。在构造时,将资源的计数给成1,每增加一个对象使用该资源,就给计数增加1,当某个对象被销毁时,先给该计数减1,然后再检查是否需要释放资源,如果计数为1,说明该对象时资源的最后一个使用者,将该资源释放;否则就不能释放,因为还有其他对象在使用该资源。
一个常见的例子是字符串的写实拷贝。
在许多编程语言中,字符串通常是不可变的(immutable),即一旦创建后,就无法修改其内容。在这种情况下,当多个变量或对象引用同一个字符串时,如果其中一个变量试图修改字符串的内容,就需要创建一个新的字符串对象,而不是直接在原始字符串上进行修改。
假设有两个变量 str1 和 str2 都指向相同的字符串 “Hello”:
std::string str1 = "Hello";
std::string str2 = str1;
在这里,str2 是通过拷贝构造函数从 str1 创建的。在传统的拷贝情况下,这将导致整个字符串 “Hello” 的拷贝,即两个变量 str1 和 str2 都指向不同的内存地址,但其内容是相同的。
但是,写时拷贝可以优化这种情况。在写时拷贝中,当 str2 拷贝 str1 时,并不会立即创建一个新的字符串副本。而是让 str2 和 str1 共享同一个底层的字符串数据。只有当其中一个字符串试图修改其内容时,才会触发实际的拷贝操作。
例如,如果现在对 str2 进行修改操作:
str2[0] = 'h'; // 修改第一个字符为小写 'h'
在写时拷贝机制下,会创建一个新的字符串 “hello”,然后 str2 的内容指向新的字符串,而 str1 的内容保持不变。这样,两个变量 str1 和 str2 仍然共享相同的底层数据,但它们的内容已经不再相同。
写时拷贝可以有效地节省内存,尤其在字符串长期共享的情况下,避免了不必要的内存复制。但在其他情况下,可能会增加复杂性和开销。因此,在实现时需要仔细权衡利弊,根据实际需求选择合适的优化策略。
4.传统版与现代版写法的String类(参考)
传统版
class 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;
};
现代版
class String
{
public:
String(const char* str = "")
{
if (nullptr == str)
{
assert(false);
return;
}
_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;
};
5.string类的模拟实现
常见和常用部分模拟实现
5.1命名空间string类的成员变量定义
namespace mystring //[1]
{
class string
{
public:
//...
private:
size_t _capacity; //[2]
size_t _size;
char* _str;
public:
// const static 语法特殊处理
// 直接可以当成定义初始化
const static size_t npos = -1; //[3]
}
[1] 重新定义一个命名空间,防止和库中的string类重定义。
[2] 模拟实现string类,需要一个成员变量_size来表示字符串的长度(不包含’\0’),一个_capacity来表示申请的内存空间的大小
[3] 初始化npos,static静态变量需要在类中声明,类外定义
5.2 构造函数
string(const char* str = "") //[1]
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];//+1是因为要保存'\0'
strcpy(_str, str);
}
[1] const char* str = “”
是构造函数的默认参数。
默认参数是在函数声明中为函数参数提供默认值的一种特性,它允许在调用函数时,如果没有提供相应的参数值,就会使用默认值作为参数的值。
空串""
后有隐式的 ‘\0’ 结尾,空串做缺省值strlen值为0,开1字符空间用于存储’\0’
5.3 拷贝构造函数
传统写法:
string(const string& s)
:_str(new char[s._capacity+1])
, _size(s._size)
, _capacity(s._capacity)
{
strcpy(_str, s._str);
}
现代写法:
void Swap(string& tmp)
{
std::swap(_str, tmp._str);
std::swap(_size, tmp._size);
std::swap(_capacity, tmp._capacity);
}
string(const string& s)
:_str(nullptr) //[1]
, _size(0)
, _capacity(0)
{
string tmp(s._str);
Swap(tmp); //this->swap(tmp);
}
[1] 必须将_str初始化为nullptr;否则交换后,析构临时对象时会释放随机指针而导致程序崩溃。
传统写法中,拷贝构造函数采用传统的深拷贝方式。它首先分配了与源对象(s)相同大小的内存空间(包括结尾的空字符),然后将源对象的内容复制到新分配的内存空间中。
这种实现方式确保了新创建的对象和源对象具有独立的内存空间,即它们不共享资源。这样,当一个对象修改其内容时,不会影响到另一个对象,从而保证了对象之间的数据隔离。
而在现代写法代码中,拷贝构造函数使用了 C++11 引入的移动语义。它先创建了一个名为 tmp 的临时对象,并使用 s._str 初始化了这个临时对象。接着,通过调用成员函数 Swap(tmp) 将当前对象的成员和临时对象的成员进行交换。
Swap 函数的实现会使当前对象的成员指向临时对象的内存空间,而临时对象的成员指向了当前对象之前的内存空间。这样一来,原来的资源被交换了,临时对象会在析构时释放当前对象原来的资源,而当前对象则拥有了 s 对象的资源。
这种实现方式通过避免了不必要的内存拷贝,从而提高了拷贝构造函数的性能。在 tmp 作为临时对象被析构时,它会自动释放原来 s 对象的资源,因此没有内存泄漏。
两种实现方式都是有效的拷贝构造函数,但第二种实现利用了移动语义,可以在拷贝对象时避免不必要的内存复制,提高性能。在 C++11 及以上版本中,推荐使用第二种实现方式。
5.4 赋值重载(=)
传统写法:
string& operator=(const string &s){
if(this != &s) //[1]
{
char *tmp = new char[s._capacity+1]; //[2]
memcpy(tmp, s._str, s._size+1);
delete[] _str; //[3]
_str = tmp;
_size = str._size;
_capacity = str._capacity;
}
return *this; //[4]
}
现代写法:
string& operator=(string s) //[5]
{
Swap(s);
return *this;
}
[1] 比较两个对象的指针,避免出现自己给自己赋值而出错的情况。
[2] 先开新空间拷贝数据,再释放旧空间;防止出现开空间失败而造成原数据丢失的情况。
[3] 必须释放旧空间,防止内存泄漏;匹配使用new T[N]和delete[] 。
[4] 返回调用对象的引用,使运算符支持连续赋值。
[5] 参数是一个string对象,调用函数时先用实参拷贝构造形参。
传统写法:传统做法直接进行数据拷贝。
现代写法:复用拷贝构造函数;在函数内用目标对象拷贝构造临时对象,与调用对象做浅交换,
函数返回前析构临时对象(原调用对象数据),而调用对象得到拷贝数据。
5.5 析构函数,迭代器和易实现的成员函数
析构函数
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
这里的析构函数通过 delete[] 操作释放 _str 指向的动态分配的字符数组(字符串内存),然后将 _str 置为 nullptr,同时将 _size 和 _capacity 设置为 0。这样确保对象被销毁时内存得到正确的释放,防止内存泄漏。
注意:匹配使用new T[N]和delete[],否则程序运行崩溃。
迭代器
typedef char *iterator; //[1]
typedef const char *const_iterator; //[2]
iterator begin(){
return _str;
}
const_iterator begin() const{
return _str;
}
iterator end(){
return _str+_size; //[3]
}
const_iterator end() const{
return _str+_size;
}
[1] 对于string类,迭代器实际就是原生指针。
[2] const对象也要提供迭代器访问方法,const对象返回const指针。
[3] begin()返回首元素的地址;end()返回尾元素下一个位置的地址。
c_str()
const char* c_str() const
{
return _str;
}
c_str()函数用于返回指向存储字符串的字符数组的指针。
size()
size_t size() const
{
return _size;
}
size()函数用于返回字符串的大小,即字符串中实际存储的字符个数,返回类型为 size_t。这里的 _size 成员变量表示实际存储的字符个数,因此直接返回 _size 即可。
capacity()
size_t capacity() const
{
return _capacity;
}
capacity()函数用于返回字符串的容量,即字符串中当前分配的内存空间大小,返回类型为 size_t。这里的 _capacity 成员变量表示当前的容量,因此直接返回 _capacity 即可。
operator[ ]
char& operator[](size_t pos)
{
assert(pos < _size); //[1]
return _str[pos];
}
[1] 一定要检查pos的范围,防止越界访问。
[]
操作符重载函数,用于访问字符串中指定位置 pos
处的字符。
返回类型是 char&
,表示返回的是可修改字符的引用,允许通过该引用修改字符内容。
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
operator[](size_t pos) const
是 const版本的下标操作符重载函数。
函数返回类型为 const char&
,表示返回的是常量字符的引用,即不允许通过该引用修改字符内容。这是为了确保字符串的不可变性。
5.6 容量操作(reserve,resize,clear)
reserve(扩容)
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void reserve(size_t n)
:这是 std::string 类中的 reserve 函数的声明,表示该函数将预留 n 个字符的内存空间。n 是传入的参数,表示需要预留的字符个数。
if (n > _capacity)
:这里通过比较传入的 n 和当前字符串的容量 _capacity,来判断是否需要增加字符串的容量。只有当需要预留的字符个数 n 大于当前容量 _capacity 时,才需要进行内存扩展操作。
char* tmp = new char[n + 1];
:如果需要增加容量,首先创建一个新的字符数组 tmp,长度为 n + 1,即预留的字符个数加上结尾的空字符。这里将字符串的容量设置为 n,是为了预留额外的一个位置来存储结尾的空字符。
strcpy(tmp, _str);
:将原来的字符串内容复制到新创建的字符数组 tmp 中。
delete[] _str;
:释放原来字符串 _str 指向的动态分配的字符数组,即释放原来的内存空间。
_str = tmp;
:将原来的指针 _str 指向新的字符数组 tmp,这样字符串的内存空间得到了扩展。
_capacity = n;
:将 _capacity 更新为新的容量 n。
这样,当需要预留更多的内存空间时,reserve 函数会创建一个新的字符数组,并将原来的字符串内容复制到新数组中,然后释放原来的内存空间,并将 _str 指向新的字符数组,更新容量 _capacity 为新的预留值 n。
resize(改容)
void resize(size_t n, char ch = '\0')
{
if (n > _size)
{
// 插入数据
reserve(n);
for (size_t i = _size; i < n; ++i)
{
_str[i] = ch;
}
_str[n] = '\0';
_size = n;
}
else
{
// 删除数据
_str[n] = '\0';
_size = n;
}
}
resize 函数用于改变字符串的大小,即增加或减少字符串中的字符个数。这里简单解释一下这个函数的实现:
void resize(size_t n, char ch = '\0')
:这是 std::string 类中的 resize 函数的声明,表示该函数将改变字符串的大小为 n。n 是传入的参数,表示新的字符串大小。参数 ch 是可选的,默认值为 ‘\0’,用于在扩展字符串大小时填充新增的字符。
if (n > _size)
:在这个条件分支中,判断需要增加字符串大小的情况。如果传入的新大小 n 大于当前字符串大小 _size,表示需要在字符串末尾添加新的字符。
reserve(n);
:首先调用 reserve 函数来预留足够的内存空间,确保字符串有足够的容量来容纳新增的字符。
for (size_t i = _size; i < n; ++i)
:然后在字符串中新增的位置,从当前字符串的大小 _size 开始循环添加字符。这里将新增的字符都设置为 ch,即传入的第二个参数。
_str[n] = '\0';
:在循环结束后,将字符串的新末尾字符设置为空字符 ‘\0’,保证新的字符串正确终止。
_size = n;
:最后将字符串的大小 _size 更新为新的大小 n。
else
:在这个条件分支中,处理需要减小字符串大小的情况。如果传入的新大小 n 小于当前字符串大小 _size,表示需要删除字符串中多余的字符。
_str[n] = '\0';
:将字符串的新末尾字符设置为空字符 ‘\0’,保证新的字符串正确终止。
_size = n;
:最后将字符串的大小 _size 更新为新的大小 n。
这样,resize 函数可以根据传入的大小 n,扩展或缩小字符串的大小,并在必要时添加或删除字符。
clear(清空)
void clear()
{
_str[0] = '\0';
_size = 0;
}
clear 函数用于清空字符串,即将字符串内容全部置为空,并将实际大小 _size 设为 0,将字符数组的第一个字符(即字符串的起始位置)设置为空字符 ‘\0’,以将字符串内容清空。
5.7 增(insert、append、push_back、+=重载)
insert
insert的模拟实现主要实现字符和字符串插入两种
字符插入
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
// 满了就扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
--end;
}
_str[pos] = ch;
++_size;
return *this;
}
insert 函数在字符串中指定位置插入一个字符。这里简单解释一下这个函数的实现:
string& insert(size_t pos, char ch)
:这是 std::string 类中的 insert 函数的声明,表示该函数将在指定位置 pos 插入字符 ch。pos 是传入的参数,表示插入位置的索引;ch 是要插入的字符。
assert(pos <= _size);
:使用 assert 断言来确保插入位置 pos 不超过字符串的实际大小 _size。如果断言失败(pos 大于 _size),则会触发断言失败错误,帮助调试找到错误的位置。
if (_size == _capacity)
:检查当前字符串是否已满(即 _size 等于 _capacity)。如果字符串已满,则需要扩容,以确保有足够的容量来插入新字符。这里使用 reserve 函数扩容,使字符串有足够的容量来容纳新字符。
size_t end = _size + 1;
:在插入字符前,先将字符串的末尾位置(实际字符个数 _size 后面)向后移动一个位置,为新字符留出空间。这样做是为了将插入位置 pos 之后的字符后移。
while (end > pos)
:通过一个循环,将插入位置 pos 之后的字符依次向后移动一个位置。
_str[pos] = ch;
:将字符 ch 插入到指定的插入位置 pos。
++_size;
:插入字符后,将字符串的实际大小 _size 增加 1。
return *this;
:返回当前 std::string 对象的引用,以支持链式调用。
字符串插入
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)
{
_str[end] = _str[end - len];
--end;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}
与上一个 insert 函数相比,这里的参数 str 是一个 C-style 字符串(const char*),而不是一个单个字符。函数的功能是在字符串中指定位置插入一个 C-style 字符串。现在来解释这个函数的实现:
string& insert(size_t pos, const char* str)
:这是 std::string 类中的 insert 函数的声明,表示该函数将在指定位置 pos 插入一个 C-style 字符串 str。pos 是传入的参数,表示插入位置的索引;str 是要插入的 C-style 字符串。
assert(pos <= _size);
:使用 assert 断言来确保插入位置 pos 不超过字符串的实际大小 _size。如果断言失败(pos 大于 _size),则会触发断言失败错误,帮助调试找到错误的位置。
size_t len = strlen(str);
:计算要插入的 C-style 字符串 str 的长度,即字符个数。
if (_size + len > _capacity)
:检查插入后的字符串大小是否超过当前的容量 _capacity,如果超过,则需要扩容,以确保有足够的容量来容纳插入的字符串。
reserve(_size + len);
:调用 reserve 函数来扩容,保证有足够的容量来容纳插入的字符串。
size_t end = _size + len;
:在插入字符串前,先将字符串的末尾位置(实际字符个数 _size 后面)向后移动 len 个位置,为新字符串留出空间。
while (end >= pos + len)
:通过一个循环,将插入位置 pos 之后的字符依次向后移动 len 个位置,为新字符串的插入留出空间。
strncpy(_str + pos, str, len);
:使用 strncpy 函数将 C-style 字符串 str 复制到指定的插入位置 pos,并且只复制 len 个字符。
_size += len;
:插入字符串后,将字符串的实际大小 _size 增加 len,以反映插入后的新大小。
return *this;:返回当前 std::string 对象的引用,以支持链式调用。
append
void append(const char* str)
{
size_t len = strlen(str);
// 满了就扩容
if (_size + len > _capacity)
{
reserve(_size+len);
}
strcpy(_str + _size, str);
//strcat(_str, str); 需要找\0,效率低
_size += len;
}
append 函数用于在字符串末尾添加一个 字符串。现在来解释这个函数的实现:
void append(const char* str)
:这是 std::string 类中的 append 函数的声明,表示该函数将在字符串末尾添加一个 C-style 字符串 str。str 是传入的参数,表示要添加的 C-style 字符串。
size_t len = strlen(str);
:计算要添加的 C-style 字符串 str 的长度,即字符个数。
if (_size + len > _capacity)
:检查添加后的字符串大小是否超过当前的容量 _capacity,如果超过,则需要扩容,以确保有足够的容量来容纳添加的字符串。
reserve(_size + len);
:调用 reserve 函数来扩容,保证有足够的容量来容纳添加的字符串。
strcpy(_str + _size, str);
:使用 strcpy 函数将 C-style 字符串 str 复制到字符串末尾,即从 _str 的实际字符个数 _size 处开始复制。
_size += len;
:添加字符串后,将字符串的实际大小 _size 增加 len,以反映添加后的新大小。
这样,append 函数将 字符串 str 添加到字符串末尾,并且在必要时进行了内存扩容。
当然你可以对insert函数复用
void append(const char* str)
{
insert(_size, str);
}
push_back
void push_back(char ch)
{
// 满了就扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
push_back 函数用于在字符串末尾添加一个字符。现在来解释这个函数的实现:
void push_back(char ch)
:这是 std::string 类中的 push_back 函数的声明,表示该函数将在字符串末尾添加一个字符 ch。ch 是传入的参数,表示要添加的字符。
if (_size == _capacity)
:检查当前字符串是否已满(即 _size 等于 _capacity)。如果字符串已满,则需要扩容,以确保有足够的容量来容纳新增的字符。这里使用 reserve 函数扩容,使字符串有足够的容量来容纳新字符。
_str[_size] = ch;
:将字符 ch 添加到字符串末尾,即在 _str 的实际字符个数 _size 处添加字符。
++_size;
:字符串的实际大小 _size 增加 1,以反映添加后的新大小。
_str[_size] = '\0';
:在字符串末尾添加一个空字符 ‘\0’,以保证新的字符串正确终止。
这样,push_back 函数将字符 ch 添加到字符串末尾,并在必要时进行了内存扩容。
同样的,push_back 函数你也可以对insert函数复用
void push_back(char ch)
{
insert(_size, ch);
}
+=重载
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
operator+= 运算符重载用于在现有字符串后追加字符或 C-style 字符串。现在来解释这个函数的实现:
string& operator+=(char ch)
:这是 operator+= 运算符重载的第一个版本,表示该运算符将在字符串末尾追加一个字符 ch。在这个版本中,直接调用了 push_back 函数,将字符 ch 添加到字符串末尾。
string& operator+=(const char* str)
:这是 operator+= 运算符重载的第二个版本,表示该运算符将在字符串末尾追加一个 C-style 字符串 str。在这个版本中,直接调用了 append 函数,将 C-style 字符串 str 添加到字符串末尾。
在两个版本的实现中,都返回当前 std::string 对象的引用,以支持链式调用。
5.8 删(erase)
void erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
if (len == npos || pos + len >= _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}
erase 函数用于从字符串中删除指定位置开始的一定长度的字符。现在来解释这个函数的实现:
void erase(size_t pos, size_t len = npos)
:这是 std::string 类中的 erase 函数的声明,表示该函数将从指定位置 pos 开始删除一定长度 len 的字符。pos 是传入的参数,表示删除的起始位置的索引;len 是要删除的字符个数,默认值为 npos,表示删除从起始位置开始的所有字符。
assert(pos < _size);
:使用 assert 断言来确保删除的起始位置 pos 不超过字符串的实际大小 _size。如果断言失败(pos 大于等于 _size),则会触发断言失败错误,帮助调试找到错误的位置。
if (len == npos || pos + len >= _size)
:检查是否要删除从起始位置 pos 开始的所有字符(即 len 等于 npos),或者是否要删除的字符个数超过字符串末尾(即 pos + len 大于等于 _size)。如果是其中一种情况,表示要删除从 pos 开始的所有字符或从 pos 开始直到末尾的所有字符。
_str[pos] = '\0'; 和 _size = pos;
:在上述情况下,将字符串从位置 pos 处截断,即将字符数组的第 pos 个字符设置为空字符 ‘\0’,并更新字符串的实际大小 _size 为 pos,以反映删除后的新大小。
else
:如果要删除的字符个数小于字符串末尾的字符个数,则需要将后面的字符向前移动。
strcpy(_str + pos, _str + pos + len);
:将从位置 pos + len 开始的字符复制到位置 pos,覆盖掉要删除的字符。
_size -= len;
:删除字符后,将字符串的实际大小 _size 减去 len,以反映删除后的新大小。
5.9 查(find)
size_t find(char ch, size_t pos = 0) const
{
assert(pos < _size);
for (size_t i = pos; i < _size; ++i)
{
if (ch == _str[i])
{
return i;
}
}
return npos;
}
find 函数用于在字符串中查找指定字符或子串,并返回其位置。现在来解释这个函数的实现:
size_t find(char ch, size_t pos = 0) const
:这是 std::string 类中的 find 函数的第一个版本,表示该函数将在字符串中从位置 pos 开始查找字符 ch。pos 是传入的参数,表示查找的起始位置的索引,默认值为 0,表示从字符串的开头开始查找。
assert(pos < _size);
:使用 assert 断言来确保查找的起始位置 pos 不超过字符串的实际大小 _size。如果断言失败(pos 大于等于 _size),则会触发断言失败错误,帮助调试找到错误的位置。
在这个版本中,使用了简单的循环遍历,从位置 pos 开始遍历字符串,查找是否存在字符 ch。如果找到了,就返回该字符的位置索引;如果未找到,则返回 npos。
size_t find(const char* sub, size_t pos = 0) const
{
assert(sub);
assert(pos < _size);
const char* ptr = strstr(_str + pos, sub);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
size_t find(const char* sub, size_t pos = 0) const
:这是 std::string 类中的 find 函数的第二个版本,表示该函数将在字符串中从位置 pos 开始查找子串 sub。sub 是传入的参数,表示要查找的子串;pos 是传入的参数,表示查找的起始位置的索引,默认值为 0,表示从字符串的开头开始查找。
assert(sub);
:使用 assert 断言来确保传入的子串 sub 不为空指针。如果断言失败(sub 为空指针),则会触发断言失败错误,帮助调试找到错误的位置。
assert(pos < _size);
:同样,使用 assert 断言来确保查找的起始位置 pos 不超过字符串的实际大小 _size。在这个版本中,使用 strstr 函数在字符串中查找子串 sub,如果找到了,就返回子串的位置索引;如果未找到,则返回 npos。
5.10 substr
string substr(size_t pos, size_t len = npos) const
{
assert(pos < _size);
size_t realLen = len;
if (len == npos || pos + len > _size)
{
realLen = _size - pos;
}
string sub;
for (size_t i = 0; i < realLen; ++i)
{
sub += _str[pos + i];
}
return sub;
}
substr 函数用于从字符串中提取子串,从指定位置 pos 开始,并且可选地指定子串的长度 len。现在来解释这个函数的实现:
string substr(size_t pos, size_t len = npos) const
:这是 std::string 类中的 substr 函数的声明,表示该函数将从指定位置 pos 开始提取子串,并且可选地指定子串的长度 len。pos 是传入的参数,表示提取子串的起始位置的索引;len 是传入的参数,表示要提取的子串的长度,默认值为 npos,表示提取从起始位置 pos 开始的所有字符。
assert(pos < _size);
:使用 assert 断言来确保提取子串的起始位置 pos 不超过字符串的实际大小 _size。如果断言失败(pos 大于等于 _size),则会触发断言失败错误,帮助调试找到错误的位置。
size_t realLen = len;
:定义一个变量 realLen,用于存储实际要提取的子串的长度。初始值为传入的参数 len。
if (len == npos || pos + len > _size)
:检查是否要提取从起始位置 pos 开始的所有字符(即 len 等于 npos),或者是否要提取的字符个数超过字符串末尾(即 pos + len 大于等于 _size)。如果是其中一种情况,表示要提取从 pos 开始的所有字符或从 pos 开始直到末尾的所有字符。此时,将 realLen 更新为从 pos 开始到末尾的字符个数。创建一个名为 sub 的新的 std::string 对象,用于存储提取的子串。使用循环从位置 pos 开始,逐个字符地将子串添加到 sub 中。返回提取的子串 sub。
5.11比较运算符重载
bool operator>(const string& s) const
{
return strcmp(_str, s._str) > 0;
}
这是大于运算符 > 的重载版本,表示该运算符用于比较当前字符串与另一个字符串 s 的大小关系。在这个版本中,使用 strcmp 函数比较两个字符串 _str 和 s._str 的字典序。如果 _str 大于 s._str,则返回 true,否则返回 false。
bool operator==(const string& s) const
{
return strcmp(_str, s._str) == 0;
}
这是等于运算符 == 的重载版本,表示该运算符用于比较当前字符串与另一个字符串 s 是否相等。同样,使用 strcmp 函数比较两个字符串 _str 和 s._str 的内容是否相同。如果相同,返回 true,否则返回 false。
bool operator>=(const string& s) const
{
return *this > s || *this == s;
}
这是大于等于运算符 >= 的重载版本,表示该运算符用于比较当前字符串是否大于或等于另一个字符串 s。在这个版本中,直接使用已经定义好的大于运算符 > 和等于运算符 == 进行组合,如果当前字符串大于 s 或者与 s 相等,则返回 true,否则返回 false。
bool operator<=(const string& s) const
{
return !(*this > s);
}
这是小于等于运算符 <= 的重载版本,表示该运算符用于比较当前字符串是否小于或等于另一个字符串 s。同样,直接使用已经定义好的大于等于运算符 >= 进行取反,如果当前字符串小于 s,则返回 true,否则返回 false。
bool operator<(const string& s) const
{
return !(*this >= s);
}
这是小于运算符 < 的重载版本,表示该运算符用于比较当前字符串是否小于另一个字符串 s。同样,直接使用已经定义好的大于等于运算符 >= 进行取反,如果当前字符串不大于等于 s,则说明当前字符串小于 s,返回 true,否则返回 false。
bool operator!=(const string& s) const
{
return !(*this == s);
}
这是不等于运算符 != 的重载版本,表示该运算符用于比较当前字符串是否不等于另一个字符串 s。同样,直接使用已经定义好的等于运算符 == 进行取反,如果当前字符串与 s 不相等,则返回 true,否则返回 false。
其实和之前类和对象的文章中讲到的日期类比较运算符重载一样,先实现> == 或< ==后面的都可以进行复用。
5.12流插入<<和流提取>>重载
首先这里要注意的是,流插入和流提取在这里定义为全局函数,因此我们不要再类中定义,而是在类外,即全局定义。这样定义的运算符重载函数不属于类的成员,因此在其实现中不能直接访问类的私有成员,而需要通过类的公有接口进行访问。
运算符重载函数可以作为成员函数或全局非成员函数进行定义,具体取决于使用场景和设计需求。通常情况下,如果运算符的操作数为类对象本身或需要直接访问类的私有成员,可以考虑将其定义为成员函数。而如果运算符的操作数为类对象外的其他类型,或者运算符涉及的操作不仅限于类对象本身,可以考虑将其定义为全局非成员函数。
流插入<<
ostream& operator<<(ostream& out, const string& s)
{
for (size_t i = 0; i < s.size(); ++i)
{
out << s[i];
}
return out;
}
这是输出运算符 << 的重载版本,表示将 std::string 类对象 s 输出到输出流 out 中。
使用一个循环遍历 s 中的每个字符,并将每个字符依次输出到输出流 out 中。最后,将输出流 out 返回,以支持链式输出。
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch;
ch = in.get();
const size_t N = 32;
char buff[N];
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
buff[i] = '\0';
s += buff;
return in;
}
这是输入运算符 >> 的重载版本,表示将输入流 in 中的数据读取并存储到 std::string 类对象 s 中。
首先调用 s.clear() 函数,将 s 的内容清空,以便接收新的输入。然后,使用一个循环从输入流 in 中逐个读取字符 ch。如果字符 ch 不是空格或换行符,就将字符添加到一个临时字符数组 buff 中,并增加索引 i。一旦 buff 已满(i == N - 1),就将 buff 最后一个元素设为空字符 ‘\0’,然后将 buff 添加到 s 中,然后将索引 i 重置为 0,以继续接收后续字符。如果字符 ch 是空格或换行符,说明一个单词的输入结束,将 buff 最后一个元素设为空字符 ‘\0’,然后将 buff 添加到 s 中。最后,将输入流 in 返回,以支持链式输入。
6.string类的模拟实现(完整代码)
#include<iostream>
#include<string.h>
#include<assert.h>
using namespace std;
namespace mystring
{
class string
{
public:
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
// 传统写法
//string(const string& s)
// :_str(new char[s._capacity+1])
// , _size(s._size)
// , _capacity(s._capacity)
//{
// strcpy(_str, s._str);
//}
// 现代写法
void swap(string& tmp)
{
::swap(_str, tmp._str);
::swap(_size, tmp._size);
::swap(_capacity, tmp._capacity);
}
string(const string& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
string tmp(s._str);
swap(tmp);
}
//string& operator=(const string& s)
//{
// if (this != &s)
// {
// //string tmp(s._str);
// string tmp(s);
// swap(tmp); // this->swap(tmp);
// }
// return *this;
//}
string& operator=(string s)
{
swap(s);
return *this;
}
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
typedef char *iterator;
typedef const char *const_iterator;
iterator begin(){
return _str;
}
const_iterator begin() const{
return _str;
}
iterator end(){
return _str+_size; //[3]
}
const_iterator end() const{
return _str+_size;
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void resize(size_t n, char ch = '\0')
{
if (n > _size)
{
// 插入数据
reserve(n);
for (size_t i = _size; i < n; ++i)
{
_str[i] = ch;
}
_str[n] = '\0';
_size = n;
}
else
{
// 删除数据
_str[n] = '\0';
_size = n;
}
}
void push_back(char ch)
{
// 满了就扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
//insert(_size, ch);
}
void append(const char* str)
{
size_t len = strlen(str);
// 满了就扩容
if (_size + len > _capacity)
{
reserve(_size+len);
}
strcpy(_str + _size, str);
//strcat(_str, str); 需要找\0,效率低
_size += len;
//insert(_size, str);
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
// 满了就扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
--end;
}
_str[pos] = 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)
{
_str[end] = _str[end - len];
--end;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}
void erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
if (len == npos || pos + len >= _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
size_t find(char ch, size_t pos = 0) const
{
assert(pos < _size);
for (size_t i = pos; i < _size; ++i)
{
if (ch == _str[i])
{
return i;
}
}
return npos;
}
size_t find(const char* sub, size_t pos = 0) const
{
assert(sub);
assert(pos < _size);
// kmp/bm
const char* ptr = strstr(_str + pos, sub);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
string substr(size_t pos, size_t len = npos) const
{
assert(pos < _size);
size_t realLen = len;
if (len == npos || pos + len > _size)
{
realLen = _size - pos;
}
string sub;
for (size_t i = 0; i < realLen; ++i)
{
sub += _str[pos + i];
}
return sub;
}
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);
}
private:
size_t _capacity;
size_t _size;
char* _str;
public:
const static size_t npos = -1;
};
ostream& operator<<(ostream& out, const string& s)
{
for (size_t i = 0; i < s.size(); ++i)
{
out << s[i];
}
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch;
ch = in.get();
const size_t N = 32;
char buff[N];
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
buff[i] = '\0';
s += buff;
return in;
}
}