文章目录
string是一个类，表示字符序列，也就是字符串类。
相较于C语言的字符串有着更便利更丰富的接口，可以通过调用接口直接实现对应功能。
常用接口
push_back：在字符串末尾插入一个字符
append：在字符串后追加一个字符串
string支持[]随机访问
string支持直接使用 + += 追加字符串或字符
c_str：返回C类型的字符串
string支持 >> << 输入输出流的重载使用
string的输入流不会将空格输入，需要用到getline接口才可获取一整行字符串
string支持迭代器，其迭代器的底层为原生指针。可通过迭代器直接访问元素
在使用的过程中如果遇到某些功能接口不记得的，可以到C官网查询。
模拟实现string类
需要注意以下几点：
- string是一个类，因此构造函数需要写好。其具备无参构造，有参构造，拷贝构造，赋值构造，迭代器区间构造，指定起始位置和长度的拷贝构造，指定字符和个数的直接构造
- string的底层可以用C的原生指针实现，因为需要申请空间。可自行实现析构函数
- 成员变量可以有一个C类型的原生指针，一个整型表示字符串长度，一个整形表示空间大小
- 迭代器直接用指针实现，begin()指向第一个元素，end()指向最后一个元素的下一位置
- 因为是动态申请空间所以需要关心到扩容问题，如果当前字符串长度 >= 空间大小时就需要扩容。因为Ｃ＋＋中没有原地扩容的概念，因此每一次扩容都要将原空间的元素拷贝到新开辟的空间再进行使用。
- 每一次的插入删除都需要更新字符串长度变量和空间大小变量
- 插入一个字符可以直接判断是否需要扩容。插入一个字符串则需要将两字符串长度相加与空间大小比较
代码
class String {
public:
//普通构造函数
String()
:_str(nullptr)
,_size(0)
,_capacity(0)
{}
//拷贝构造函数
String(const String& str) {
_str = new char[str._capacity + 1];
_size = str._size;
_capacity = str._capacity;
strcpy(_str, str._str);
}
//指定起始位置和长度拷贝构造函数
String(const String& str, size_t pos, size_t len = string::npos){
if (len == -1) {
_str = new char[str._size - pos + 1];
_capacity = str._size - pos;
while (str._str[pos])
_str[_size++] = str._str[pos++];
_str[_size] = '\0';
}
else {
_str = new char[len - pos + 1];
_capacity = len - pos;
while (pos != len)
_str[_size++] = str._str[pos++];
_str[_size] = '\0';
}
}
//拷贝字符串构造函数
String(const char* s) {
size_t len = strlen(s);
_str = new char[len + 1];
_capacity = len;
_size = len;
strcpy(_str, s);
}
//拷贝字符串指定长度构造函数
String(const char* s, size_t n) {
_str = new char[n + 1];
int i = 0;
while (i != n) {
_str[_size++] = s[i++];
}
_str[_size] = '\0';
_capacity = n;
}
//指定字符和个数构造函数
String(size_t n, char c) {
_str = new char[n + 1];
_capacity = n;
while (_size != n)
_str[_size++] = c;
_str[_size] = '\0';
}
//迭代器区间构造函数
template <class InputIterator>
String(InputIterator first, InputIterator last) {
_str = new char[last - first + 1];
_capacity = last - first;
while (first != last) {
_str[_size++] = *first;
first++;
}
_str[_size] = '\0';
}
//析构函数
~String() {
_capacity = 0;
_size = 0;
delete[] _str;
_str = nullptr;
}
//迭代器
typedef char* iterator;
typedef const char* const_iterator;
iterator begin() {
return _str;
}
iterator end() {
return _str + _size;
}
iterator rbegin() {
return _str + _size;
}
iterator rend() {
return _str;
}
const_iterator cbegin() const{
return _str;
}
const_iterator cend() const{
return _str + _size;
}
const_iterator crbegin() const{
return _str + _size;
}
const_iterator crend() const{
return _str;
}
//扩容
//每一次扩容两倍
void expansion() {
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
if (_str == nullptr)
_str = new char[newcapacity + 1];
else {
//将原空间元素拷贝至新空间
//释放原空间再指向新空间
char* newstr = new char[newcapacity + 1];
strcpy(newstr, _str);
delete[] _str;
_str = newstr;
}
//更新空间大小
_capacity = newcapacity;
}
//插入
void push_back(char c) {
//扩容
if (_size == _capacity)
expansion();
_str[_size++] = c;
_str[_size] = '\0';
}
//尾删
void pop_back() {
_str[--_size] = '\0';
}
//指定起始位置和长度删除
String& erase(size_t pos = 0, size_t len = string::npos) {
if (len == string::npos) {
_str[pos] = '\0';
_size = pos;
}
else {
int n = pos + len;
for (int i = n; n < _size; ++n) {
_str[pos++] = _str[n];
}
_size -= len;
_str[_size] = '\0';
}
return *this;
}
//指定迭代器位置删除
iterator erase(iterator p) {
iterator pp = p;
while (p != end()) {
*p = *(p + 1);
++p;
}
_str[--_size] = '\0';
return pp;
}
//指定迭代器区间删除
iterator erase(iterator first, iterator last) {
assert(first < last);
iterator pp = first;
while (last != end()) {
*first = *last;
++first;
++last;
}
*first = '\0';
_size -= (last - first);
return pp;
}
//在指定位置前插入字符串
String& insert(size_t pos, const String& s) {
assert(pos <= _size);
//判断扩容
int len = _size + s._size;
while(_capacity < len)
expansion();
int n = pos;
for (int i = 0; i < s._size; ++i)
_str[n + s._size] = _str[n++];
for (int i = 0; i < s._size; ++i)
_str[pos++] = s._str[i];
_size = len;
_str[_size] = '\0';
return *this;
}
//在指定位置前插入字符
String& insert(size_t pos, const char c) {
assert(pos <= _size);
//判断扩容
if (_capacity == _size)
expansion();
for (int i = _size; i > pos; --i)
_str[i] = _str[i - 1];
_str[pos] = c;
++_size;
_str[_size] = '\0';
return *this;
}
//在指定位置前插入指定字符串的指定起始位置指定长度的子串
String& insert(size_t pos, const String& str, size_t subpos, size_t sublen) {
assert(pos <= _size);
if (sublen > str._size - subpos)
sublen = str._size - subpos;
while (_capacity < _size + sublen)
expansion();
for (int i = _size - 1; i >= pos; --i)
_str[i + sublen] = _str[i];
for (int i = 0; i < sublen; ++i)
_str[pos++] = str._str[subpos++];
_size += sublen;
_str[_size] = '\0';
return *this;
}
//在指定位置前插入指定个数的指定字符
String& insert(size_t pos, size_t n, const char c) {
assert(pos <= _size);
while (_capacity < _size + n)
expansion();
for (int i = _size - 1; i >= pos; --i)
_str[i + n] = _str[i];
for (int i = 0; i < n; ++i)
_str[pos++] = c;
_size += n;
_str[_size] = '\0';
return *this;
}
//在指定位置前插入指定迭代器区间的字符串
template <class InputIterator>
void insert(size_t pos, InputIterator first, InputIterator last) {
assert(pos <= _size);
int len = last - first;
while (_capacity < _size + len)
expansion();
for (int i = _size - 1; i >= pos; --i)
_str[i + len] = _str[i];
for (int i = 0; i < len; ++i) {
_str[pos++] = *first;
++first;
}
_size += len;
_str[_size] = '\0';
}
//返回C指针
const char* c_str() const{
return _str;
}
//返回有效字符长度
const size_t size() const{
return _size;
}
const size_t length() const{
return _size;
}
//返回容量大小
const size_t capacity() const{
return _capacity;
}
//清空内容
void clear() {
_str[0] = '\0';
_size = 0;
}
//判空
bool empty() {
return _size == 0;
}
//重载[]
char& operator[](size_t pos) {
assert(pos < _size);
return _str[pos];
}
const char& operator[](size_t pos) const {
assert(pos < _size);
return _str[pos];
}
//重载+=
String& operator+=(String& s) {
while (_capacity < _size + s._size)
expansion();
for (auto e : s)
_str[_size++] = e;
_str[_size] = '\0';
return *this;
}
String& operator+=(char c) {
if (_capacity == _size)
expansion();
_str[_size++] = c;
_str[_size] = '\0';
return *this;
}
String& operator+=(const char* s) {
if (_capacity < _size + strlen(s))
expansion();
for (int i = 0; i < strlen(s); ++i)
_str[_size++] = s[i];
_str[_size] = '\0';
return *this;
}
//交换
void swap(String& s) {
std::swap(_str, s._str);
std::swap(_capacity, s._capacity);
std::swap(_size, s._size);
}
//将有效字符的个数该成n个，多出的空间用字符c填充
void resize(size_t n) {
while (_capacity < n)
expansion();
if (n <= _size) {
_str[n] = '\0';
_size = n;
}
}
void resize(size_t n, char c) {
while (_capacity < n)
expansion();
if (n <= _size) {
_str[n] = '\0';
_size = n;
}
else {
while (_size < n)
_str[_size++] = c;
_str[_size] = '\0';
}
}
//比较大小
bool operator<(const String& s) {
if (strcmp(this->c_str(), s.c_str()) < 0)
return true;
else
return false;
}
bool operator<=(const String& s) {
if (strcmp(this->c_str(), s.c_str()) <= 0)
return true;
else
return false;
}
bool operator>(const String& s) {
if (strcmp(this->c_str(), s.c_str()) > 0)
return true;
else
return false;
}
bool operator>=(const String& s) {
if (strcmp(this->c_str(), s.c_str()) >= 0)
return true;
else
return false;
}
bool operator==(const String& s) {
if (strcmp(this->c_str(), s.c_str()) == 0)
return true;
else
return false;
}
bool operator!=(const String& s) {
if (strcmp(this->c_str(), s.c_str()) != 0)
return true;
else
return false;
}
private:
char* _str;
size_t _size;
size_t _capacity;
};
//流输入\输出
ostream& operator<<(ostream& out, const String& s) {
for (int i = 0; i < s.size(); i++)
out << s[i];
return out;
}
istream& operator>>(istream& in, String& s) {
s.clear();
char butt[128] = { '\0' };
size_t i = 0;
char c = in.get();
while (c != ' ' && c != '\n') {
if (i == 127) {
s += butt;
i = 0;
}
butt[i++] = c;
c = in.get();
}
if (i > 0) {
butt[i] = '\0';
s += butt;
}
return in;
}
扫一扫
1143
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
