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获取单个字符