目录

准备

构造函数

c_str

size

capacity

析构函数

拷贝构造

swap

operator[ ]

迭代器iterator的实现

begin

end

reserve

insert在任意位置插入字符/字符串

push_back

append

operator+

operator+=

erase

clear

pop_back

比较函数

substr

find(利用kmp算法实现)

kmp详解可移步至:KMP算法详解(一眼看穿next[ ]数组)

>>

<<

准备

为了自己创建的string类不和库当中的发生冲突，可以自己创建一个命名空间

namespace test
{}

string需要三个参数，一个存放字符串(char* _str)，一个存放大小(size_t _size)，一个存放容量(size_t _capacity)

//自定义一个命名空间，防止与stl中的string同
namespace test
{class string{public://构造函数string(){}//析构函数private:char* _str;size_t _size;size_t _capacity;};}

构造函数

构造函数需要做的就是对成员进行初始化，由于字符串是常量，类型为const char*，所以接收的时候也需要用const char*来接收，但这里不能简单的直接将str给_str，因为str是存放在常量区的，如果直接将_str=str，会将str在常量区的地址也拷贝过去，会导致之后无法修改string的内容，所以需要给_str分配一个空间，然后再将str的值全部拷贝过去，在分配空间的时候要多分配一个空间给'\0'

		string(const char* str):_size(strlen(str)),_capacity(_size){_str = new char[_capacity + 1];strcpy(_str, str);}

为了方便测试函数是否正确，提供一个c_str函数来获取对象中的字符串

c_str

官方解释:

 函数类型是const char*因为这只是一个提取对象内容的函数，为了防止权限放大，因为某些原因导致指针被修改就麻烦大了

返回一个指针包括'\0'的字符串

		const char* c_str() const{//添加const防止修改指针的内容return _str;}

测试一下构造函数，传一个hello world

通过监视窗口可以看到是拷贝成功了的

运行结果：

 再提供两个接口来获取size和capacity

size

官方解释:

首先返回类型为size_t，大小肯定不会为负数，用const修饰
返回的是字符串的实际长度，不包括'\0'，也不是容量的大小

		size_t size() const{return _size;}

capacity

官方解释:

 和size差不多，返回的容量不包括'\0'

        size_t capacity() const{return _capacity;}

运行结果：

 运行结果是正确的，但这里存在两个构造函数，第一种是默认的

string()
{}

第二种就是我们自主实现的，其实这里可以简化一下，将两种合并为一种，在传的字符串为空的时候就会调用第一种构造函数，空的话字符串内容就是'\0'，_capacity=0，_size=0，可以直接将第二种构造函数的参数给个缺省值，如果不填就默认是""或者"\0"，这两种是等效的，第一种也是直接填一个'\0'上去，所以构造函数也可以写成:

		string(const char* str=""):_size(strlen(str)),_capacity(_size){_str = new char[_capacity + 1];strcpy(_str, str);}

或者:

		string(const char* str="\0"):_size(strlen(str)),_capacity(_size){_str = new char[_capacity + 1];strcpy(_str, str);}

析构函数

成员变量中_str是动态开辟出来的，所以需要对内存进行delete释放，释放后再将其指向nullptr空

		~string(){delete[] _str;_str = nullptr;_size = 0;_capacity = 0;}

拷贝构造

思路1：

对_str重新分配空间，然后利用strcpy函数来讲str中的字符串全部拷贝到_str中

		string(const string& str):_size(str._size),_capacity(str._capacity){_str = new char[_capacity + 1];strcpy(_str, str._str);}

测试:

运行结果:

思路2：

创建一个临时变量tmp来拷贝str，再通过swap函数来交换，因为tmp是临时变量，出了函数作用域就会调用析构函数来销毁tmp，所以在tmp和str交换之后，因为str的原地址需要被销毁，这里就不需要手动销毁了，我们将str的地址给到了tmp，出了函数作用域之后调用析构函数就将其销毁了。

		string(const string& str):_str(nullptr),_size(0),_capacity(0){string tmp(str._str);swap(tmp);}

swap

全局的那个swap对于内置类型交换很快，但对于自定义类型会比较慢了，它会掉用三次构造函数，所以可以自己实现一个swap函数

		void swap(string& str){string tmp(str._str);std::swap(_str, tmp._str);std::swap(_size, tmp._size);std::swap(_capacity, tmp._capacity);}

 operator[ ]

对操作符[ ]进行重载,可以通过[ ]来获取字符

官方解释：

		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的实现

iterator实质上就是一个类似指针的东西但又不是指针，但是在string类中可以将其当作指针，所以对iterator进行重命名即可

typedef char* iterator;

begin

官方解释：

 返回第一个字符的指针

		iterator begin(){return _str;}

		const_iterator begin() const{return _str;}

end

官方解释：

返回的是字符串最后一个字符的后一个位置的指针，比如一个字符串为"hello world\0"，end()指向的就是'\0'的位置

		iterator end(){return _str + _size;}

		const_iterator end() const{return  _str + _size;}

测试：

	void test_string(){string s1("hello world");for (test::string::iterator it = s1.begin(); it < s1.end(); ++it){cout << *it << " ";}}

输出结果:

reserve

官方解释：

 该函数对字符串内容不能进行修改，大小也不能修改，只能增加其容量，并且只能增容不能缩容

所以可以通过创建一个临时变量tmp，大小为n+1，将_str的内容通过strcpy函数复制给tmp，然后将_str给delete[ ]掉，最后将tmp地址给_str，就实现了扩容。

		void reserve(size_t n = 0){assert(n > _capacity);char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}

insert在任意位置插入字符/字符串

官方解释：

		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){_str[end] = _str[end - 1];--end;}_str[pos] = ch;++_size;_str[_size] = '\0';return *this;}

这样的代码看起来是没有什么问题，下面进行测试：
 

