实现string类的框架
namespace zyy
{
class string
{
friend ostream& operator<<(ostream& _cout, const zyy::string& s);
friend istream& operator>>(istream& _cin, zyy::string& s);
public:
typdef const char* const_iterator;
typedef char* iterator;
public:
string(const char* str = "");
string(const string& s);
string& operator=(const string &s);
~string();
//
// iterator
iterator begin();
iterator end();
/
// modify
void push_back(char c);
string& operator+=(char c);
void append(const char* str);
string& operator+=(const char* str);
void clear();
void swap(string& s);
const char* c_str()const;
/
// capacity
size_t size()const
size_t capacity()const
bool empty()const
void resize(size_t n, char c = '\0');
void reserve(size_t n);
/
// access
char& operator[](size_t index);
const char& operator[](size_t index)const;
/
//relational operators
bool operator<(const string& s);
bool operator<=(const string& s);
bool operator>(const string& s);
bool operator>=(const string& s);
bool operator==(const string& s);
bool operator!=(const string& s);
// 返回c在string中第一次出现的位置
size_t find (char c, size_t pos = 0) const;
// 返回子串s在string中第一次出现的位置
size_t find (const char* s, size_t pos = 0) const;
// 在pos位置上插入字符c/字符串str，并返回该字符的位置
string& insert(size_t pos, char c);
string& insert(size_t pos, const char* str);
// 删除pos位置上的元素，并返回该元素的下一个位置
string& erase(size_t pos, size_t len);
private:
char* _str;
size_t _capacity;
size_t _size;
public:
const static size_t npos;
}
const size_t string::npos = -1;
}；
string构造函数、拷贝构造、赋值、析构
- 传递空字符串的情况
string(const char* str = "")
:_str(new char[strlen(str) + 1]) //用初始化列表初始化，也可以用函数体内赋值
, _capacity(strlen(str))
, _size(strlen(str))
//使用初始化列表的注意点：定义顺序与声明的顺序保持一致
{
//做完上述的初始化工作之后，不要忘了把str赋值给新的_str
strcpy(_str, str);
}
- 拷贝构造
string(const string& s)
:_str(new char[s.capacity() + 1])
, _capacity(s.capacity())
, _size(s.size())
//初始化列表部分和上面一样
{
memcpy(_str, s._str, _size + 1);
//这里之所以用memcpy而不用strcpy，是因为传递的是string
//而string是在size位置结束，char是在'\0'处结束
//strcpy拷贝到'\0'截止，memcpy拷贝到size结束
}
- 赋值
3.1 第一版本
直接异地拷贝，首先用tmp新开一个空间，把s._str全部拷贝给tmp，最后把tmp再拷贝给_str。
string& operator=(const string& s)
{
//实现深拷贝
//逻辑和扩容resize()的逻辑一样
if (*this != s)
{
char* tmp = new char[s._capacity + 1];
memcpy(tmp, s._str, s._size + 1);
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}
3.2第二版本
调用拷贝构造，将tmp拷贝为s，再交换每个成员变量。tmp是临时变量，处作用域自动销毁。
相较于第一版本，优点是不需要再自己去申请空间，直接复用了拷贝构造函数。
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s); //调用拷贝构造
std::swap(_str, tmp._str);
std::swap(_size, tmp._size);
std::swap(_capacity, tmp._capacity);
}
return *this;
}
3.3 第三版本
为了实现第三个版本，需要先实现一个swap函数，作用是可以一个函数直接全部交换string类的全部成员变量。
//假设s1拷贝为s3, 传值string tmp 此时tmp是s3的拷贝构造 tmp改变不影响s3，
string& operator=(string tmp)
{
//tmp是局部变量，s1的所有东西都给了tmp,最后tmp全部销毁
swap(tmp);
return *this;
}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
- 析构
~string()
{
delete[] _str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
iterator迭代器的内容
迭代器比较简单，但是需要注意的是，不仅需要typededf char* iterator,还需要typedef const char* const_iterator。
因为在流插入和流提取的时候，用const string& s作为第二操作数的时候，auto it = s.begin() 中 s.begin()的返回值是const_iterator。
iterator begin()
{
return _str; //iterator == char*
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str;
}
capacity 改变容量的函数
reserve()
参照std库里的reserve函数实现
void reserve(size_t n)
{
//异地扩容
//如果n < _capacity 不改变
if (n > _capacity)
{
char* tmp = new char[n + 1]; // +1是因为后面有'\0'
memcpy(tmp, _str, n + 1);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
resize()
库里resize函数的意思是：
如果n < _size,那么就抹除大于n的下标的数据；
如果 n < _size ,就需要扩容，并且把后面的补上c ,如果c没有赋值，就补空字符’\0’，如果给了，就赋给的值。
void resize(size_t n, char c = '\0') //char c = '\0'是缺省
{
if (n < _size)
{
_size = n;
_str[_size] = '\0';
}
else
{
reserve(n);
for (int i = _size; i < n; i++)
{
_str[i] = c;
}
_size = n;
_str[_size] = '\0';
}
}
size()
size_t size()const
{
return _size;
}
capacity()
size_t capacity()const
{
return _capacity;
}
empty()
bool empty()const
{
if (_size == 0)
return true;
return false;
}
Modify 操作类函数
push_back()
从字符串的末尾插入一个字符
void push_back(char c)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = c;
_size++;
_str[_size] = '\0';
}
append()
在字符串的尾部插入一个字符串。
逻辑与push_back()类似，但是需要注意扩容的长度。
void append(const char* str)
{
size_t n = strlen(str);
if (_size + n > _capacity)
{
reserve(_size + n);
}
strcpy(_str + _size, str);
_size += n;
}
operator+=（）
直接复用就行
string& operator+=(char c)
{
push_back(c);
//注意这里的返回值是string& 所以需要返回*this
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
clear()
void clear()
{
_str[0] = '\0';
_size = 0;
}
c_str()
const char* c_str() const
{
return _str;
}
access
operator[]
char& operator[](size_t index)
{
assert(index < _size);
//判断index的合法性
return _str[index];
}
const char& operator[](size_t index)const
{
assert(index < _size);
return _str[index];
}
relation operators
operator <
1.第一版本
string比较大小不是比较长度，而是比较ascall码。
比较字符串的大小，除了最普遍的情况：某一个字符串不相等，最后比较大小出结果。
还有下面这种情况：
-
"hello" 和 "hello" return false; -
"hello" 和 "helloxxx" return false; -
"helloxxx" 和 "hello" return true;
基于这些情况，设计代码的思路就是：
先比较短的字符串，如果短的字符串就能比较出结果，例如’‘aaa’'和“bb‘比较，就直接返回比较结果。
如果不能比较出结果，例如刚才举例的三种结果，就接着比较字符串长度就行。 - - - 这个时候已经跳出循环了，就代表着一定有一个结束条件起效了。
如果是i1 < _size这个条件违背了，就代表，i1走到了字符串的末尾，就对应着举例的三种情况的前两种，则返回false。 否则返回true。
bool operator<(const string& s)
{
size_t i1 = 0;
size_t i2 = 0;
//先比较短的
while (i1 < _size && i2 < s._size)
{
if (_str[i1] > _str[i2])
{
return false;
}
else if (_str[i1] < _str[i2])
{
return true;
}
i1++;
i2++;
}
//走到这一步就代表循环结束，有三种可能，
//第一种：i1走到结尾i2未结束 return false
//第二种：i2走到结尾i1未结束 return true
//第三种：i1和i2都走到结尾 return false
if (i1 == _size && i2 != s._size)
{
return true;
}
return false;
}
2.第二版本
bool operator<(const string& s)
{
//首先比较前面的短的字符是不是相等 下面显示特殊情况，其他情况都能比较出来
//"hello" "hello" ret = 0;
//"hello" "helloxxx" ret = 0;
//"helloxxx" "hello" ret = 0;
int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
//"aa"和"bb"比较 ret = -1;
//如果ret == 0代表和上面举例的特殊情况相同，则需要进行下一步比较
//"hello" "hello" return false;
//"helloxxx" "hello" return false;
//"hello" "helloxxx" return true;
return ret == 0 ? _size < s._size : ret < 0;
//只有当 _size < s._size 的时候 return true;
//其他时候如果ret < 0就代表比较的字符 _str < s 应该返回true ----> 推出ret < 0 返回 true
}
operator其他函数
基本都是直接复用
bool operator<=(const string& s)
{
return *this < s || *this == s;
}
bool operator>(const string& s)
{
return !(*this <= s);
}
bool operator>=(const string& s)
{
return !(*this < s);
}
bool operator==(const string& s)
{
return _size == s._size
&& memcmp(_str, s._str, _size) == 0;
}
bool operator!=(const string& s)
{
return !(*this == s);
}
find()
1.找字符
//返回c在string中第一次出现的位置
size_t find(char c, size_t pos = 0) const
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == c)
{
return i;
}
}
//npos是 -1
return npos;
}
- 找字符串
//返回子串s在string中第一次出现的位置
size_t find(const char* s, size_t pos = 0) const
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, s);
if (ptr)
{
return ptr - _str;
}
else
{
return npos;
}
}
insert()
1.在pos位置上插入字符c/字符串str，并返回该字符的位置
// 在pos位置上插入字符c/字符串str，并返回该字符的位置
string& insert(size_t pos, char c)
{
assert(pos <= _size);
if (_size + 1 > _capacity)
{
reserve(_size + 1);
}
size_t end = _size;
//这里很重要，为什么要写end != npos,因为end是size_t类型
//当end == 0的时候进入循环，下次end--之后，end就变成-1
//但是因为end = size_t类型，-1就变成了最大值，造成死循环
while (end >= pos && end != npos) //_size_t 和 int 不同，会整型提升
{
//挪动数据
_str[end + 1] = _str[end];
end--;
}
_str[pos] = c;
_size = _size + 1;
return *this;
}
2.在pos位置插入字符串
string& insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t n = strlen(str);
if (n + _size > _capacity)
{
reserve(n + _size);
}
size_t end = _size;
//这里和上述一样
while (end >= pos && end != npos)
{
//挪动到end + n的位置，因为是字符串
_str[end + n] = _str[end];
--end;
}
for (size_t i = 0; i < n; i++)
{
_str[pos + i] = str[i];
}
_size = _size + n;
return *this;
}
erase()
// 删除pos位置上的元素，并返回该元素的下一个位置
string& erase(size_t pos, size_t len)
{
//判断pos的合理性
assert(pos <= _size);
//这里表示的意思是：从pos位置一直删完
if (len == npos || pos + len >= _size)
{
_str[pos] = '\0';
_size = pos;
_str[_size] = '\0';
}
else
{
//从pos + len位置往前挪动
size_t end = pos + len;
while (end <= _size)
{
_str[pos++] = _str[end++];
}
_size = _size - len;
}
return *this;
}
1266
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
