目录
浅拷贝与深拷贝
string的基本使用和模拟实现
浅拷贝与深拷贝
namespace lyl
{
class string
{
public:
string(const char* str)
:_str(new char[strlen(str)+1])
{
strcpy(_str, str);
}
~string()
{
delete[] _str;
_str = nullptr;
}
private:
char* _str;
};void test_string1()
{
string s1("hello world");
string s2(s1);//拷贝构造}
}
上述string类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块 空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。
s1和s2中的_str是同一块地址，即s1和s2指向的是同一块空间。
后定义的变量先析构，当s2生命周期结束后，s2调用析构函数，空间已经被销毁，s1所指向的空间就不存在了，s1就是一个野指针，s1生命周期结束也会调用析构函数，这时就会析构一块不存在的空间，造成程序崩溃。这时由于浅拷贝引起的，所以当涉及到资源申请时，我们需要用到深拷贝，在这里，拷贝构造函数和赋值重载一定是需要我们自己实现的，不能使用默认的。
浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
深拷贝 ：如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。（给每个对象独立分配资源，保证多个对象不会因共享资源而造成多次释放而造成程序崩溃）
//s2(s1) -----拷贝构造
string(const string& s)
:_str(new char[strlen(s._str)+1])
{
strcpy(_str, s._str);
}
string的基本使用和模拟实现
namespace lyl
{
class string
{
public://
private:
char* _str;
size_t _size;
size_t _capacity;static const size_t npos;
};const size_t string::npos = -1;
}
_size 是当前 vector 容器真实占用的大小，也就是容器当前拥有多少空间。
_capacity 是指在发生 realloc 前能允许的最大元素数，即预分配的内存空间。
构造函数
//构造函数
string(const char* str = "")
:_size(strlen(str)),
_capacity(_size)
{
_str = new char[_capacity + 1];
strcpy(_str, str);
}空字符串初始化不能写成string(const char* str = "\0") 或者string(const char* str = nullptr) 。
拷贝构造 s2(s1)
传统写法
string(const string& s)
:_size(s._size),
_capacity(s._capacity)
{
_str = new char[_capacity + 1];
strcpy(_str, s._str);
}现代写法（间接复用构造函数）
string(const string& s)
:_str(nullptr),
_size(0),
_capacity(0)
{
string tmp(s);
swap(tmp);
strcpy(_str, s._str);
}赋值重载（s1=s2）
传统写法
string& operator = (const string& s)
{
if (this != &s)
{
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}现代写法
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s);
swap(_str, tmp._str);
}
return *this;
}
/*string& operator=(string s)//传值传参调用拷贝构造
{
swap(s);
return *this;
}*/析构函数
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}c_str()
const char* c_str() const
{
return _str;
}size()
此函数用于以字节为单位返回字符串的长度。它定义了符合字符串对象内容的实际字节数，不一定等于容量。（有效字符的长度，不包含'\0'）
size_t size() const
{
return _size;
}[] 操作符
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
使用 [] 操作符访问容器内的对象，很可能出现数组越界的问题。
reserve() ---开辟空间
void reserve (size_t n = 0);
更改_str的容量。
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n+1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
对于 reserve(10) 后接着直接使用 [] 访问越界报错 。用at()是抛异常。
resize() ---开辟空间+初始化（如果不给初始化的值，初始化为0）
void resize (size_t n); void resize (size_t n, char c);
如果 n 小于字符串的长度，则将字符串长度缩短为 n 指定的长度，删除 n 之外的所有字符。
如果 n大于字符串的长度，则字符串长度扩展到 k 指定的长度。
- n:n 是第一个参数中指定的字符数。它调整字符串的大小，使字符串包含 k 个字符。
- c:如果 n 大于字符串的长度，则 c 是要添加到新空格中的新字符。是可选参数。
void resize(size_t n, char ch = '\0')
{
if (n <= _size)
{
_size = n;
_str[_size] = '\0';
}
else
{
if (n > _capacity)
{
reserve(n);
}
memset(_str + _size, ch, n - _size);
_size = n;
_str[_size] = '\0';
}
}
使用 resize() 容器内的对象内存空间是真正存在的。(_size)
使用 reserve() 仅仅只是修改了 _capacity 的值，容器内的对象并没有真实的内存空间(空间是"野"的)。
push_back(尾插字符)
void push_back(char ch)
{
/*if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';*/
insert(_size, ch);
}append() --- 追加字符串
void append(const char* str)
{
/*size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, str);
_size += len;*/
insert(_size, str);
}+=运算符重载
string& operator+=(char ch)
{
push_back(ch);
return *this;
}string& operator+=(const char* str)
{
append(str);
return *this;
}find()
寻找字符
size_t find(char ch)
{
for (size_t i = 0; i < _size; ++i)
{
if (ch == _str[i])
{
return i;
}
}
return npos;
}寻找字符串
size_t find(const char* s, size_t pos = 0)
{
const char* ptr = strstr(_str + pos, s);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr -_str;
}
}insert() ---头插
插入字符
string& insert(size_t pos, char ch)
{
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] = ch;
++_size;
return *this;
}插入字符串
string& insert(size_t pos, const char* s)
{
assert(pos <= _size);
size_t len = strlen(s);
if (_size + len > _capacity)
{
reserve(_size + len);
}
size_t end = _size + len;
while (end > pos)
{
_str[end] = _str[end - len];
--end;
}
strncpy(_str+pos, s, len);
return *this;
}erase()
string& erase(size_t pos = 0, size_t len = npos)
{
assert(pos < _size);
if (len == npos || pos+len >= _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
return *this;
}迭代器 （这里可以看做指向字符的一个指针）
begin()此函数提供对第一个元素的引用。
iterator it = s.begin();
typedef char* iterator;
typedef const char* const_iterator;
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
iterator begin()
{
return _str;
}
iterator end()
{
return _str+_size;
}clear() 函数删除元素，变成一个空字符串。
void clear()
{
_str[0] = '\0';
_size = 0;
}运算符重载
// "abcd" "abcd" false
// "abcd" "abcde" true
// "abcde" "abcd" false
bool operator<(const string& s1, const string& s2)
{
/*size_t i1 = 0, i2 = 0;
while (i1 < s1.size() && i2 < s2.size())
{
if (s1[i1] < s2[i2])
{
return true;
}
else if (s1[i1] > s2[i2])
{
return false;
}
else
{
++i1;
++i2;
}
}
return i2 < s2.size() ? true : false;*/
return strcmp(s1.c_str(), s2.c_str()) < 0;
} bool operator==(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator<=(const string& s1, const string& s2)
{
return s1 < s2 || s1 == s2;
}
bool operator>(const string& s1, const string& s2)
{
return !(s1 <= s2);
}
bool operator>=(const string& s1, const string& s2)
{
return !(s1 < s2);
}
bool operator!=(const string& s1, const string& s2)
{
return !(s1 == s2);
}<< 流输出
ostream& operator<<(ostream& out, const string& s)
{
/*for (auto ch : s)
{
out << ch;
}*/
for (size_t i = 0; i < s.size(); ++i)
{
out << s[i];
}
//out << s.c_str(); // 不能这么写
return out;
}>>流提取
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch = in.get();
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}rbegin() 函数代表反向开始。该函数用于指向字符串的最后一个字符。它返回指向字符串最后一个字符的反向迭代器。
rend() 函数代表反向结束。该函数指向字符串的第一个字符。它返回一个指向字符串开头的反向迭代器。
empty()函数检查字符串是否为空。函数返回一个布尔值 true 或 false。
