C++ string及其模拟实现-优快云博客

什么是string

string是c++中的一个用来保存字符串的部分。

string底层：字符数组，数组大小，数组容量

注意初始化，否则会造成重复析构。

private:
	char* _str = nullptr;//指针,指向对应的字符数组
	size_t _size = 0;//字符串的大小
	size_t _capacity = 0;//容量

string的常用接口

构造和析构

构造

string(const char* str = "");//string s1("aaa");
string(const string& s);//string s2(s1)
string& operator=(string s);//string s3 = s1

使用

string s1("1234567");
string s2(s1);
string s3 = s1;
cout << s1 << endl;
cout << s2 << endl;
cout << s3 << endl;

运行结果

1234567

1234567

1234567

模拟实现

构造都是将传入的字符串深拷贝然后更改对应的_size和_capacity。为避免析构时重复释放，不能使用直接修改指针的浅拷贝。

//构造

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

	strcpy(_str, str);
}

string::string(const string& s)
{
	string tmp(s._str);
	swap(tmp);
}

string& string::operator=(string s)
{

	swap(s);
	return *this;

}

析构

析构是string在生命周期结束时所进行的内存释放的一系列操作，这样可以避免内存泄漏。

//析构
~string();

析构相比来说就比较简单了，只需delete字符数组后将指针置NULL，对应的size和capacity置零即可。

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

empty ()

判断string是否为空，为空返回true

使用

string s1("1234567");
string s2;
cout << s1.empty() << endl;
cout << s2.empty() << endl;

运行结果

0

1

模拟实现

//字符串的判空
bool empty()
{
	if (_str == nullptr) return true;
	return false;
}

find()

从pos位置开始查找第一个出现的字符/字符串。找到返回位置，没找到返回 npos

size_t npos = -1

使用

string s1("1234567");
cout << s1.find('1') << endl;
cout << s1.find("4567") << endl;
cout << s1.find('a') << endl;

运行结果

0

3

18446744073709551615

模拟实现

//查找
size_t string::find(char ch, size_t pos)
{
	assert(pos < _size);

	for (int i = pos; i < _size; i++)
	{
		if (_str[i] == ch) return i;
	}
	return npos;//未找到
}
size_t string::find(const char* str, size_t pos)
{
	assert(pos < _size);

	const char* ptr = strstr(_str + pos, str);
	if (ptr == nullptr)
	{
		return npos;
	}
	else
	{
		return ptr - _str;
	}
}

swap()

交换有两种，一种是string内的，另一种是string外的。两种swap本质上都是一样的。

使用

string s1("1234567");
string s2("xxxxxxx");
string s3("aaaaaaaa");
string s4("bbbbbbbbbb");

s1.swap(s2);
swap(s3, s4);

cout << s1 << endl;
cout << s2 << endl;

cout << s3 << endl;
cout << s4 << endl;

运行结果

xxxxxxx
1234567
bbbbbbbbbb
aaaaaaaa

模拟实现

//交换
void swap(string& s);
void swap(string& s1, string& s2);

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

void swap(string& s1, string& s2)
{
	s1.swap(s2);
}

size()

计算string大小并返回。因为底层含有size，所以直接返回即可。

//字符串的大小
size_t size() { return _size; }

capacity()

计算string容量并返回，因为底层含有capacity，所以直接返回即可。

//字符串的容量
size_t capacity() { return _capacity; }

clear()

将string内容清空。不是析构因为没有释放空间

//字符串的判空
bool empty()
{
	if (_str == nullptr) return true;
	return false;
}

reverse()

扩容，传入的为所需扩到的空间。为了减少扩容次数，提高效率，我们每次扩容时都会扩为原来的 1.5-2 倍。

//扩容
void string::reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;

		_capacity = n;
	}
}

insert()

在pos位置插入字符/字符串。

void insert(int pos, char s);
void insert(int pos, const char* str);