	void test_string(){string s1("hello world");s1.insert(2, 'a');cout << s1.c_str() << endl;}

运行结果：

看起来好像一切都正常，但进行头插的时候

	void test_string(){string s1("hello world");s1.insert(0, 'a');cout << s1.c_str() << endl;}

程序就崩溃了

这里导致程序崩溃的原因是因为end和pos都是size_t类型，size_t的0是一个很大的数，所以导致这里死循环了，但如果将end的类型从size_t改成int，程序还是会报错

而这里报错的原因是存在一个隐式类型转换，end>=pos这个式子当中，end是int类型，pos是size_t类型，int会自动转换成size_t，所以这里改成int类型也是没有用的，除非全都改成int类型，但库当中使用的类型是size_t，我们不能因为实现这个功能将库中变量的类型都改变了，这里有两种解决方式，一种是利用指针，还有一种就是另end=_size+1，只要不判断0就不会出错了

指针的方式：

		string& insert(size_t pos, char ch){assert(pos <= _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : 2 * _capacity);}char* end = _str + _size;char* target = _str + pos;size_t end1 = _size;while (end >= target){_str[end1] = _str[end1 - 1];--end;--end1;}_str[pos] = ch;++_size;_str[_size] = '\0';return *this;}

不判断0的方式：

		string& insert(size_t pos, char ch){assert(pos <= _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : 2 * _capacity);}size_t end = _size + 1;while (end > pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;++_size;_str[_size] = '\0';return *this;}

如果是插入一个字符串呢?其实思路也是一样的

指针的方式：

		string& insert(size_t pos, const char* str){assert(pos <= _size);int len = strlen(str);size_t end1 = _size + len;if (_capacity == _size){reserve(_capacity + len);}char* end = _str + _size + len;char* target = _str + pos;while (end >= target){_str[end1] = _str[end1 - len];--end1;--end;}strncpy(_str + pos, str, len);return *this;}

不判断0的方式：

		string& insert(size_t pos, const char* str){assert(pos <= _size);int len = strlen(str);size_t end = _size + len;if (_capacity == _size){reserve(_capacity+len);}while (end-len > pos){_str[end] = _str[end - len];--end;}strncpy(_str + pos, str, len);return *this;}

继续测试：

	void test_string(){string s1("hello world");s1.insert(0, "test");cout << s1.c_str() << endl;}

 push_back

官方解释：

插入一个字符到字符串的结尾，并且_size+1。

首先判断是否需要扩容，然后再在_str[_size]进行插入字符，最后++_size。

		void push_back(char ch){if (_size == _capacity){reserve(_capacity + 1);}_str[_size] = ch;++_size;_str[_size] = '\0';}

开始测试：
 

	void test_string(){string s1("hello world");string s2("");string s3(" ");s1.push_back('a');s2.push_back('a');s3.push_back('a');cout << "s1的size：" << s1.size() << " " << "s1的capacity：" << s1.capacity() << " " << "字符串为：" << s1.c_str() << endl;cout << "s2的size：" << s2.size() << " " << "s2的capacity：" << s2.capacity() << " " << "字符串为：" << s2.c_str() << endl;cout << "s3的size：" << s3.size() << " " << "s3的capacity：" << s3.capacity() << " " << "字符串为：" << s3.c_str() << endl;}

 其实为了简化代码也可以直接调用insert函数

		void push_back(char ch){insert(_size, ch);}

