核心接口的基本实现：
1.插入：在STL中，其实是实现了很多关于插入的接口的，比如：但是我们从学习的角度而言没必要太过于深入的去契合源码的，所以在这里我就只是简单的模拟了库里的几个插入接口，这几个接口也是平时比较常用的。
(1):string的底层其实是一个字符数组实现的，所以STL中也对string重载了[]，在这里模拟插入接口我直接用的是下标，也就没有用迭代器位置去模拟实现了。
Insert接口：1、插入一个字符。
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);//模拟一个扩容机制，STL中是用的空间配置器
}
//挪动数据
int end = _size;
while ((int)pos <= end)
{
_str[end + 1] = _str[end];
--end;
}
_str[pos] = ch;
++_size;
return *this;
}2、插入字符串。
string& insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);//模拟实现时单独给一个命名空间，这样可以更好的与库进行切换测试和调用
if (_capacity < len + _size)
{
reserve(len + _size);
}
//挪动数据
size_t end = len + _size;
while (pos + len <= end)
{
_str[end] = _str[end - len];
--end;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}(2):push_back:在字符串的末尾插入单个字符或字符串 。大致思路：直接找到当前字符串的末尾位置，先预判空间是否够，如果不够就扩容，然后直接将插入字符串拷贝到当前字符串的末尾即可，最后字符串的末尾给一个'\0'表示该字符的结尾
void push_back(const char* str)
{
size_t len = strlen(str);
if (_capacity < len + _size)
{
reserve(len + _size);
}
strcpy(_str + _size, str);
_size += len;
_str[_size] = '\0';
}插入单个字符：
void push_back(char ch)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}（3）：重载+=即operator+=()。前面实现了push_back()以后这里的operator+=()是完全可以复用之前的代码的，这里之所以实现operaotr+=()是为了更加简洁的使用尾插。
插入单个字符：
string& operator+=(char ch)
{
push_back(ch);
return *this;
}插入字符串：
string& operator+=(const char* str)
{
push_back(str);
return *this;
}2、删除操作：删除的接口相对插入少了几个，也比插入简单，我自己的实现就是直接覆盖删除，相对STL比较简洁。大致思路：如果要删除的位置就是字符串的长度，那直接在该位置给一个'\0',或者要删除的长度大于当前字符串的长度那也是直接在该位置给一个'\0',否则给一个需要删除的位置和需要删除的长度进行覆盖式的删除就好了。
void erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
if (len == pos || len + pos > _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);//覆盖之前的数据就好了
_size -= len;
}
}3、查找，直接遍历整个字符数组就好了，如果找到所需查找的字符或字符串那就返回下标，否则返回-1。
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);
const char* ptr = strstr(_str + pos, sub);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}4、重载operator[](),这个接口提供的是一个更加简洁的访问元素的方式，就像访问数组元素一样的访问方式，在C++中其实也间接的体现了面向对象语言特性之一，即封装，只要重载了这个操作符，从使用的角度而言，使用者也不用太关心这个类的底层是怎么实现的，就直接像数组一样去访问元素就行了，大大降低了使用成本（不用过多的暴露底层原理，使得程序更具有安全性）
const char& operator[](const size_t pos)const//普通对象调用----权限缩小
{
assert(pos < _size);
return _str[pos];
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}二、迭代器，迭代器作为STL的六大组件之一，在算法和容器之间搭建了一座桥梁，相对string而言，其实也算是一个比较特殊的容器，它是专门用来存储字符串的容器，当要使用到一些官方库的算法对string里面的数据进行操作时，那迭代器无疑时提供了一作沟通的桥梁。注：这里没有实现反向迭代器，其实反向迭代器的原理与正向迭代器是一样的，只是起始位置不一样而已。
typedef char* ietrator;
typedef const char* const_ietrator;
ietrator begin()
{
return _str;
}
ietrator end()
{
return _str + _size;
}
const_ietrator begin()const
{
return _str;
}
const_ietrator end()const
{
return _str + _size;
}三、拷贝问题。拷贝是大多数类都会涉及的问题，对于拷贝构造，我们不实现编译器会自动生成拷贝构造，这是C++的语法特性，但是对于string这样的类，编译器默认生成的拷贝构造是不够用的，因为编译器默认生成的是浅拷贝，而string类可能会涉及到深拷贝问题,其次浅拷贝可能会导致同一块空间可能会被释放多次的问题，这样就会导致程序运行崩溃，是危险的!所谓的深拷贝就是跟需要拷贝的对象开一个一样大的空间，然后把数据拷到新空间去，再释放旧空间，这样就不会有同一块空间被释放多次的问题（c++11之前的做法：深拷贝）
深拷贝在浅拷贝的基础上做了一些改造，拷贝对象和被拷贝对象各自使用一快空间，这样析构的时候就不会有一块空间被释放多次的问题
移动构造：移动构造的本质是将参数右值的资源窃取过来，占为己有，那么就不用做深拷贝了，所以它叫移动构造，就是窃取别人的资源来构造自己。相比于C++11之前在拷贝这个环节，移动构造的拷贝效率提高了不少，因为特定的情况下它不用访问操作系统去申请空间，或者说不用去向空间配置器申请空间。
总结
以上就是string类的一些基本框架，相比于STL来说还是简单了很多，STL对这个类的实现封装了很多算法和一些比较复杂的接口，比如说空间配置器、和更加完善的迭代器等，但是我们从学习的维度来看待，需要知道STL实现string有哪些重要的接口就行了，实实在在的需要使用它的时候可以结合C++官方文档或者第三方库更好更严谨的使用它！
string类模拟代码实现
#include<iostream>
#include<assert.h>
using namespace std;
namespace Mystring
{
class string
{
public:
typedef char* ietrator;
typedef const char* const_ietrator;
ietrator begin()
{
return _str;
}
ietrator end()
{
return _str + _size;
}
const_ietrator begin()const
{
return _str;
}
const_ietrator end()const
{
return _str + _size;
}
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
~string()
{
delete[]_str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
void swap(string& tmp)
{
::swap(_str, tmp._str);//调用全局域的swap
::swap(_size, tmp._size);
::swap(_capacity, tmp._capacity);
}
string(const string& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
string tmp(s._str);//调用构造
swap(tmp);//调用void swap(string& tmp)方法，这个swap是自己实现的
}
////浅拷贝
//string(const string& s)
// :_str(s._str)
// , _size(s._size)
// , _capacity(s._capacity)
//{
// strcpy(_str, s._str);
//}
// 移动构造
string(string&& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(string&& s) -- 移动语义" << endl;
swap(s);
}
string& operator=(string& s)
{
if (this != &s)
swap(s);
return *this;
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
const char& operator[](const 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 (_capacity < n)
{
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';
}
void push_back(const char* str)
{
size_t len = strlen(str);
if (_capacity < len + _size)
{
reserve(len + _size);
}
strcpy(_str + _size, str);
_size += len;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t len = strlen(str);
if (_capacity < len + _size)
{
reserve(len + _size);
}
strcpy(_str + _size, str);
_size += len;
}
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);
}
//挪动数据
int end = _size;
while ((int)pos <= end)
{
_str[end + 1] = _str[end];
--end;
}
_str[pos] = ch;
++_size;
return *this;
}
string& insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
if (_capacity < len + _size)
{
reserve(len + _size);
}
//挪动数据
size_t end = len + _size;
while (pos + len <= end)
{
_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 == pos || len + pos > _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);//覆盖之前的数据就好了
_size -= len;
}
}
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);
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 || len + pos > _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 !(*this > s);
}
bool operator==(const string& s)const
{
return strcmp(_str, s._str) == 0;
}
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);
}
//清理数据
void clear()
{
_str[0] = '\0';
_size = 0;
}
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;
}
}
扫一扫
到【灌水乐园】发言
