【C++】string类（下）

个人主页~
string类（上）

二、模拟实现string类

今天我们来实现一下上篇文章中详细介绍过的接口

1、头文件string.h

#pragma once
#include <iostream>
#include <assert.h>

//const和非const迭代器
typedef char* iterator;
typedef const char* const_iterator;

namespace little_monster
{
	class string
	{
	public:
		//重载流输入流提取操作符
		friend std::ostream& operator<<(std::ostream& out, const string& s)
		{
			for (auto ch : s)
			{
				out << ch;
			}//范围for一个一个读取
			return out;
		}

		friend std::istream& operator>>(std::istream& in, string& s)
		{
			s.clear();//清理掉原来的资源
			char buff[129];
			size_t i = 0;
			char ch;
			ch = in.get();//获取第一个字符
			while (ch != ' ' && ch != '\n')
			{
				buff[i++] = ch;
				if (i == 128)
				{
					buff[i] = '\0';
					s += buff;
					i = 0;
				}
				ch = in.get();
			}//持续获取字符，如果满128就存到s中，将i置为0继续获取，直到遇到空格或者换行停止获取
			if (i != 0)
			{
				buff[i] = '\0';
				s += buff;
			}//如果此时的i不为0，那么就在此位置加一个'\0'，这个位置是有效数据的后一个位置
			return in;
		}		
		//定义一个npos
		const static size_t npos = -1;
		
		//构造、拷贝、析构函数
		string(const char* str);
		string(const string& s);
		~string();
		
		//有关于类容量的接口
		size_t size() const;//当前数据个数
		size_t capacity() const;//容量
		bool empty();//判空
		void reserve(size_t n);//预留空间
		void clear();//清理资源
		void resize(size_t n,char ch);//调整大小并补齐
		
		//访问以及遍历的接口
		char& operator[](size_t pos);
		const char& operator[](size_t pos) const;//重载下标访问操作符
		iterator begin();
		const_iterator begin() const;//迭代器begin
		iterator end();
		const_iterator end() const;//迭代器end
//迭代器有很多都是指针，但也有很多不是指针，string类这里的迭代器是指针
		
		//类对象修改的接口
		void push_back(char ch);//尾插一个字符
		void append(const char* str);//尾插一个字符串
		string& operator+=(char ch);//尾插一个字符
		string& operator+=(const char* str);//尾插一个字符串
		void insert(size_t pos,char ch);//pos位置插入一个字符
		void insert(size_t pos, const char* str);//pos位置插入一个字符串
		void erase(size_t pos,size_t len);//pos位置开始往后删除len个字符
		size_t find(char ch, size_t pos);//从pos位置开始往后查找到第一个ch字符，返回它的索引
		size_t find(const char* sub,size_t pos);
		//pos位置开始往后查找到第一个sub指向的字符串，返回第一个字符的索引
		const char* c_str() const;//类转化为c格式
		string substr(size_t pos,size_t len);//从字符串pos位置开始提取len个字符
		string& operator=(string tmp);//重载=操作符
		
		//重载运算符接口
		bool operator<(const string& s) const;
		bool operator==(const string& s) const;
		bool operator>(const string& s) const;
		bool operator<=(const string& s) const;
		bool operator>=(const string& s) const;
		bool operator!=(const string& s) const;
		