append

官方解释：

 也是在字符串的结尾进行插入，与push_back不同的就是push_back只能插入字符但append还能插入字符串，函数返回类型也不同，所以插入字符的就不说了。

插入字符串，首先判断是否需要扩容，然后进行字符串尾插

		string& append(const char* str){int len = strlen(str);if (_capacity < _size + len){reserve(_size + len);}strcpy(_str + _size, str);_size += len;return *this;}

测试：

	void test_string(){string s1("hello world");string s2("");string s3(" ");s1.append("test");s2.append("test");s3.append("test");cout << "s1的size：" << s1.size() << " " << "s1的capacity：" << s1.capacity() << " " << "字符串为：" << s1.c_str() << endl;cout << "s2的size：" << s2.size() << " " << "s2的capacity：" << s2.capacity() << " " << "字符串为：" << s2.c_str() << endl;cout << "s3的size：" << s3.size() << " " << "s3的capacity：" << s3.capacity() << " " << "字符串为：" << s3.c_str() << endl;}

 为了代码简洁也是可以直接调用insert函数来实现append函数的功能

		string& append(const char* str){insert(_size, str);return *this;}

operator+

		string operator+(const string& s2){char* tmp = new char[strlen(s2._str) + strlen(_str) + 1];strcpy(tmp, _str);strcat(tmp, s2._str);string res(tmp);delete[] tmp;tmp = nullptr;return res;}

测试：

void test_string(){string s1("hello world");string s2("");string s3(" ");string s4 = s1 + s2;string s5 = s2 + s1;string s6 = s2 + s3;string s7 = s3 + s2;string s8 = s1 + s3;string s9 = s3 + s1;cout << "s4的size：" << s4.size() << " " << "s4的capacity：" << s4.capacity() << " " << "字符串为：" << s4.c_str() << endl;cout << "s5的size：" << s5.size() << " " << "s5的capacity：" << s5.capacity() << " " << "字符串为：" << s5.c_str() << endl;cout << "s6的size：" << s6.size() << " " << "s6的capacity：" << s6.capacity() << " " << "字符串为：" << s6.c_str() << endl;cout << "s7的size：" << s7.size() << " " << "s7的capacity：" << s7.capacity() << " " << "字符串为：" << s7.c_str() << endl;cout << "s8的size：" << s8.size() << " " << "s8的capacity：" << s8.capacity() << " " << "字符串为：" << s8.c_str() << endl;cout << "s9的size：" << s9.size() << " " << "s9的capacity：" << s9.capacity() << " " << "字符串为：" << s9.c_str() << endl;}

这里的代码实现我刚开始犯了一个错误，将返回类型string写成了&string，这会导致程序直接崩溃

 对不可操作的内存进行strlen了。

由于s1+s2返回的是一个不可操作的内存，因为res是string自定义类型的临时对象，出了函数作用域就会调用析构函数，析构函数会直接将res对象中的_str给delete[ ]销毁掉，但这个res又传过来了，所以s4又会去调用构造函数，所以就出问题了

operator+=

官方解释：

通过在字符串的当前值末尾附加其他字符来扩展字符串

首先要判断是否需要扩容，然后利用strcpy函数将str._str的字符串内容全部复制过去

		string& operator+=(const string& str){if (_size + str._size > _capacity){reserve(_size + str._size);}strcpy(_str + _size, str._str);_size += str._size;return *this;}

测试：

	void test_string(){string s1("hello world");string s2("test");string s3("");string s4(" ");s1 += s3;cout << s1.c_str() << endl;s1 += s4;cout << s1.c_str() << endl;s1 += s2;cout << s1.c_str() << endl;s3 += s1;cout << s3.c_str() << endl;s4 += s1;cout << s4.c_str() << endl;}

 运行结果：

也可以为了写的更加简洁，直接调用之前写的append函数即可

		string& operator+=(const char* str){append(str);return *this;}

erase

官方解释：

npos就是size_t -1

删除部分字符串，减少字符串长度。

	private:char* _str;size_t _size;size_t _capacity;static const size_t npos;

然后再类外面对npos进行初始化，为什么npos不在初始化列表中初始化呢？

