C++中string的用法总结+底层剖析

前言：在C语言中，我们经常使用字符串进行一系列操作，经常使用的函数如下：增删改查

（自己造轮子），C++中设计出string容器，STL库中为我们提供了以上函数，所以我们使用string容器时，就不用造轮子了

参考网站：https://legacy.cplusplus.com/reference/string/string/?kw=string

底层实现，这里我用的是VS的编译器（window）（简化版本），linux（g++）这里使用计数引用（这里不采用计数引用实现）

constructor（构造函数）

第一个（第四个）：是无参构造

#include
#include
using namespace std;
int main()
{
	string s;
 
	return 0;
}

s中只含有'\0'（无参构造时）

底层实现：（运用全缺省构造）

string(const char* arr = "")
{
	int len = strlen(arr);
	_str = new char[len + 1];// '\0'要单独开空间
	strcpy(_str, arr);
	_size = len;
	_capacity = len;
}

第二个：拷贝构造（将 str 中的所有成员变量全部赋值给*this）

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

第三个：将str中的字符串从下标为pos ,拷贝字符的个数为npos

（注意npos 为默然时，则为字符串能存储最多的个数，不是_capacity，而是系统默然能储存的最大值，此时npos = -1）

当npos > len - pos 时 ， 就拷贝全部

举个例子：

destructor（析构函数）

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

operator=（赋值重载）

​
string& operator=(const string& s)
{
	char* tmp = new char[s._capacity + 1];
	strcpy(tmp, s._str);
	_size = s._size;
	_capacity = s._capacity;
	delete[] _str;
	_str = tmp;
	return *this;
}
//现代写法
string& operator=(string s)
{
    swap(s);
    return *this;
}
​

现代写法含义：传参时，s进行拷贝构造，在交换*this与s

iterator（迭代器）

迭代器的行为像指针

范围for的原理就是迭代器

#include
#include
using namespace std;
int main()
{
	string s("0000000000000000000");
	string::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
return 0;
}
 
 
#include
#include
using namespace std;
int main()
{
	string s("0000000000000000000");
	for( auto e : s )
     cout << e << " ";
    cout << endl;
	return 0;
}

这两个代码等效，原理都是迭代器

//迭代器底层实现
char* begin()
{
	return _str;
}
char* end()
{
	return _str + _size;
}
 
char* rbegin()
{
	return _str + _size;
}
char* rend()
{
	return _str;
}

capacity（容量）

_capacity当前开辟的空间最多能储存多少字符

_size代表当前有多少个有效的字符

库里面有提供查询_capacity,_size的函数

int size()
{
return _size;
}
int capacity()
{
return _capacity;
}

如何扩容：（库里面有两个函数，可以实现扩容）

第一个reserve

传入一个size_t的参数，作为要扩容到标准

当 n <= _capacity 一般不会造成缩容（这个要具体看编译器）

当 n > _capacity 会扩容

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

第二个resize函数

当 n < _size 会造成有效数据的删除（有可能会缩容）

当 n > _size 且n < _capacity 有可能会缩容，但会造成添加有效数据，一直到 n

当 n > _capacity 会造成扩容，并添加有效数据的个数，一直到 n 

void resize(size_t n, char c = '\0')
{
	if (n <= _size)
	{
		_size = (int)n;
		_str[n] = '\0';
	}
	else
	{
		reserve(n);
		for (; _size < n; _size++)
		{
			_str[_size] = c;
		}
		_str[_size] = '\0';// n为最多有效字符个数,_str[n] = '\0';
	}
}

clear函数

清空有效数据，令_size = 0;

empty函数

判断有效数据个数是否为0

operator[]

放回下标为pos的字符

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

需要assert（判断pos < _size ）,防止对未进行赋值的位置解引用

operator+=（传入的是字符串也可以，因为会进行隐式类型转换）

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

在字符串末尾添加字符串

具体使用：与整形变量的使用方法一样

append（传入的是字符串也可以，因为会进行隐式类型转换）

string& append(const string& str)
{
	*this += str;//复用上面的+=
	return *this;
}

举个例子：

push_back

在字符串末尾添加一个字符

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

assign（容量不改变）

第一个,第三个相当与拷贝构造

第二个就是将str中的字符串中的下标从subpos位置的sublen个字符，拷贝给*this

string& assign(const string& str, size_t subpos, size_t sublen)
{
	assert(_size - subpos >= sublen && sublen >= 0 );
	if (sublen > _capacity)reserve(sublen + _capacity);
	memcpy(_str, str._str + subpos, sublen);
	_size = sublen;
	_str[_size] = '\0';
	return *this;
}

第四个将s中的字符串前n个字符，给*this;

string& assign(const char* s, size_t n)
{
	if (n > _capacity)reserve(n);
	memcpy(_str, s, n);
	_size = n;
	_str[_size] = '\0';
	return *this;
}

第五个将n个字符c给*this

string& assign(size_t n, char c)
{
	if (n > _capacity)reserve(n);
	for (int i = 0; i < n; i++)
	{
		_str[i] = c;
	}
	_size = n;
	_str[n] = '\0';
	return *this;
}

insert

请注意可以插入一个string

在pos位置前插入字符或字符串

string& insert(size_t pos, char c)
{
if( _capacity == _size )reserve( 2 * _size );
	for (size_t i = _size; i > pos; i--)
	{
		_str[i] = _str[i - 1];
	}
    _size++;
	_str[pos] = c;
}
 
string& insert(size_t pos, const char* str)
{
	
	int len = strlen(str);
	if (len + _size > _capacity)reserve(len + _size);
	for (size_t i = _size + len  ; i >= pos + len; i--)
	{
		_str[i] = _str[i - len];
	}
	
	_size += len;
	memcpy(_str + pos, str, sizeof(char) * len);
	return *this;
}

使用方法：

自定义类型的变量 . insert ( 参数列表 ）

erase

string& erase(size_t pos = 0, size_t len = npos)
{
	assert(pos >= 0);
	if (pos + len >= _size)_size = pos;
	else
	{
		for (size_t i = pos + len; i < _size; i++)
		{
			_str[i - len] = _str[i];
		}
		_size -= len;
		
	}
	_str[_size] = '\0';
	return *this;
}

从下标为pos的位置，删除len个字符，其中当len == npos时，就将从pos位置起以后（包括pos位置的数据）的数据删除

find

size_t find(char c, size_t pos = 0) const
{
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] == c)return i;
	}
	return -1;//npos
}
size_t find(const char* s, size_t pos = 0) const
{
	char* tmp = strstr(_str , s );
	if (tmp == nullptr)
		return -1;
	else return tmp - _str;
}

找寻_str中是否存在字符c或字符串s,如果存在返回第一次出现时的下标

不存在，返回-1