String类常用的使用方法_c语言string

1.string类是什么?

​ 从语法的角度来讲string是为了改进c语言字符串而创造的一个类，它本质上其实就是一个字符串，不过可以进行许多c语言字符串没有的操作。

2.特点

1. 字符串是表示字符序列的类

2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作

单字节字符字符串的设计特性。

3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信

息，请参阅basic_string)。

4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits

和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。

5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个

类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。

总结：

1. string是表示字符串的字符串类

2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。

3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>

string;

4. 不能操作多字节或者变长字符的序列。

在使用string类时，必须包含#include头文件以及using namespace std;

3.string类的常见接口使用

1.常见构造

以下为代码实操以及结果：

#include<iostream>
#include<string>
using namespace std;

int main()
{
	string a;
	char b[] = "Hello";
	string c(b);
	string d(5, 'a');
	string e(d);
}

1
2
3
4
5
6
7
8
9
10
11
12
13

结果图：

2.容量操作

tips:

1. size()与length()方法底层原理完全相同，引入size()的原因是为了与其他容器的接口保持一

致，一般情况下基本都是用size()。

2. clear()只是将string中有效字符清空，不改变底层空间大小。

3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字

符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的

元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大

小，如果是将元素个数减少，底层空间总大小不变。

4. reserve(size_t res_arg=0)：强制 vector 容器的容量（capacity）至少为 n。注意，如果 n 比当前 vector 容器的容量小，则该方法什么也不会做；反之如果 n 比当前 vector 容器的容量大，则 vector 容器就会扩容。

下面是实际代码用法：

#include<iostream>
#include<string>
using namespace std;

int main()
{
	string test = "abcdefg";
	 int a = test.size();
	 int b = test.length();
	 int c = test.capacity();
	 bool judge = test.empty();
	 test.clear();
	 test.reserve(20);
	 test.resize(20, 'a');
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.对象的访问以及遍历，还有最为重要的迭代器

（1）string类中重要的操作符重载使用及其底层代码

赋值符号的重载

#include<iostream>
#include<string>
using namespace std;
template<class T>
void swap(T& a, T& b)
{
    T temp = a;
    a = b;
    b = temp;
}
namespace own
{
    class string
    {
    public:
        //旧版赋值运算符重载，本质开空间
        /*string& operator= (const string& s)
        {
            if (this != &s)
            {
                char* temp = new char[strlen(s._str) + 1];
                strcpy(temp, _str);
                delete[]_str;
                _str = temp;
            }
            return *this;
        }*/
        //新版本赋值运算符重载，本质换地址
        string& operator= (const string& s)
        {
            string temp(s);
            swap(_str, temp._str);
        }
        return *this;
    private:
       char* _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

深拷贝的复现

首先我们知道拷贝构造在不重写的情况下进行的是浅拷贝，用的是同一块空间。而这里我们将复现一下深拷贝，其原理和赋值运算符重载有一定相似，便放在这块进行类比。

class string
{   //传统写法
	/*string(const string& s)
		:_str(new char [stelen(s._str)+1])
	{
		strcpy(_str, s._str);
	}*/
	//现代写法(其实本质上就是换地址）
	string(const string& s)
		:_str(nullptr)
	{
		string temp(s._str);//注意这里得是深拷贝
		swap(_str, temp._str);
	}
private:
	char* _str
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

string类的基础操作，增删查改以及一些常规的函数模拟

class string
{
        public:
		typedef char* iterator;//迭代器本质
		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;
		}//迭代器中begin的返回

		//构造函数
		string(const char* str = "")
			:_size(strlen(str))
			,_capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
	    //交换
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
		//拷贝构造，这边为什么在写一遍主要为了强调下面这个swap
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			string tmp(s._str);
			//this->swap(tmp);

			swap(tmp);//这样换消耗小，如果按照上面写的那样换的话会进行3次深拷贝。
		}
		//析构函数（进行了内存动态管理）
		~string()
		{
			delete[]_str;
			_str = nullptr;
			size = capacity = 0;
		}
		//[]的运算符重载
		char& operator[](size_t pos)
		{
			assert(pos <= _size);
			return _str[pos];
		}
		//reserve的复刻
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		//resize的复刻
		void resize(size_t n, char ch = '\0')
		{
			if (n <= _size)
			{
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
				if (n > _capacity)
				{
					reserve(n);
				}

				memset(_str + _size, ch, n - _size);
				_size = n;
				_str[_size] = '\0';
			}
		}
		//尾插的三种方式
		void push_back(char ch)
		{
			/*if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';*/
			insert(_size, ch);
		}

		void append(const char* str)
		{
			/*size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}

			strcpy(_str + _size, str);
			_size += len;*/

			insert(_size, str);
		}

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

		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}
		//find复刻
		size_t find(char ch)
		{
			for (size_t i = 0; i < _size; ++i)
			{
				if (ch == _str[i])
				{
					return i;
				}
			}

			return npos;
		}

		size_t find(const char* s, size_t pos = 0)
		{
			const char* ptr = strstr(_str + pos, s);
			if (ptr == nullptr)
			{
				return npos;
			}
			else
			{
				return ptr - _str;
			}
		}
		//insert复刻

		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);

			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			/*size_t end = _size;
			while (end >= pos)
			{
			_str[end + 1] = _str[end];
			--end;
			}*/

			/*int end = _size;
			while (end >= (int)pos)
			{
			_str[end + 1] = _str[end];
			--end;
			}*/

			size_t end = _size + 1;
			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(_size + len);
			}

			size_t end = _size + len;
			while (end > pos)
			{
				_str[end] = _str[end - len];
				--end;
			}

			strncpy(_str + pos, s, len);

			return *this;
		}
		//erase复刻
		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
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}

			return *this;
		}
		private:
		char* _str;
		size_t _size;// 能存储有效字符的空间数，不包含\0
		size_t _capacity; //实际空间大小

		static const size_t npos;
};
    const size_t string::npos = -1;
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245

迭代器的使用:

上述代码已经展现了迭代器begin函数和end函数的复刻，而rbegin和rend只不过是反向迭代器换个方向而已

范围for（其实本质就是调用了个迭代器）

//基础格式
for(auto:arr)
{
    arr[i] += 1; //arr数组中每个数都加1
}
1
2
3
4
5

4.各种修改操作的汇总

这些函数的复刻大多都在上面实现了，基本用法也是比较容易，这里给大家演示一下find的用法。

int main()
{
    string file("test.txt");
    FILE* fout = fopen(file.c_str(),"w");
    size_t pos = file.find('.');
    if(pos != string::npos)
    {
        string suffix = file.substr(pos,file.size() - pos);
        cout<<suffix<<endl;   //打印为“.text"
    }
}
1
2
3
4
5
6
7
8
9
10
11