因为npos是一个静态变量，它不属于某一个特定的对象，所以要在类外面对其进行初始化，并且要指定类域

	const size_t string::npos = -1;

如果pos比字符串的长度还要大，直接报错。

如果pos+len>=_size，那么直接将_str[pos]位置改为'\0'。

		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{strncpy(_str + pos, _str + pos + len,len);_size -= len;}return *this;}

测试：
 

	void test_string(){string s1("hello world");s1.erase(0, 10);cout << s1.c_str() << endl;string s2("hello world");s2.erase(10, 5);cout << s2.c_str() << endl;}

运行结果：

 clear

官方解释：

 消去字符串的内容成为一个空字符串，_size和_capacity都变为0

		void clear(){delete[] _str;_capacity = 0;_size = 0;}

pop_back

		void pop_back(){assert(_size > 0);_str[_size-1] = '\0';--_size;}

比较函数

bool operator >(const string& s) const{return strcmp(_str, s._str) > 0;}bool operator ==(const string& s) const{return strcmp(_str, s._str) == 0;}bool operator >= (const string& s) const{return *this > s || *this == s;}bool operator <(const string& s) const{return !(*this >= s);}bool operator <=(const string& s) const{return !(*this > s);}bool operator !=(const string& s){return !(*this == s);}

substr

官方解释：

返回一个新构造的对象，其值初始化为此对象的子字符串的拷贝。

子字符串是从字符位置开始并跨越字符（或直到字符串末尾，以先到者为准）的对象部分。

		string substr(size_t pos = 0, size_t len = npos){assert(pos < _size);size_t reallen = len;if (len == npos || pos + len > _size){reallen = _size - len;}string sub;for (int i = pos; i < reallen; ++i){sub += _str[i];}return sub;}

find(利用kmp算法实现)

官方解释： 

从pos位置开始，在字符串中找到第一个匹配的下标并且返回

首先是查找单个字符，很简单，直接遍历挨个比对就好了

size_t find(char ch, size_t pos = 0)//查找字符{for (int i = pos; i < _size; i++){if (_str[i] == ch){return i;}}return npos;}

其次就是匹配字符串了，这里使用的是kmp算法来匹配子串并且返回其下标

kmp详解可移步至:KMP算法详解(一眼看穿next[ ]数组)

size_t find(const char* str, size_t pos = 0){int len = strlen(str);if (strlen(str) > _size){return npos;}ne = new int[len + 1]{ 0 };//获取匹配码for (int i = 1, j = 0; i < len; i++){while (j && str[i] != str[j]) j = ne[j];if (str[i] == str[j]) j++;ne[i] = j;}for (int i = 0, j = 0; i < _size; i++){while (j && _str[i] != str[j]) j = ne[j];if (_str[i] == str[j]) j++;if (j == len){return i - j + 1;}}return npos;}

注意到这里使用到了一个ne数组，ne数组主要是用来存储字符串的匹配码的，这个ne数组直接定义在私有成员变量当中，int* ne;

private:char* _str;size_t _size;size_t _capacity;int* ne;static const size_t npos;

成员变量添加了一个ne指针之后，也需要在构造函数中对ne指针进行初始化，否则ne指向的是一片随机的空间，由于无法直接在初始化列表当中给ne分配空间，所以可以先给ne一个空指针。

string(const char* str = ""):_size(strlen(str)), _capacity(_size), ne(nullptr){ne = new int[1]{ 0 };_str = new char[_capacity + 1];strcpy(_str, str);}

>>

官方解释：

在C++当中，处理输入时使用命名为cin的istream类型对象，这个对象也叫标准输入，每次输入操作符实例都要接受两个操作数：左操作数必须是istream对象，然后接受一个对象作为右操作数，它从istream操作数当中读取数据并且保存在右操作数中。

因为>>是操作符，只能接收一个参数，如果不使用友元的话调用这个函数的书写方式会变为：

str.cin("test");

这显然不符合正常使用的习惯，所以这里需要添加一个友元函数

friend istream& operator>>(istream& in, string& str);

然后再实现cin

	istream& operator>>(istream& in, string& str){str.clear();//清空原字符串char ch = in.get();while (ch != ' ' && ch != '\n'){ch = in.get();}return in;}

<<

<<为流提取，与>>类似，不过它的左值是一个ostream类型的对象

友元函数：

friend ostream& operator<<(ostream& out, const string& str);

实现cout：

	ostream& operator<<(ostream& out, const string& str){out << str.c_str();return out;}