string类
1.学习string类
C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
2.标准库中的string类
string类的文档介绍
string是表示字符串的字符串类
3.string类的常用接口及模拟实现
3.1string类对象的常见构造
string(const char* str = "")
: _capacity(strlen(str))
, _size(_capacity)
{
_str = new char[_capacity + 1];
strcpy(_str, str);
}
string(const string& str)
: _size(0)
, _capacity(0)
, _str(nullptr)
{
string temp(str._str);
swap(temp);
}
//两种方法都可以
/*string(const string& str)
{
_str = new char[str._capacity + 1];
strcpy(_str, str._str);
_size = str._size;
_capacity = str._capacity;
}*/3.2string类对象的容量操作
size_t size() const
{
return _size;
}
size_t length() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
bool empty() const
{
return _size == 0;
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* temp = new char[n + 1];
strcpy(temp, _str);
delete[] _str;
_str = temp;
_capacity = n;
}
}
void resize(size_t n, char c = '\0')
{
if (n > _size)
{
reserve(n);
for (size_t i = _size; i < n; i++)
{
_str[i] = c;
}
}
_str[n] = '\0';
_size = n;
}
注意：
1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。
3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小
3.3string类对象的访问及遍历操作
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
//迭代器
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
3.4string类对象的修改操作
void Push_back(char c)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size++] = c;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t len = strlen(str);
if (len + _size > _capacity)
{
reserve(len + _size);
}
strcat(_str, str);
_size += len;
_str[_size] = '\0';
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
string& operator+=(const char c)
{
Push_back(c);
return *this;
}
const char* c_str() const
{
return _str;
}
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;
}
}
return nops;
}
size_t find(const char* s, size_t pos = 0) const
{
assert(pos < _size);
const char* p = strstr(_str + pos, s);
if (p)
{
return p - _str;
}
else
{
return nops;
}
}
string substr(size_t pos, size_t len = nops)
{
assert(pos);
string s;
size_t end = pos + len;
if (len == nops || len + pos >= _size)
{
len = _size - pos;
end = _size;
}
s.reserve(len);
for (size_t i = pos; i < end; i++)
{
s += _str[pos];
}
return s;
}
4.深拷贝问题
4.1 经典的string类问题
// 为了和标准库区分，此处使用String
class String
{
public:
String(const char* str = "")
{
if (nullptr == str)
{
assert(false);
return;
}
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
~String()
{
if (_str)
{
delete[] _str;
_str = nullptr;
}
}
private:
char* _str;
};
// 测试
void TestString()
{
String s1("hello bit!!!");
String s2(s1);
}String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。
4.2传统写法的拷贝构造/赋值重载
String(const String& s)
: _str(new char[strlen(s._str) + 1])
{
strcpy(_str, s._str);
}
String& operator=(const String& s)
{
if (this != &s)
{
char* pStr = new char[strlen(s._str) + 1];
strcpy(pStr, s._str);
delete[] _str;
_str = pStr;
}
return *this;
}4.3现代写法的拷贝构造/赋值重载
String(const String& s)
: _str(nullptr)
{
String strTmp(s._str);
swap(_str, strTmp._str);
}
String& operator=(String s)
{
swap(_str, s._str);
return *this;
}其实就是复用其他函数，达到简化代码的目的，但是其实在效率上是没有任何区别。
5.写实拷贝
拷贝时，如果一直都是深拷贝，其实代价是比较大的，先开辟一个新空间，还要拷贝数据，使用写时拷贝就可以避免很多没有必要的深拷贝。
写时拷贝是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
当我们想修改的时候，就会进行深拷贝。也就是说，只有我们修改的时候，才会发生深拷贝，只读的话是不会发生深拷贝的。
6.string的模拟实现
namespace cola
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
//默认成员函数
string(const char* str = "")
: _capacity(strlen(str))
, _size(_capacity)
{
_str = new char[_capacity + 1];
strcpy(_str, str);
}
~string()
{
delete[] _str;
_str = nullptr;
_capacity = _size = 0;
}
string(const string& str)
: _size(0)
, _capacity(0)
, _str(nullptr)
{
string temp(str._str);
swap(temp);
}
string& operator=(string& temp)
{
swap(temp);
return *this;
}
/*string(const string& str)
{
_str = new char[str._capacity + 1];
strcpy(_str, str._str);
_size = str._size;
_capacity = str._capacity;
}*/
string& operator=(const string& str)
{
if (*this == str)
{
return *this;
}
char* temp = new char[str._capacity];
strcpy(temp, str._str);
delete[] _str;
_str = temp;
_size = str._size;
_capacity = str._capacity;
return *this;
}
//迭代器
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
//修改
void reserve(size_t n)
{
if (n > _capacity)
{
char* temp = new char[n + 1];
strcpy(temp, _str);
delete[] _str;
_str = temp;
_capacity = n;
}
}
void resize(size_t n, char c = '\0')
{
//扩容
if (n > _size)
{
reserve(n);
for (size_t i = _size; i < n; i++)
{
_str[i] = c;
}
}
_str[n] = '\0';
_size = n;
}
void Push_back(char c)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size++] = c;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t len = strlen(str);
if (len + _size > _capacity)
{
reserve(len + _size);
}
strcat(_str, str);
_size += len;
_str[_size] = '\0';
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
string& operator+=(const char c)
{
Push_back(c);
return *this;
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
void swap(string& str)
{
std::swap(_str, str._str);
std::swap(_size, str._size);
std::swap(_capacity, str._capacity);
}
bool empty() const
{
return _size == 0;
}
//返回私有成员
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
const char* c_str() const
{
return _str;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
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;
}
}
return nops;
}
size_t find(const char* s, size_t pos = 0) const
{
assert(pos < _size);
const char* p = strstr(_str + pos, s);
if (p)
{
return p - _str;
}
else
{
return nops;
}
}
string substr(size_t pos, size_t len = nops)
{
assert(pos);
string s;
size_t end = pos + len;
if (len == nops || len + pos >= _size)
{
len = _size - pos;
end = _size;
}
s.reserve(len);
for (size_t i = pos; i < end; i++)
{
s += _str[pos];
}
return s;
}
string& insert(size_t pos, char c)
{
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] = c;
++_size;
return *this;
}
string& insert(size_t pos, const char* str)
{
assert(pos < _size);
size_t len = strlen(str);
if (len + _size > _capacity)
{
reserve(len + _size);
}
size_t end = _size + len;
while (end >= pos + len)
{
_str[end] = _str[end - len];
end--;
}
for (size_t i = pos; i < pos + len; i++)
{
_str[i] = str[i - pos];
}
_size += len;
return *this;
}
string& erase(size_t pos, size_t len = nops)
{
assert(pos < _size);
if (len == nops || len + _size > _capacity)
{
_str[pos] = '\0';
_size = pos;
}
else
{
size_t i = pos;
while (i + len <= _size)
{
_str[i] = _str[i + len];
++i;
}
_size -= len;
}
return *this;
}
//比值
bool operator==(const string& str) const
{
return strcmp(_str, str._str) == 0;
}
bool operator!=(const string& str) const
{
return !(*this == str);
}
bool operator>(const string& str) const
{
return strcmp(_str, str._str) > 0;
}
bool operator>=(const string& str) const
{
return *this == str && *this > str;
}
bool operator<(const string& str) const
{
return !(*this > str) && !(*this == str);
}
bool operator<=(const string& str) const
{
return !(*this > str);
}
private:
char* _str;
size_t _capacity;
size_t _size;
const static size_t nops;
};
const size_t string::nops = -1;
ostream& operator<<(ostream& out, const string& s)
{
out << s.c_str();
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear();
char c;
char buff[128];
c = in.get();
size_t i = 0;
while (c != ' ' && c != '\n')
{
if (i == 127)
{
buff[i] = '\0';
s += buff;
i = 0;
}
buff[i++] = c;
c = in.get();
}
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
}