string的实现（下）
1.面试中的简单实现
在面试中，由于时间的缘故，我们只需要简单实现string就行，其中就包括构造函数，析构函数，拷贝构造，赋值运算即可。由于不涉及容量的改变，只需要一个成员变量_str即可。
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class my_string
{
public:
my_string(const char* s = "")
:_str(new char[strlen(s)+1])
{
strcpy(_str, s);
}//构造函数
my_string(const my_string& s)
:_str(nullptr)
{
my_string s1(s.c_str());
swap(_str, s1._str); //交换首地址元素，结束旧元素的s1，会自动调用析构函数析构，一定要置原_str为空,不然就会析构错误
}//拷贝构造函数
~my_string()
{
delete[] _str;
_str = nullptr;
}
//析构函数
my_string& operator=(const my_string& s)
{
my_string s1(s);
swap(_str, s1._str);
return *this;
}
const char* c_str()const
{
return _str;
}
private:
char* _str;
};2.复杂功能的实现
注意，其中可能掺杂了strcpy的来交换_str的传统写法，我们更倾向于在实现的时候调用库函数swap。
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
using namespace std;
class my_string
{
friend istream& operator>>(istream& ci, my_string& s);
public:
my_string(const char* s="")
{
_size = _capacity = strlen(s);
_str = new char[_size + 1];
strcpy(_str, s);
}//实现了默认和带参构造
//my_string(const my_string& s)
//{
// _size = _capacity = strlen(s._str);
// _str = new char[_size + 1];
// strcpy(_str, s._str);
//}//实现拷贝构造
//拷贝构造的现代写法（使用swap)
my_string(const my_string& s)
:_str(nullptr) //如果初始化 换给s中的str后，s析构delete时就会出问题
{
my_string tmps(s._str);
swap(tmps);
}
~my_string()
{
delete[] _str;
_capacity = _size = 0;
_str = nullptr;
}
char& operator[](size_t pos)const
{
assert(pos >= 0 && pos < _size);
return *(_str + pos);
}
typedef char* iterator;
char* begin()const
{
return _str;
}
char* end()const
{
return _str + _size ;
}
void push_back(char c)
{
if (_capacity == _size)
{
size_t capacity = _capacity == 0 ? 4 : 2 * _capacity;
reserve(capacity);
}
_str[_size++] = c;
_str[_size] = '\0';
}
void append(const char* s)
{
size_t len = strlen(s);
if (_size + len > _capacity)
{
size_t capacity = _size + len;
reserve(capacity);
}
strcpy(_str + _size, s);
_size = _size + len;
}
void operator+=(char c)
{
push_back(c);
}
void operator+=(const char* str)
{
append(str);
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void resize(size_t n,char c = '\0')
{
if (n <= _size)
{
_str[n] = '\0';
}
else
{
reserve(n);
for (size_t i = _size; i < n; i++)
{
_str[i] = c;
}
_str[n] = '\0';
}
}
my_string& insert(size_t pos, size_t n, char c)
{
assert(pos <= _size);
if (_capacity < _size + n)
{
reserve(_size + n);
}//先增容
int end = _size;
while (end >= (int)pos)
{
_str[end + n] = _str[end];
end--;
}//将pos位置后的移动，腾出n个位置
while (n)
{
_str[pos] = c;
pos++;
n--;
}
return *this;
}
my_string& insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
if (_capacity < _size + len)
{
reserve(_size + len);
}//扩容
int end = _size;
while (end >= (int)pos)
{
_str[end + len] = _str[end];
end--;
}//腾位置
strncpy(_str + pos, str, len);
return *this;
}
my_string erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
if (len >= _size - pos)
{
_str[pos] = '\0';
_size = pos;
}
else
{
for (size_t i = pos + len; i <= _size; i++)
{
_str[i - len] = _str[i];
}
}
return *this;
}
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 npos;
}
size_t find(const char* str, size_t pos = 0)const
{
assert(pos < _size);
const char* s = strstr(_str + pos, str);
if (s)
{
return s - begin();
}
return npos;
}
//my_string& operator=(const my_string& s)
//{
// delete[] _str;
// char* tmp = new char[strlen(s._str) + 1];
// strcpy(tmp, s._str);
// _str = tmp;
// return *this;
//}
// operator=的现代写法(使用swap）
///*my_string & operator=(const my_string & s)
//{
// my_string s1(s);
// swap(s1);
//}*/
my_string& operator=(my_string s)
{
swap(s);
return *this;
}
bool operator==(const my_string& s)const
{
int c = strcmp(_str, s._str);
return c == 0;
}
bool operator> (const my_string& s)const
{
int c = strcmp(_str, s._str);
return c > 0;
}
bool operator< (const my_string& s)const
{
int c = strcmp(_str, s._str);
return c < 0;
}
bool operator>=(const my_string& s)const
{
return !(*this < s);
}
bool operator<=(const my_string& s)const
{
return !(*this > s);
}
size_t size()const
{
return _size;
}
size_t capacity()const
{
return _capacity;
}
char* c_str() const
{
return _str;
}
void swap(my_string& s)
{
::swap(_str, s._str); //_str指向的是地址，所以库的swap实现了首元素地址交换，就交换了整个
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
private:
char* _str;
size_t _size;//已经有多少有效字符
size_t _capacity;//能存储多少有效字符
static size_t npos;
};
size_t my_string::npos = -1;
ostream& operator<<(ostream& cou, const my_string& s)
{
cout << s.c_str();
return cou;
}
istream& operator>>(istream& ci, my_string& s)
{
while (1)
{
char c;
c=ci.get();
if (c == '\0' || c == '\n')
{
break;
}
else
{
s.push_back(c);
}
}
return ci;
}//利用istream中的get获取单个字符