构造和析构深拷贝赋值swap的区别实现遍历c_str()迭代器string完整代码
构造和析构首先得在我们自己的命名空间避免冲突，再完成构造和析构函数
namespace cl
{
class string
{
public:
//整体思路：在构造函数的时候，开空间把数据拷贝拷贝过来，存储在动态开辟的字符串,待会增删查改都方便
//size_t strlen(const char* str);
string(const char* str)
:_str(new char[strlen(str) + 1])//strlen不会计算到' '，所以会加1
{
strcpy(_str, str);//char * strcpy ( char * destination, const char * source );
}
~string()
{
delete[] _str;
_str = nullptr;
}
private:
char* _str;
};
void test_string1()
{
string s("hello world");
}
}
我们知道拷贝构造是默认的成员函数，不写编译器会默认生成一份
编译器生成的拷贝构造，对于内置类型会完成值拷贝(浅拷贝–把每个字节依次拷贝)，对于自定义类型会调用它的拷贝构造
void test_string1()
{
string s1("hello world");
string s2(s1);
}
因此，s1中的_str拷贝给了s2,s2中的_str和s1中的_str指向同一块空间
所以出了作用域会调用析构函数(后定义的先析构)，所以s2先调用析构函数把_str指向的空间释放了，s1再调用析构时，一个空间就被释放两次，这是矛盾的
浅拷贝可以理解为丝毫不变的把成员变量按字节依次拷贝过来
深拷贝就是更深层次的拷贝，不是拷贝成员变量，而是拷贝它指向的空间
模拟实现string也得写自己的拷贝构造
//s2(s1)
string(const string& s)//取s1的别名类型是const string&
:_str(new char[strlen(s._str) + 1])//先开一个一样大的空间
{
strcpy(_str, s._str);//再把值都拷贝过来
}
这样s1,s2指向的空间就不一样了
深拷贝的现代写法
跟上面传统的拷贝构造不同，我们相当于接了个项目，给员工A做，做完之后交给客户获得佣金，再分一部分给员工A
//s2(s1)复用了构造函数
string(const string& s)
:_str(nullptr)//先把s2的_str置空，不置空的话，和tmp._str交换后，tmp调用析构函数会报错
{
string tmp(s._str);//tmp调用带参的构造函数
swap(_str, tmp._str);//交换后，s2的_str就指向原先tmp._str的空间
}
赋值
赋值跟拷贝构造类型，调用默认的拷贝构造就是浅拷贝，所以我们要深拷贝
//s3=s1,把s3赋值给s1
string& operator=(const string& s)
{
if (this != &s)//这个是用来预防s3=s3;的情况
{
//先把s1本身的空间释放，再开一个和s3一样大的空间，最后深拷贝
delete[] _str;
_str = new char[strlen(s._str) + 1];
strcpy(_str, s._str);
}
//if (this != &s)//这个是用来预防s3=s3;的情况
//{
// //先看能不能申请到空间
// char* tmp = new char[strlen(s._str) + 1];
// strcpy(tmp, s._str);
// delete[] _str;
// _str = tmp;
//}
return *this;
}
现代写法
拷贝复用了拷贝构造，释放复用了析构函数
//s1=s3，现代写法
string& operator=(const string s)
{
if (this != &s)
{
string tmp(s);//拷贝构造，tmp就跟s3有一样的空间和值
swap(_str, tmp._str);//s1就拿到tmp的空间，tmp拿到s1的空间
//tmp是局部变量，出了作用域会调用析构函数，就把原来s1的空间释放了
//最后s1就有和s3一样大的空间，一样大的值
}
return *this;
}
swap的区别
函数模板里的swap和string提供的swap的区别
std::string s1("hello world");
std::string s2("123455");
s1.swap(s2);//效率高--仅仅是对成员变量进行交换即可
swap(s1, s2);//代价很大--进行了三次深拷贝
实现遍历
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];//可读可写
}
const char& operator[](size_t pos) const//遍历const类型的
{
return _str[pos];//可读不可写
}
c_str()
cout << s1 << endl;
cout << s1.c_str() << endl;
大部分情况下，上面两种写法是一样的
但是如果中间加了字符’ ’就不一样了
这里string的迭代器的实现就可以看作指针,而链表等则不是
//迭代器
typedef char* iterator;
//const 迭代器
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;
}
string完整代码
namespace cl
{
class string
{
public:
//迭代器
typedef char* iterator;
//const 迭代器
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;
}
//整体思路：在构造函数的时候，开空间把数据拷贝拷贝过来，存储在动态开辟的字符串,待会增删查改都方便
string(const char* str = "")//全缺省
//:_str(new char[strlen(str) + 1])//strlen不会计算到' '，所以会加1
:_size(strlen(str)) //size_t strlen(const char* str);
, _capacity(_size)
{
_str = new char[_capacity + 1];
strcpy(_str, str);//char * strcpy ( char * destination, const char * source );
}
void Swap(string& s)
{
swap(_str, s._str);
swap(_size, s._size);
swap(_capacity, s._capacity);
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];//可读可写
}
const char& operator[](size_t pos) const//遍历const类型的
{
return _str[pos];//可读不可写
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];//+1为了包含' '
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
//if (_size == _capacity)
//{
// reserve(_capacity == 0 ? 4:2*_capacity);//三目运算符，防止刚开始capacity就是0
//}
//_str[_size] = ch;
//++_size;
//_str[_size] = ' ';
insert(_size, ch);//直接复用insert
}
void append(const char* str)
{
//strcpy(_str + _size, str);//从' '这个位置往后续
//_size += len;
insert(_size, str);//复用insert
}
//s2(s1)现代的拷贝构造
string(const string& s)
:_str(nullptr)//先把s2的_str置空，不置空的话，和tmp._str交换后，tmp调用析构函数会报错
, _capacity(0)
, _size(0)
{
string tmp(s._str);//tmp调用带参的构造函数
Swap(tmp);//自己写的Swap函数第一个参数默认是this
}
//swap(_str, tmp._str);//交换后，s2的_str就指向原先tmp._str的空间
//swap(_size, tmp._size);
//swap(_capacity, tmp._capacity);
//s1=s3，现代写法
string& operator=(string s)//这里传值传参，调用了拷贝构造 s就是s3的深拷贝
{
Swap(s);
return *this;
}
string& operator+=(char ch)//+=一个字符
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)//+=一个字符串
{
append(str);
return *this;
}
void resize(size_t n, char ch = ' ')//保留n个有效数据，从_size位置开始往后补ch
{
if (n <= _size)
{
_size = n;
_str[_size] = ' ';
}
else//n>_size的情况
{
if (n > _capacity)//如果容量不够要增容
{
reserve(n);
}
memset(_str + _size, ch, n - _size);//从_str+_size位置开始，填ch，填n-_size个
_size = n;
_str[_size] = ' ';
}
}
size_t find(char ch)//查找一个字符.返回下标
{
for (size_t i = 0; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}
return npos;//找不到就返回npos
}
size_t find(const char* s, size_t pos = 0)//查找一个字符串，返回下标
{
const char* ptr = strstr(_str + pos, s);
if (ptr == nullptr) {
return npos;//找不到就返回npos
}
else
{
return ptr - _str;
}
}
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
//size_t end = _size;
//while (end >= pos)//pos==0,end--就会越界
//{
// _str[end + 1] = _str[end];
// end--;
//}
size_t end = _size + 1;//end的位置就是在' '的后一个位置
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(len + _size);
}
size_t end = _size + len;
while (end >= pos + len)//画图找边界
{
_str[end] = _str[end - len];
--end;
}
strncpy(_str + pos, s, len);//也可以用for循环
_size += len;
return *this;
}
string& erase(size_t pos = 0, size_t len = npos)//删
{
assert(pos < _size);
if (len == npos || pos + len >= _size)//从pos位置往后全部删除
{
_str[pos] = ' ';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);//也把' '拷贝过去
_size -= len;
}
return *this;
}
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
void clear()//清空数据,流提取会用到
{
_str[0] = ' ';
_size = 0;
}
private:
char* _str;
size_t _size;
size_t _capacity;//能存储有效字符的空间数，不包含' '
static const size_t npos;//找不到的情况就返回npos
};
const size_t string::npos = -1;
bool operator<(const string& s1, const string& s2)//s1 s2[i2])
{
return false;
}
else//相等的情况
{
i1++;
i2++;
}
}
//"abcd" "abcd" s1, s2的size相等就说明s1==s2
//"abcde" "abcd"s1的size大于s2的size，说明s1>s2
//"abcd" "abcde"s2的size大于s1的size,说明s1(const string& s1, const string& s2)// >
{
return !(s1<=s2) ;//复用s1<=s2
}
bool operator>=(const string& s1, const string& s2)// >+
{
return !(s1 < s2);//复用s1>(istream& in, string& s)//流提取的重载
{
s1.clear();
char ch = in.get();//get()获取一个字符
while (ch != ' ' && ch != 'n')//有空格和换行就结束
{
s += ch;
ch = in.get();
}
return in;
}
}
