1：默认成员函数的模拟实现
2：多种打印的模拟实现
3：运算符重载模拟实现
4：reserve与resize模拟实现
5:尾插字符/字符串模拟实现
6：任意地方的插入字符/字符串，删除字符串模拟实现
7：寻找字符/字符串的模拟实现
8：流插入与流提取的模拟实现
///
///
1：默认成员函数的模拟实现
默认成员函数有六种，我们这里主要实现其中的四种：构造，拷贝，赋值重载，析构；
构造函数：我们尽量给全缺省，毕竟有string S1 /string S1("***")两种定义的需求；
拷贝构造：我们需要自己写，编译器自己生成的拷贝构造只能浅拷贝，对于字符串这种需要拷贝一整块空间的情况，我们需要自己写拷贝构造函数，实现深拷贝，否则浅拷贝析构时会对一个空间释放两次；
赋值重载与析构函数和平常的大致一样，
class string
{
public:
//构造函数：
string(const char* ptr = " ")//全缺省，
:_size(strlen(ptr))//初始化列表，只初始化size，
{
_capacity = _size == 0 ? 3 : _size;//防止插入一个字符时capacity是0，
_ptr = new char[_capacity + 1];
strcpy(_ptr, ptr);
}
//拷贝构造：//因为是字符串，所以需要深拷贝；
string(const string& ptr)
{
_size = ptr._size;
_capacity = ptr._capacity;
_ptr = new char[_capacity + 1];//重新开辟一块空间，
strcpy(_ptr, ptr._ptr);
}
//析构函数：
~string()
{
delete[]_ptr;
_ptr = nullptr;
_size = _capacity = 0;
}
//赋值运算符：
string& operator=(const string& ptr)//返回值是string&,因为赋值对象一般已经定义，参数是防止赋值时位置不对引发错误以及产生多余的拷贝构造；
{
if (this != &ptr)//如果不是自己赋值给自己，直接返回；
{
_size = ptr._size;
_capacity = ptr._capacity;
//先创建一个临时字符串，开辟空间
char* temp = new char[_capacity + 1];
delete[]_ptr;//然后将要赋值的字符串析构，
strcpy(temp, ptr._ptr);//将被拷贝的字符串拷贝到临时字符串中，
_ptr = temp;//再将临时字符串赋值给要拷贝的字符串；
}
return *this;
}
private:
char* _ptr;
size_t _size;
size_t _capacity;
};///
///
2：多种打印的模拟实现
在没有实现流插入与流提取的时候，如何打印string类定义的字符串呢？
1.成员函数实现：在类中写一个成员函数方便类外调用打印；
2：迭代器实现（语法糖实现（底层仍然是迭代器））；
4；下标 [ ] 实现 5：类外函数实现（也是调用类中的成员函数，但是成员函数是加const的）；
class string
{
public:
//正向迭代器，关键字iterator:
typedef char* iterator;
typedef const char* const_iterator;//const正向迭代器,
//获取字符串，方便类外打印：
const char* c_str()//遇见空格就结束打印；
{
return _ptr;
}
//获取字符串的个数：
size_t size()const
{
return _size;
}
//运算符重载[]，方便通过下标访问字符串：
char& operator[](size_t pos)
{
assert(pos < _size);
return _ptr[pos];
}
//与运算符重载[]构成函数重载，方便有const修饰的[]调用；
char& operator[](size_t pos)const
{
assert(pos < _size);
return _ptr[pos];
}
//正向迭代器：
iterator begin()//迭代器的开始：
{
return _ptr;
}
iterator end()//迭代器的结束：
{
return _ptr + _size;
}
//const正向迭代器：
const_iterator begin()const//迭代器的开始：
{
return _ptr;
}
const_iterator end()const//迭代器的结束：
{
return _ptr + _size;
}
private:
char* _ptr;
size_t _size;
size_t _capacity;
};
//各种打印：调类中成员函数/迭代器/语法糖/下标[]/类外打印函数
void string_it(const string& s)//类外调用const成员函数（迭代器）
{
string::const_iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
it++;
}
cout << endl;
}
void print(const string& s)//类外调用const成员函数（下标[]）
{
for (size_t i = 0; i < s.size(); i++)
{
cout << s[i] << " ";
}
cout << endl;
}
void test_string2()
{
string s1("aaabbbcccddd");
cout << s1.c_str() << endl;
string::iterator it = s1.begin();
while (it != s1.end())
{
(*it)++;
cout << *it << " ";
it++;
}
cout << endl;
for (size_t i = 0; i < s1.size(); i++)
{
cout << s1[i] << " ";
}
cout << endl;
for (auto e : s1)
{
e += 1;
cout << e << " ";
}
cout << endl;
string_it(s1);
print(s1);
}
///
///
3：运算符重载模拟实现
运算符重载的主要是 == ! = > >= < <=
通过strcmp的返回值来判断字符串是否相等或者大于 小于，然后通过复用直接实现其他运算符重载；
//运算符重载==：通过strcmp来比较字符串是否相等；
bool operator==(const string& ptr)const
{
return strcmp(_ptr, ptr._ptr) == 0;
}
//运算符重载！=：复用==运算符
bool operator!=(const string& ptr)const
{
return !(*this == ptr);
}
//运算符重载>:通过strcmp来比较字符串是否大于；
bool operator>(const string& ptr)const
{
return strcmp(_ptr, ptr._ptr) > 0;
}
//运算符重载>=：复用 >运算符 与 ==运算符，
bool operator>=(const string& ptr)const
{
return (*this == ptr) || (*this > ptr);
}
//运算符重载<:复用 >=运算符;
bool operator<(const string& ptr)const
{
return !(*this >= ptr);
}
//运算符重载<:复用 >运算符;
bool operator<=(const string& ptr)const
{
return !(*this > ptr);
}///
///
4：reserve与resize模拟实现
通过库中的定义我们可以认识到，
reserve只改变string类字符串capacity(容量)；
而resize可以改变strng类字符串的size（长度），capacity（容量）；
//reserve: 扩容 相当于realloc,但是它是重新开辟空间，realloc则是原地扩或者异地扩两种方式；
void reserve(size_t n)
{
if (n > _capacity)//当需要的空间大于原本的空间才扩容，否则会导致缩容;
{
char* temp = new char[n + 1];//开辟临时字符串；
strcpy(temp, _ptr);//将之前的字符串拷贝到临时字符串；
delete[]_ptr;//释放原来字符串；
_ptr = temp;//将临时字符串赋值给原来的字符串；
_capacity = n;//最后将容量赋值成需要的大小；
}
}
//resize:扩容/缩容+初始化：分两种情况：1.当n小于原来的空间， 2.当n大于原来的空间
void resize(size_t n, char ch = '\0')//全缺省；
{
//第一种情况，此时直接截断，在n位置直接加'\0';将字符串字符个数赋值成n;
if (n <= _size)
{
_ptr[n] = '\0';
_size = n;
}
else
{
if (n > _capacity)//第二种情况先扩容;
{
reserve(n + 1);
}
size_t end = _size;//创建临时变量，赋值；
while (end < n)
{
_ptr[end++] = ch;//一直赋值；
}
_size = n;
_ptr[_size] = '\0';//最后将赋完值的字符串结尾加'\0'。防止进随机值：
}
}///
///
5:尾插字符/字符串以及 运算符+= 模拟实现
通过库中的定义可知，
push_back就是尾插，无返回值，参数是字符；
append是尾部追加字符串，，实现了很多接口，我们就以字符串为例：
+=就是在尾部插入，但是要注意到返回值，需要用引用，同时注意空字符串插入第一个字符时capacity是否为空；（或者直接复用push_back,append）;
//尾插字符：
void push_back(char ch = '\0')
{
if (_size + 1 > _capacity)//先判断是否需要扩容；+1是为了计算了要插入的字符
{
reserve(_size + 1);
}
_ptr[_size] = ch;//将字符串的'\0'处赋值为字符；
_size++;
_ptr[_size] = '\0';//最后将赋完值的字符串结尾加'\0'。防止进随机值：
//复用insert，插入字符
//insert(_size, ch);
}
//尾插字符串：
void append(const string& str)
{
size_t len = strlen(str._ptr);//计算要插入的字符串大小；
if (_size + len > _capacity)//判断是否需要扩容：
{
reserve(_size + len);
}
strcpy(_ptr + _size, str._ptr);//将字符串拷贝到原字符串的结尾处
_size += len;
//复用insert，插入字符串
//insert(_size, str);
}
//运算符重载+=字符：
string& operator+=(const char ch)
{
push_back(ch);
return *this;
}
//运算符重载+=字符串；
string& operator+=(const string& str)
{
append(str);
return *this;
}///
///
6：任意地方的插入字符/字符串（insert），删除字符串(erase)模拟实现
在实现任意位置插入字符/字符串时，我们需要留心一些细节如：要插入的位置是否在字符串中，插入的时候需不需要扩容，插入时注意插入的位置等；
//在任意地方插入字符：
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;//创建临时变量，+len预留插入的字符串的位置长度；
while (end > pos + len-1)//-1是要插入字符串的起始位置；
{
_ptr[end] = _ptr[end - len];//将前len个字符挪到现在的位置；
--end;
}
strncpy(_ptr + pos, str, len);//将字符串拷贝到原字符串；
_size += len;//字符串长度+len;
return *this;
}
//在任意地方删除：两种情况：1.删除的位置加上删除的个数<字符串长度；2.删除的位置加上删除的个数>字符串长度 3.默认删除nops
string& erase(size_t pos = 0, size_t len = nops)
{
assert(pos <= _size);
if (len+pos > _size||len==nops)//第二与第三两种情况；
{
_size = pos;
_ptr[_size] = '\0';
}
strcpy(_ptr + pos, _ptr + pos + len);//第一种情况，直接复制；
_size -= len;
return *this;
}///
///
7：寻找字符/字符串的模拟实现
查找字符/字符串第一次出现的位置下标；库中给了默认缺省值size_t nops（-1）,找到返回第一次出现的下标，没找到返回nops；
//选择指定字符第一次出现的位置；
size_t find(const char ch, size_t pos = 0)const
{
assert(pos < _size);
size_t i = 0;
for (i = pos; i < _size; i++)
{
if (_ptr[i] == ch)
{
return i;//找到返回下标，
}
}
return nops;//没找到返回nops;
}
size_t find(const char*str,size_t pos=0)
{
assert(pos < _size);
char* temp = strstr(_ptr + pos, str);//通过strstr找到子字符串在母字符串出现的位置；
if (temp == nullptr)//如果没找到，返回nops;
{
return nops;
}
return temp - _ptr;//找到通过指针相减 返回相对位置
}///
///
8：流插入与流提取的模拟实现
流插入 流提取就无需写在类中，直接在类外定义实现就行，同时，要注意返回值和参数
//流输入：
ostream& operator<<(ostream&out, const string& s)
{
for (auto e : s)
{
out << e;
}
return out;
}
//流提取：
istream& operator>>(istream&in, string& s)
{
s.clern();//先将字符串置空；
char ch = in.get();//获取字符
//while (ch != '\n')//输入时有空格也可以打印出来；
while (ch != ' ' && ch != '\n')//遇见空格与回车直接刷新缓冲区，
{
s += ch;
ch = in.get();//获取字符
}
return in;
}
///
///
至此，这是我对string类常用接口的实现，如有不足之处请各位大佬指正！
下面是我string类实现的全部代码,为了避免与库中string类冲突，可以将其放到命名空间中去；
namespace MKL
{
class string
{
public:
//正向迭代器，关键字iterator:
typedef char* iterator;
typedef const char* const_iterator;//const正向迭代器,
//构造函数：
string(const char* ptr = " ")//全缺省，
:_size(strlen(ptr))//初始化列表，只初始化size，
{
_capacity = _size == 0 ? 3 : _size;//防止插入一个字符时capacity是0，
_ptr = new char[_capacity + 1];
strcpy(_ptr, ptr);
}
//拷贝构造：
string(const string& ptr)
{
_size = ptr._size;
_capacity = ptr._capacity;
_ptr = new char[_capacity + 1];
strcpy(_ptr, ptr._ptr);
}
//析构函数：
~string()
{
delete[]_ptr;
_ptr = nullptr;
_size = _capacity = 0;
}
//获取字符串，方便类外打印：
const char* c_str()//遇见空格就结束打印；
{
return _ptr;
}
//获取字符串的个数：
size_t size()const
{
return _size;
}
//获取字符串的容量：
size_t capacity()const
{
return _capacity;
}
//运算符重载[]，方便通过下标访问字符串：
char& operator[](size_t pos)
{
assert(pos < _size);
return _ptr[pos];
}
//与运算符重载[]构成函数重载，方便有const修饰的[]调用；
char& operator[](size_t pos)const
{
assert(pos < _size);
return _ptr[pos];
}
//赋值运算符：
string& operator=(const string& ptr)//返回值是string&,因为赋值对象一般已经定义，参数是防止赋值时位置不对引发错误以及产生多余的拷贝构造；
{
if (this != &ptr)//如果不是自己赋值给自己，直接返回；
{
_size = ptr._size;
_capacity = ptr._capacity;
//先创建一个临时字符串，开辟空间
char* temp = new char[_capacity + 1];
delete[]_ptr;//然后将要赋值的字符串析构，
strcpy(temp, ptr._ptr);//将被拷贝的字符串拷贝到临时字符串中，
_ptr = temp;//再将临时字符串赋值给要拷贝的字符串；
}
return *this;
}
//正向迭代器：
iterator begin()//迭代器的开始：
{
return _ptr;
}
iterator end()//迭代器的结束：
{
return _ptr + _size;
}
//const正向迭代器：
const_iterator begin()const//迭代器的开始：
{
return _ptr;
}
const_iterator end()const//迭代器的结束：
{
return _ptr + _size;
}
//运算符重载==：通过strcmp来比较字符串是否相等；
bool operator==(const string& ptr)const
{
return strcmp(_ptr, ptr._ptr) == 0;
}
//运算符重载！=：复用==运算符
bool operator!=(const string& ptr)const
{
return !(*this == ptr);
}
//运算符重载>:通过strcmp来比较字符串是否大于；
bool operator>(const string& ptr)const
{
return strcmp(_ptr, ptr._ptr) > 0;
}
//运算符重载>=：复用 >运算符 与 ==运算符，
bool operator>=(const string& ptr)const
{
return (*this == ptr) || (*this > ptr);
}
//运算符重载<:复用 >=运算符;
bool operator<(const string& ptr)const
{
return !(*this >= ptr);
}
//运算符重载<:复用 >运算符;
bool operator<=(const string& ptr)const
{
return !(*this > ptr);
}
//reserve: 扩容 相当于realloc,但是它是重新开辟空间，realloc则是原地扩或者异地扩两种方式；
void reserve(size_t n)
{
if (n > _capacity)//当需要的空间大于原本的空间才扩容，否则会导致缩容;
{
char* temp = new char[n + 1];//开辟临时字符串；
strcpy(temp, _ptr);//将之前的字符串拷贝到临时字符串；
delete[]_ptr;//释放原来字符串；
_ptr = temp;//将临时字符串赋值给原来的字符串；
_capacity = n;//最后将容量赋值成需要的大小；
}
}
//resize:扩容/缩容+初始化：分两种情况：1.当n小于原来的空间， 2.当n大于原来的空间
void resize(size_t n, char ch = '\0')//全缺省；
{
//第一种情况，此时直接截断，在n位置直接加'\0';将字符串字符个数赋值成n;
if (n <= _size)
{
_ptr[n] = '\0';
_size = n;
}
else
{
if (n > _capacity)//第二种情况先扩容;
{
reserve(n + 1);
}
size_t end = _size;//创建临时变量，赋值；
while (end < n)
{
_ptr[end++] = ch;//一直赋值；
}
_size = n;
_ptr[_size] = '\0';//最后将赋完值的字符串结尾加'\0'。防止进随机值：
}
}
//尾插字符：
void push_back(char ch = '\0')
{
if (_size + 1 > _capacity)//先判断是否需要扩容；+1是为了计算了要插入的字符
{
reserve(_size + 1);
}
_ptr[_size] = ch;//将字符串的'\0'处赋值为字符；
_size++;
_ptr[_size] = '\0';//最后将赋完值的字符串结尾加'\0'。防止进随机值：
//复用insert，插入字符
//insert(_size, ch);
}
//尾插字符串：
void append(const string& str)
{
size_t len = strlen(str._ptr);//计算要插入的字符串大小；
if (_size + len > _capacity)//判断是否需要扩容：
{
reserve(_size + len);
}
strcpy(_ptr + _size, str._ptr);//将字符串拷贝到原字符串的结尾处
_size += len;
//复用insert，插入字符串
//insert(_size, str);
}
//在任意地方插入字符：
string& insert(size_t pos, char ch)
{
assert(pos <= _size);//判断要插入的位置是否为字符串内；
if (_size + 1 > _capacity)//判断是否需要扩容；
{
reserve(_size + 1);
}
size_t end = _size + 1;//创建临时变量，+1预留插入的位置；
while (end > pos)//从后向前遍历；
{
_ptr[end] = _ptr[end-1];//每次将前一个挪到后一个；
--end;
}
_ptr[end] = 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;//创建临时变量，+len预留插入的字符串的位置长度；
while (end > pos + len-1)//-1是要插入字符串的起始位置；
{
_ptr[end] = _ptr[end - len];//将前len个字符挪到现在的位置；
--end;
}
strncpy(_ptr + pos, str, len);//将字符串拷贝到原字符串；
_size += len;//字符串长度+len;
return *this;
}
//在任意地方删除：两种情况：1.删除的位置加上删除的个数<字符串长度；2.删除的位置加上删除的个数>字符串长度 3.默认删除nops
string& erase(size_t pos = 0, size_t len = nops)
{
assert(pos <= _size);
if (len+pos > _size||len==nops)//第二与第三两种情况；
{
_size = pos;
_ptr[_size] = '\0';
}
strcpy(_ptr + pos, _ptr + pos + len);//第一种情况，直接复制；
_size -= len;
return *this;
}
//运算符重载+=字符：
string& operator+=(const char ch)
{
push_back(ch);
return *this;
}
//运算符重载+=字符串；
string& operator+=(const string& str)
{
append(str);
return *this;
}
//选择指定字符第一次出现的位置；
size_t find(const char ch, size_t pos = 0)const
{
assert(pos < _size);
size_t i = 0;
for (i = pos; i < _size; i++)
{
if (_ptr[i] == ch)
{
return i;//找到返回下标，
}
}
return nops;//没找到返回nops;
}
size_t find(const char*str,size_t pos=0)
{
assert(pos < _size);
char* temp = strstr(_ptr + pos, str);//通过strstr找到子字符串在母字符串出现的位置；
if (temp == nullptr)//如果没找到，返回nops;
{
return nops;
}
return temp - _ptr;//找到通过指针相减 返回相对位置
}
//清理字符串：直接将字符串在第一个位置赋值成'\0';
void clern()
{
_ptr[0] = '\0';
_size = 0;
}
private:
char* _ptr;
size_t _size;
size_t _capacity;
static const size_t nops;//静态变量，不能在类中初始化或者给缺省值；
};
//静态变量属于整个类，在类外初始化；
const size_t string::nops = -1;
//流输入：
ostream& operator<<(ostream&out, const string& s)
{
for (auto e : s)
{
out << e;
}
return out;
}
//流提取：
istream& operator>>(istream&in, string& s)
{
s.clern();
char ch = in.get();
//while (ch != '\n')//输入用空格也可以打印出来；
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}
}
扫一扫
393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
