文章目录
- 前言
- 成员变量
- 默认成员函数
- 默认构造函数
- 拷贝构造函数
- 析构函数
- 赋值运算符重载
- 容量相关函数（Capacity）
- reserve函数
- resize函数
- size函数
- capacity 函数
- clear函数
- 修改函数（Modifiers）
- swap函数
- insert函数
- 字符插入
- 字符串插入
- append函数
- push_back函数
- erase函数
- +=重载
- 元素获取函数（Element access）
- operator[]
- 操作函数（String operations）
- c_str函数
- substr函数
- find函数
- 运算符重载
- 流插入运算符<<重载
- 流提取运算符>>重载
- 完整代码
- 写实拷贝
- 写时拷贝完整代码
前言
本文将要对STL容器string进行模拟实现，将要实现string常用构造函数，析构函数，拷贝构造函数以及常用增删查改接口，介绍如何通过函数复用以达到简化代码，如何通过写实拷贝提高程序效率，通过模拟实现达到加深对string的理解，提高自身编程技巧的效果。
注：本文在读者拥有string相关知识储备的基础下更易于理解，可跳转链接阅读博主的另一篇文章掌握如何使用string后再来阅读
成员变量
private:
char* _str=nullptr;//字符串
size_t _capacity=0;//容量
size_t _size=0;//有效字符个数
static const size_t npos;
//static const size_t npos=-1 vs下int类型支持给static和const同时修饰的变量用缺省值
默认成员函数
默认构造函数
默认构造函数（无参构造函数）是构造一个空的字符串。
string()
:_str(new char[1])
, _capacity(0)
, _size(0)
{
_str[0] = '\0';
}
像上面这样写如何？可以，但是可以更简洁一些。
像下面这样写更加简洁并且好处在于C-string构造函数可以同时担任默认构造函数与C-string构造函数的角色，这一点利用了语言的语法规则，如果我们显示定义构造函数后编译器则不会再生成默认构造函数
string(const char* str="")//对象实例化不传递参数则默认用空字符串拷贝构造
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
注：实现string(const char* str=“”)后不可以再显示实现默认构造函数，否则会造成调用歧义。
在调用方面，如果我们想要实例化一个空字符串的string对象要以以下方式调用
string s1;
绝对不可以用以下的方式调用，错误示例如下：
在这种情况下编译器会把它识别为函数声明
string s1();
拷贝构造函数
拷贝构造函数是用一个类对象实例化另一个类对象
string(const string& str)
{
_size = str._size;
_capacity = str._capacity;
_str = str._str;
}
如果以以上方式编写后进行调用会发生什么
在调用之前我们先实现一个方便我们观察运行时现象的析构函数
析构函数
清理对象占用内存资源
~string()
{
delete[] _str;
_str = nullptr;
_size = 0;
_capacity = 0;
//cout<<~string()<<endl;此语句仅为观察使用
}
运行程序
监视窗口
RUN:运行错误
以上为典型浅拷贝引起的delete内存释放错误，浅拷贝使得两个对象共享同一块内存资源，在内存释放时对同一内存空间进行多次释放引起错误。
默认拷贝构造函数同样是浅拷贝，仅对对象的成员变量的值进行拷贝。
什么是浅拷贝？
浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。其实我们可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。什么是深拷贝
深拷贝是指在进行对象拷贝时，不仅复制对象本身的成员变量，还复制对象所指向的动态分配的资源（例如堆内存）到新的对象中。这意味着拷贝后的对象和原对象拥有独立的资源副本，彼此之间不会相互影响。
当对象中含有动态分配的资源，如指针指向的内存块，或者其他动态分配的资源（文件句柄、网络连接等），进行深拷贝是非常重要的，以避免多个对象共享同一块资源导致释放重复、悬挂指针（悬挂指针：指的是一个指针变量指向了曾经被分配的内存地址，但该内存已经被释放或者回收了。在这种情况下，指针仍然指向原来的内存地址，但那个地址现在可能已经被操作系统重新分配给了其他程序或变量，或者已经被标记为不可用。）等问题。
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供
拷贝构造正确编写方法
string(const string& str)
{
_str = new char[str._capacity + 1];
strcpy(_str, str._str);
_size = str._size;
_capacity = str._capacity;
}
通过函数复用进行优化
void swap(string& str)//交换对象内容
{
std::swap(_size, str._size);
std::swap(_capacity, str._capacity);
std::swap(_str, str._str);
}
string(const string& str)
:_str(nullptr)//_str用nullptr初始化是为了确保与之交换的指针不会成为野指针，导致不必要错误
,_size(0)
,_capacity(0)
{
string temp(str._str);
swap(temp);
//this->swap(temp);编译器为每个非静态的成员函数配备一个this指针
//这个this指针可以显示使用，也可以不显示使用
}
这样设计的原理是调用C-string构造函数后再交换两个对象的内容，temp对象出作用域之后自动销毁。
这种方法虽然简化了代码但存在着一定问题，像_size 与_capacity的大小可能与被拷贝对象的值不相同，但问题可忽略。
关于为什么不使用标准库的swap函数进行数据交换
在C++之前swap是以下形式实现
它首先会拷贝构造一个对象，然后再进行赋值拷贝，这种实现方法十分低效
C++11之后新增的运行移动语义使得其实现更高效，如果使用C++之后的swap,它的效率与我们模拟实现的方法的效率相比更高效，它省去了一切资源的开辟。
此内容需要大篇幅讲解才能理清逻辑，因本文重点不在此，故不进行详细讲解。
赋值运算符重载
string& operator =(const string& s)
{
if (this != &s)//如果“自己”给“自己”赋值则直接跳过
{
char* temp = new char[s._capacity + 1];
strcpy(temp, s._str);
delete[] _str;
_str = temp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}
优化
string& operator=(const string& s)
{
if (this != &s)
{
string temp(s);
swap(temp);
}
return *this;
}
再优化
string& operator=(string s)
{
swap(s);
return *this;
}
通过值拷贝的方式传递参数，直接生成一个临时对象，再交换对象内容，达到简化代码的效果。
容量相关函数（Capacity）
reserve函数
根据Windows平台下的reserve规则
n > _capacity时对对象的容量进行扩容
n<=_capacity时不对对象的容量进行修改
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
开辟新空间，转移数据，释放原空间，修改成员变量
resize函数
根据Windows平台下的reserve规则
n>_size
首先判断n > _capacity是否成立，成立则首先进行扩容操作
再将[_size,n)区间内容填入指定字符ch
n<=_size时对对象的有效字符进行缩减,将有效字符缩减至指定个数
void resize(size_t n, char ch = '\0')
{
if (n > _size)
{
reserve(n);
for (int i = _size; i < n; ++i)
{
_str[i] = ch;
}
}
_str[n] = '\0';//必须给_str[n]赋值'\0'，以做字符串结束标志
_size = n;
}
size函数
返回字符串有效字符长度
size_t size() const
{
return _size;
}
capacity 函数
返回空间总大小
size_t capacity() const
{
return _capacity;
}
clear函数
void clear()
{
_str[0] = '\0';
_size = 0;
}
清空字符串内容只需要修改字符串结束标志，下次再对字符串进行操作会覆盖式写入内容。
修改函数（Modifiers）
swap函数
交换两个对象内容
void swap(string& str)
{
std::swap(_size, str._size);
std::swap(_capacity, str._capacity);
std::swap(_str, str._str);
}
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)//将插入位置 pos 之后的字符依次向后移动一个位置。
{
_str[end] = _str[end - 1];
--end;
}
_str[pos] = ch;//将字符 ch 插入到指定的插入位置 pos
++_size;//插入字符后，将字符串的实际大小 _size 增加 1
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)//将插入位置 pos 之后的字符依次向后移动 len 个位置，为新字符串的插入留出空间
{
_str[end] = _str[end - len];
--end;
}
strncpy(_str + pos, str, len);//将字符串拷贝到指定位置
_size += len;//插入字符后，将字符串的实际大小 _size 增加 len
return *this;
}
append函数
在字符串后追加一个字符串
void append(const char* str)
{
size_t len = strlen(str);
// 判读是否需要扩容
if (_size + len > _capacity)
{
reserve(_size+len);
}
strcpy(_str + _size, str);
_size += len;
}
通过复用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';//作为字符串必须要字符串结束标志
}
通过复用insert实现
void push_back(char ch)
{
insert(_size, ch);
}
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;
}
}
如果len 等于缺省值 npos则将pos及以后字符全部删除
如果删除字符个数超过pos位置后字符总和则同样将pos及以后字符全部删除
如果以上两种情况不成立则直接将从位置 pos + len 开始的字符复制到位置 pos，覆盖掉要删除的字符。
+=重载
+= 运算符在字符串的操作中通常被用作连接（拼接）操作。
连接一个字符
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
连接一个字符串
string& operator+=(const char* str)
{
append(str);
return *this;
}
元素获取函数（Element access）
operator[]
返回pos位置的字符,可修改pos位置字符
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
返回pos位置的字符，不可修改pos位置字符
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
注意断言，下标位置不能等于_size，_size指向最后一个字符的下一个也就是字符0，但是实际库中的string的字符0我们是可以访问到的，这里主要表示有效数据的访问。
操作函数（String operations）
c_str函数
返回C格式字符串
const char* c_str() const
{
return _str;
}
substr函数
获取一个子字符串
string substr(size_t pos, size_t len = npos) const
{
assert(pos < _size);
string str;
if (len == npos || pos + len >= _size)
{
str.reserve(_size-pos);
str._size = _size - pos;
strcpy(str._str, _str + pos);
}
else
{
str.reserve(len);
str._size = len;
strncpy(str._str,_str + pos,len);
str._str[_size] = '\0';
}
return str;
}
如果len长度超过pos位置后字符总和或者为缺省值则将pos及以后字符全部复制，反之则复制其区间到目标字符串str，然后将字符串末尾添加字符串结束标志’\0’.
优化
string substr(size_t pos, size_t len = npos) const
{
assert(pos < _size);
size_t end = pos+len;
if (len == npos || pos + len >= _size)
{
end = _size;
}
string str;
str.reserve(end - pos);
for (size_t i = pos; i < end; ++i)
{
str += _str[i];
}
return str;
}
确定被拷贝字符串的末尾位置，然后将被拷贝字符串的字符依次连接到目标字符串中。
find函数
查找一个字符查找成功返回其下标，查找一个字符串查找成功返回其字符串的起始下标，查找失败均返回npos值
size_t find(const char ch, size_t pos = 0)
{
assert(pos < _size);
while (pos < _size)
{
if (_str[pos] == ch)
{
return pos;
}
++pos;
}
return npos;
}
size_t find(const char* str, size_t pos = 0)
{
const char* ptr = strstr(_str + pos, str);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
strstr 是一个库函数，用于在一个字符串中查找另一个字符串的首次出现位置
char *strstr(const char *haystack, const char *needle);
haystack 是要在其中进行搜索的字符串，也被称为主字符串。
needle 是要在 haystack 中查找的子字符串。
如果 needle 在 haystack 中找到，则 strstr 返回指向 haystack 中 needle 首次出现位置的指针。如果未找到 needle，则返回 NULL。
运算符重载
流插入运算符<<重载
流插入运算符<<重载要定义为全局函数，因为定义为全局函数，因此在其实现中不能直接访问类的私有成员，而需要通过类的公有接口进行访问，或者将其定义为类的友元函数进而访问其私有成员。
std::ostream& operator<<(std::ostream& out, const string& s)
{
for (size_t i = 0; i < s.size(); ++i)
{
out << s[i];
}
return out;
}
流提取运算符>>重载
std::istream& operator>>(std::istream& in, string& s)
{
s.clear();
char ch = in.get();
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}
使用istream的成员函数get，每次读入一个字符
以上设计方法存在频繁扩容的问题，如果我们频繁输入就会频繁进行扩容操作，频繁进行函数调用会降低效率，因此我们可以创建一个”输入缓冲区buff“当缓冲区填满则将缓冲区内容刷新出去，当输入结束再将未刷新的缓冲区进行刷新，该策略在语言层面和操作系统层面有着广泛应用。
std::istream& operator>>(std::istream& in, string& s)
{
s.clear();
char buff[128] = { '\0' };
size_t i = 0;
char ch = in.get();
while (ch != ' ' && ch != '\n')
{
if (i == 127)
{
s += buff;
i = 0;
}
buff[i++] = ch;
ch = in.get();
}
if (i >= 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
完整代码
#pragma once
#include<Cassert>
namespace zyc
{
class string
{
//friend std::ostream& operator<<(std::ostream& out, const zyc::string& s);//设置为友元函数直接访问类的私有成员变量
typedef char* iterator;
typedef const char* const_iterator;
public:
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
void swap(string& str)
{
std::swap(_size, str._size);
std::swap(_capacity, str._capacity);
std::swap(_str, str._str);
}
string(const string& str)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
string temp(str._str);
swap(temp);
}
string& operator=(string s)
{
swap(s);
return *this;
}
~string()
{
delete[] _str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
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 (int i = _size; _size < n; i++)
{
_str[i] = ch;
}
}
_str[n] = '\0';
_size = n;
}
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 append(const char* str)
{
size_t len = strlen(str);
// 满了就扩容
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, str);
_size += len;
}
/*void append(const char* str)
{
insert(_size, str);
}*/
void push_back(char ch)
{
// 满了就扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
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;
}
}
/*string substr(size_t pos, size_t len = npos) const
{
assert(pos < _size);
string str;
if (len == npos || pos + len >= _size)
{
str.reserve(_size-pos);
str._size = _size - pos;
strcpy(str._str, _str + pos);
}
else
{
str.reserve(len);
str._size = len;
strncpy(str._str,_str + pos,len);
str._str[_size] = '\0';
}
return str;
}*/
string substr(size_t pos, size_t len = npos) const
{
assert(pos < _size);
size_t end = pos+len;
if (len == npos || pos + len >= _size)
{
end = _size;
}
string str;
str.reserve(end - pos);
for (size_t i = pos; i < end; ++i)
{
str += _str[i];
}
return str;
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
size_t find(const char ch, size_t pos = 0)
{
assert(pos < _size);
while (pos < _size)
{
if (_str[pos] == ch)
{
return pos;
}
++pos;
}
return npos;
}
size_t find(const char* str, size_t pos = 0)
{
const char* ptr = strstr(_str + pos, str);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
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 clear()
{
_str[0] = '\0';
_size = 0;
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//有效字符个数
static const size_t npos = -1; //vs下int类型支持给static和const同时修饰的变量用缺省值
};
std::ostream& operator<<(std::ostream& out, const string& s)
{
for (size_t i = 0; i < s.size(); ++i)
{
out << s[i];
}
return out;
}
/*std::istream& operator>>(std::istream& in, string& s)
{
s.clear();
char ch = in.get();
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}*/
std::istream& operator>>(std::istream& in, string& s)
{
s.clear();
char buff[128] = { '\0' };
size_t i = 0;
char ch = in.get();
while (ch != ' ' && ch != '\n')
{
if (i == 127)
{
s += buff;
i = 0;
}
buff[i++] = ch;
ch = in.get();
}
if (i >= 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
}
写实拷贝
写时拷贝（Copy-on-Write，简称COW）是一种计算机程序设计领域的优化策略，用于延迟复制资源的实际发生，直到真正需要修改资源时。在写时拷贝的场景中，多个引用（或“视图”）最初指向同一份资源。当某个引用尝试修改资源时，系统才会创建该资源的一个副本，并让修改的引用指向这个新的副本，而其他的引用仍然指向原始的资源。
写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的，既然是引用计数，必然有一个变量类是某些类所共有的。当第一个类构造时，string的构造函数会根据传入的参数从堆上分配内存，当有其它类需要这块内存时，这个计数为自动累加，当有类析构时，这个计数会减一，直到最后一个类析构时，此时的引用计数变为1或0，这时对对象的空间进行释放。
关于这个引用计数怎么设计，我在这里介绍两种设计思路：
1：在类内部设置一个指针指向一片开辟的内存空间。
2：在string成员变量_str指向的堆内存空间中多开辟一个整形的空间进行计数（这里博主采用第二种设计思路）。
当我们知道引用计数的设计思路后，就要考虑什么时候应该进行写时拷贝
写时拷贝发生在对string对象进行修改操做时，比如insert，push_back,append,erease等成员函数+=,[]，=赋值操作，以及析构操作时发生写时拷贝。
对于写时拷贝为主要实现了以下三个私有成员函数，方便发生写时拷贝时进行调用。
//获得引用计数
int& GetRefCount()
{
return *((int*)(_str - 4));
}
//写时拷贝
void Sub(size_t n)
{
char* tmp = new char[n + 5];
tmp += 4;
strcpy(tmp, _str);
Release();
_str = tmp;
GetRefCount() = 1;
_capacity = n;
}
申请新空间，释放旧空间，在交换前前对引用计数–，交换后将新空间的引用计数置为1.
//检查是否需要对空间进行释放
void Release()
{
if (--GetRefCount() == 0)
{
delete[](_str - 4);
}
}
写时拷贝完整代码
#pragma once
#include<Cassert>
#include<iostream>
namespace zyc
{
class string
{
typedef char* iterator;
typedef const char* const_iterator;
public:
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 5];
_str += 4;
GetRefCount()=1;
strcpy(_str, str);
}
void swap(string& str)
{
Sub(_capacity);
str.Sub(str._capacity);
std::swap(_size, str._size);
std::swap(_capacity, str._capacity);
std::swap(_str, str._str);
}
string(const string& str)
:_str(str._str)
,_size(str._size)
,_capacity(str._capacity)
{
++GetRefCount();
}
string& operator=(const string& s)
{
_str = s._str;
_size = s._size;
_capacity = s._capacity;
++GetRefCount();
return *this;
}
~string()
{
Release();
}
void reserve(size_t n)
{
if (n > _capacity)
{
Sub(n);
}
}
void resize(size_t n, char ch = '\0')
{
if (n > _size)
{
reserve(n);
for (int i = _size; _size < n; i++)
{
_str[i] = ch;
}
}
_str[n] = '\0';
_size = n;
}
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
Sub(_capacity);
// 满了就扩容
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);
Sub(_capacity);
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 append(const char* str)
{
insert(_size, str);
}
void push_back(char ch)
{
insert(_size, ch);
}
void erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
Sub(_capacity);
if (len == npos || pos + len >= _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
string substr(size_t pos, size_t len = npos) const
{
assert(pos < _size);
size_t end = pos + len;
if (len == npos || pos + len >= _size)
{
end = _size;
}
string str;
str.reserve(end - pos);
for (size_t i = pos; i < end; ++i)
{
str += _str[i];
}
return str;
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
size_t find(const char ch, size_t pos = 0)
{
assert(pos < _size);
while (pos < _size)
{
if (_str[pos] == ch)
{
return pos;
}
++pos;
}
return npos;
}
size_t find(const char* str, size_t pos = 0)
{
const char* ptr = strstr(_str + pos, str);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
char& operator[](size_t pos)
{
assert(pos < _size);
Sub(_size);
return _str[pos];
}
void clear()
{
Sub(_capacity);
_str[0] = '\0';
_size = 0;
}
int count()
{
return GetRefCount();
}
private:
void Release()
{
if (--GetRefCount() == 0)
{
delete[](_str - 4);
}
}
int& GetRefCount()
{
return *((int*)(_str - 4));
}
void Sub(size_t n)
{
char* tmp = new char[n + 5];
tmp += 4;
size_t len = _size;
strcpy(tmp, _str);
Release();
_str = tmp;
GetRefCount() = 1;
_capacity = n;
_size = len;
}
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//有效字符个数
static const size_t npos = -1; //vs下int类型支持给static和const同时修饰的变量用缺省值
};
std::ostream& operator<<(std::ostream& out, const string& s)
{
for (size_t i = 0; i < s.size(); ++i)
{
out << s[i];
}
return out;
}
std::istream& operator>>(std::istream& in, string& s)
{
s.clear();
char buff[128] = { '\0' };
size_t i = 0;
char ch = in.get();
while (ch != ' ' && ch != '\n')
{
if (i == 127)
{
s += buff;
i = 0;
}
buff[i++] = ch;
ch = in.get();
}
if (i >= 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
}
注意：我们实现的写时拷贝存并不成熟，像以下修改策略，发生修改操作时，这种操作根本就不会被我们所发现。
string str1 = "hello";
char& ref = str1[0];
string str2 = str1;
ref = 'y';
并且库的string也存在着缺陷，详情我在这里推荐一篇文章，推荐大家阅读
C++的STD::STRING的“读时也拷贝”技术！
本章到此结束，感谢您的阅读！
![[论文笔记]Root Mean Square Layer Normalization](https://img-blog.csdnimg.cn/img_convert/ebea04d0e75943d4b3eeb5b2449b92db.png)
![[Java EE] 多线程(二): 线程的创建与常用方法(下)](https://img-blog.csdnimg.cn/direct/c79dcaaebfeb41df9b7c8678e1ec2dd9.png)