		//类交换函数
		void swap(string& s);
	private:
		char* _str;//指向字符串的指针
		size_t _size;//字符个数
		size_t _capacity;//容量
	};
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

2、常见构造

构造函数、拷贝构造、析构函数

//交换函数
void::string::swap(string& s)
{
	std::swap(_str, s._str);
	std::swap(_capacity, s._capacity);
	std::swap(_size, s._size);
	//交换值
}

//构造函数
string::string(const char* str = "")//给一个缺省值，在无参时为'\0'
	:_size((size_t)strlen(str))//强制类型转换为size_t型
	, _capacity(_size)
{
	_str = new char[_capacity + 1];
	strcpy(_str, str);
}

//拷贝构造函数
string::string(const string& s)
	:_str(nullptr)
	,_size(0)
	,_capacity(0)
{
	string tmp(s._str);
	swap(tmp);
}

//析构函数
string::~string()
{
	if(_str)
	{
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

构造函数new的地方开多一个空间放’\0’,因为是字符串，由于初始化时的顺序是按照声明的顺序，在初始化列表初始化指针_str会因为容量无数据导致随机值，所以我们不用初始化列表初始化指针_str，等它们通过初始化列表初始化完成后再赋初值

拷贝构造函数是拷贝构造的一种方法，创建一个拷贝对象，将该对象按照初始化列表初始化为一个空类，用s的_str指针构造一个tmp类，然后将tmp类的参数与空类的参数进行swap互换，这样此时的空类也就是拷贝对象就有了数据，并且tmp作为一个临时类，会在函数结束后自动调用析构函数析构

析构函数就很简单了，按照delete[]的方式释放空间后将指针_str置为空，然后将容量和大小置为0，但其实容量和大小没必要操作的，这个无所谓

构造函数和拷贝构造调试：

析构函数调试：先析构s2再析构s1

3、容量函数

size、empty、capacity、reserve、clear、resize

函数后面加一个const我们讲过，因为this指针是隐参数，不能在括号里边修饰，后加const修饰的是隐参数this

size_t string::size() const
{
	return _size;
}

size_t string::capacity() const
{
	return _capacity;
}

bool string::empty()
{
	if (_size == 0)
	{
		return true;
	}
	return false;
}

void string::reserve(size_t n)
{
	if (n > _capacity)//n < _capacity不用预留
	{
		char* tmp = new char[n + 1];//创建一个指针tmp指向new出来的n+1大小的字符串位置
		strcpy(tmp, _str);//将内容拷贝过去
		delete[] _str;//释放原来的空间
		_str = tmp;//指针指向tmp的位置
		_capacity = n;//将容量置为n
	}//这里不用担心tmp没有置空的问题，因为除了作用域tmp就会销毁，其他人是访问不到的
}

void string::clear()
{
	_str[0] = '\0';
	_size = 0;
}//将第一个位置放\0，然后size为0就可以使后来的数据覆盖原来的数据，访问时也只有\0

void string::resize(size_t n,char ch = '\0')
{
	if (n <= _size)
	{
		_str[n] = '\0';
	}//如果n<=size，就是缩小或者不动，直接在n的位置放一个'\0'就可以了
	else
	{
		reserve(n);//如果n>_size，不管_capacity是多大直接预留出n个位置
		while (n > _size)
		{
			_str[_size] = ch;
			++_size;
		}//将ch填充进去，ch若是没有就是缺省参数'\0'
		_str[_size] = '\0';//在最后的位置填一个'\0'
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

4、访问及遍历

operator[]、begin和end

char& string::operator[](size_t pos)
{
	assert(pos < _size);
	return _str[pos];
}

const char& string::operator[](size_t pos) const
{
	assert(pos < _size);
	return _str[pos];
}

iterator string::begin()
{
	return _str;
}

const_iterator string::begin() const
{
	return _str;
}

iterator string::end()
{
	return _str + _size;
}

const_iterator string::end() const
{
	return _str + _size;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

范围for用的就是迭代器begin和end
这是还未进入范围for的调试过程

进入范围for，首先找到迭代器begin

然后找到迭代器end

5、类对象修改

operator+=、push_back、append、insert、erase、find、c_str、substr、operator=

void string::push_back(char ch)
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}//空间问题，如果空间为0，则开辟空间
	_str[_size++] = ch;
	_str[_size] = '\0';//在最后的位置插入后++，在++后的位置放一个'\0'
}

void string::append(const char* str)
{
	size_t len = strlen(str);//len是字符串有效字符的个数
	if (_capacity < (len + _size))
	{
		reserve(len + _size);
	}//如果容量较小，就预留出刚刚够的空间
	strcpy(_str + _size, str);//将str拷贝到_str的后面，strcpy的拷贝是包括'\0'的
	_size += len;
}

string& string::operator+=(char ch)
{
	push_back(ch);
	return *this;//复用push_back
}

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

void string::insert(size_t pos, char ch)
{
	assert(pos <= _size);
	size_t n = _size + 1;
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}
	while (pos < n)
	{
		_str[n] = _str[n - 1];
		--n;
	}
	_str[pos] = ch;
	++_size;
}

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

void string::erase(size_t pos, size_t len = npos)
{
	assert(pos < _size);
	if (len == npos || len + pos > _size)
	{
		_str[pos] = '\0';
		_size = pos;
	}//如果len太大，就是从pos开始往后删干净
	else
	{
		size_t begin = pos + len;//这里的begin其实是移动数据的begin而不是删除那段数据的begin
		while (begin < _size)
		{
			_str[begin - len] = _str[begin];
			begin++;
		}//将数据移动到len个位置之前
		_size -= len;
	}
}

size_t string::find(char ch, size_t pos = 0)
{
	for (int i = (int)pos; i < _size; i++)
	{
		if (_str[i] == ch)
		{
			return i;
		}
	}
	return npos;
}

size_t string::find(const char* sub, size_t pos = 0)
{
	const char* p = strstr(_str, sub);
	if (p)
	{
		return p - _str;
	}
	return npos;
}

string string::substr(size_t pos, size_t len = npos)
{
	string s;
	size_t end = pos + len;//找到末尾的位置end
	if (len == npos || pos + len >= _size)
	{
		len = _size - pos;
		end = _size;
	}//如果len太大就直接从pos位置截取到最后

	s.reserve(len);//给新创建的类预留len大小的空间
	for (size_t i = pos; i < end; i++)
	{
		s += _str[i];
	}//从pos位置开始，一直到end，输入所需要插入的字符

	return s;
}

string& string::operator=(string tmp)
{
	swap(tmp);

	return *this;
}

const char* string::c_str() const
{
	return _str;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

insert一个字符这里，插入一个字符，就是在最后位置开始往后移动一位，一直到pos位置，这样pos位置就空出来了，再把ch字符填入到pos位置，比较简单

insert字符串也是差不多的方法，插入一个字符串，用类似append那里的方法，先要知道当前的容量够不够容纳这两段字符串，然后不够就用reserve预留空间，然后再将字符从最后面挨个王后移动 len 位次，最后把字符串放里边，当然这次不要’\0’，所以我们用strncpy

find一个字符这里，找到从pos位置开始的第一个字符ch很简单，直接for循环比对就可以了，比较简单

find字符串需要请出C语言中的函数strstr，它可以比对两个指针指向位置的字符串是否有重合的部分，如果有就返回重合那部分的指针，如果没有返回空，指针减去指针得到两指针之间的数据个数

operator=的实现方式是一种极简的方法，也叫现代方法，直接将两者的数据进行交换，参数类tmp在出作用域也会自动调用析构函数销毁，代码简洁，很方便

6、流插入流提取重载

代码搁上边头文件里

今日分享就到这了~