//在指定位置插入字符/字符串
void string::insert(int pos, char s)
{
	assert(pos <= _size);
	if (_capacity == _size)//空间不足则扩容
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	size_t end = _size + 1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = s;
	_size++;
}
void string::insert(int pos, const char* str)
{
	assert(pos <= _size);//判断插入位置是否越界
	int len = strlen(str);
	if (_size + len > _capacity)//判断容量是否足够，不足则扩容
	{
		size_t newcapacity = _capacity * 2;
		if (newcapacity < _size + len)
			newcapacity = _size + len;
		reserve(newcapacity);
	}
	size_t end = _size + len;
	while (end > pos + len - 1)//将插入位置之后的字符后移一位，腾出空间
	{
		_str[end] = _str[end - len];
		--end;
	}
	for (int i = 0; i < len; i++)
	{
		_str[pos + i] = str[i];
	}
	_size += len;
}

push_back()

在尾部插入字符。有了insert，尾插就相当于在size位置插入了。

//尾插字符
void string::push_back(char s)
{
	insert(_size, s);
}
//尾插字符串
void string::append(const char* str)
{
	insert(_size, str);
}

erase()

删除pos位置的len个字符。每次删除后都需向前移动pos+len之后的字符，填补上删除的位置。

void string::erase(size_t pos, size_t len)
{
	assert(pos < _size);

	if (len >= _size - pos)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		// 从后往前挪
		size_t end = pos + len;
		while (end <= _size)
		{
			_str[end - len] = _str[end];
			++end;
		}

		_size -= len;
	}
}

pop_back()

删除尾部字符。相当于删除size-1位置上的1个字符。

//尾删
void string::pop_back()
{
	if (_size == 0) return;
	_size--;
}

operator+=()

在尾部插入字符/字符串。相当于在size位置插入的insert/push_back。直接调用即可。

//尾插字符/字符串
string& string::operator+=(char s)
{
	push_back(s);
	return *this;
}
string& string::operator+=(const char* str)
{
	append(str);
	return *this;
}

operator==()

计算两个string是否相等。

bool operator==(const string& lhs, const string& rhs)
{
	return strcmp(lhs.c_str(), rhs.c_str()) == 0;
}

operator!=()

==直接取反。

operator[] (）

让string能够像数组一样使用。读取每一个字符。直接调用指针的【】即可。

// []
char& operator[](size_t i)
{
	assert(i < _size);

	return _str[i];
}

string比较

operator<=()，operator<()，operator>=()，operator>()

string比较，比较的是ASCII码值。

bool operator>(const string& lhs, const string& rhs)
{
	return !(lhs <= rhs);
}
bool operator<(const string& lhs, const string& rhs)
{
	return strcmp(lhs.c_str(), rhs.c_str()) < 0;
}
bool operator>=(const string& lhs, const string& rhs)
{
	return !(lhs < rhs);
}
bool operator<=(const string& lhs, const string& rhs)
{
	return lhs == rhs || lhs < rhs;
}

operator>>()，operator<<()

流插入和流提取。

ostream& operator<<(ostream& os, const string& str)
{
	for (int i = 0; i < str.size(); i++)
	{
		os << str[i]; //往os写入
	}
	return os;
}
istream& operator>>(istream& is, string& str)
{
	str.clear();

	int i = 0;
	char buff[256];

	char ch;
	ch = is.get();
	while (ch != ' ' && ch != '\n')
	{
		// 放到buff
		buff[i++] = ch;
		if (i == 255)
		{
			buff[i] = '\0';
			str += buff;
			i = 0;
		}

		ch = is.get();
	}

	if (i > 0)
	{
		buff[i] = '\0';
		str += buff;
	}

	return is;
}

getline()

整行读取。主要原理是先放到一个临时字符数组里，当读取到换行符号时再将临时数组拷贝到对应的字符串中。

//整行读取
istream& getline(istream& is, string& str, char delim)
{
	str.clear();

	int i = 0;
	char buff[256];

	char ch;
	ch = is.get();
	while (ch != delim)
	{
		// 放到buff
		buff[i++] = ch;
		if (i == 255)
		{
			buff[i] = '\0';
			str += buff;
			i = 0;
		}

		ch = is.get();
	}

	if (i > 0)
	{
		buff[i] = '\0';
		str += buff;
	}

	return is;
}

迭代器

底层：字符指针。需要注意的是要记得做对应的const的接口。避免权限放大问题。

//迭代器
using iterator = char*;
using const_iterator = const char*;

begin()，end()

iterator begin()
{
	return _str;
}
iterator end()
{
	return _str + _size;
}
const_iterator begin() const
{
	return _str;
}
const_iterator end() const
{
	return _str + _size;
}
size_t size() const
{
	return _size;
}