【c++】string的模拟实现

目录

?一.? 交换函数swap

二.? 默认成员函数?

? ? ?构造函数和析构函数

? ? ?拷贝构造函数和赋值运算符重载

三.? 容量相关操作接口

? ? ?size 与 capacity

? ? ?reserve 与 resize

附：reserve与resize的区别

四.? 修改相关操作接口

? ? push_pack?

? ? append? ?

? ??insert 与 erase???

? ? operator+=

? ? find?

? ?substr

? ?clear

五.? 遍历访问相关接口

? ?使用迭代器

??operator[ ]?

?六.? 非成员函数流插入和流提取运算符重载?(<<、>>)

附：完整代码实现

---

示：string相关的操作接口有很多，这里实现了部分常用接口

---

? ? ? ? ? ?? ? ? ? ? ? ? ?

? ?

?一.? 交换函数swap

? ? ? ? ? ?在实现string之前先提供以下三个交换函数，如下：

? ?

//用于交换的交换函数模板
template <class T> 
void swap(T& a, T& b)
{
	T tmp = a;
	a = b; 
	b = tmp;
}

? ? 这是一个全局的交换函数，是一个泛型版本。此交换函数被定义在库当中，即头文件为<algorithm>的标准算法库里。但是，如果是交换一般的数据还是可以的；若是想要交换一个存储大量数据的类内容时，因这个交换函数涉及一个复制构造和两个赋值操作，此函数并不是最有效方法。

此时有另外两个交换函数：

? 这个交换函数是string当中的，是一个非成员函数；其实这是上面通用算法交换的重载，它通过相互转移对其内部数据的所有权来提高其性能（即，字符串交换对其数据的引用，而不实际复制字符）

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

? ??该交换函数使用行为类似于此成员函数的优化重载 ; 这是为处理大型数据类型提供此函数的重载版本，优化其性能，即只交换几个内部指针而不是它们的全部内容，从而使它们在恒定时间内运行。

说明：以下string的有关拷贝构造或赋值操作将用到以上的交换函数。

二.? 默认成员函数?

? ? ? ?构造函数和析构函数

构造函数：①写两个构造函数（无参和带参）；②直接写一个带缺省参数的构造函数(本次采? ? ? ? ? ? ? ? ? ? ? ? 用这个)? ? ? ? ?

? 带缺省参数的构造函数：? ?

? ? 缺省参数置为空字符串

析构函数：

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

拷贝构造函数和赋值运算符重载

拷贝构造：一个已存在的对象去拷贝初始化另一个对象。

首先先拷贝构造一个临时对象，在复用上面开始时所说的交换函数，交换两者指针即可

string(const string& s)
{
	string tmp(s._str); //拷贝构造临时对象tmp
	swap(tmp);        //交换两者数据，只需要交换两者指针即可
}

赋值运算符重载：将两个已存在的对象进行拷贝——赋值重载

string& operator=(string s) //注意这里不要加引用&
{
	swap(s);
	return *this;
}

说明：参数中不加引用的目的就是不改变原对象的中的内容。若加了引用就会改变原对象的内容，也即将s1与s2直接进行交换；这样虽然将s1赋给了s2，但s1本身也改了，这就不符合我们的需求。

三.? 容量相关操作接口

? ? ? ?size 与 capacity

?这是符合字符串内容的实际字节数，不一定等于其存储容量?；返回字符串的有效数据长度（以字节为单位）。

? ? ?

size_t size() const
{
	return _size;
}

返回当前为字符串分配的存储容量的大小。此容量不一定等于字符串长度，它可以相等或更大。

size_t capacity() const
{
	return _capacity;
}

reserve 与 resize

reserve : 如果 n 大于当前字符串容量，则该函数会导致容器将其容量增加到?n 个字符（或更大）

此函数对字符串长度没有影响，并且无法更改其内容；但若?n 小于当前字符串容量，有些平台会缩容(linux)，但是不会影像数据；有些不会(vs)，取决于编译器，即总的来说，该函数会影响容量，但不会影响有效数据。

void reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1]; //开辟新的空间
		strcpy(tmp, _str); //拷贝原数据到新空间
		delete[] _str;   //释放原空间
		_str = tmp;
		_capacity = n; //更新容量
	}
}

resize：将字符串大小调整为?n?个字符的有效长度。
如果 n 小于当前字符串长度，则当前值将缩短为其前 n?个字符，并删除第?n?个字符以外的字符。
如果 n 大于当前字符串长度，则通过在末尾插入任意数量的字符来扩展当前内容，以达到?n?的大小。

如果指定了?c，则新元素将初始化为?c?的副本，否则，它们是值初始化的字符（null字符）。

void string::resize(size_t n, char c)
{
    //n小于元素的个数
	if (n < _size)
	{
		_size = n;
		_str[_size] = '\0'; //末尾处理\0
	}
	else 
	{
        //n大于当前容量
		if (n > _capacity)
        {
			reserve(n);    //扩容
        }
		for (size_t i = _size; i < n; i++)//将size个元素后的填充为字符c
		{
			_str[i] = c;
		}
		_str[n] = '\0';
		_size = n;
	}
}

附：reserve与resize的区别

reserve用于预留空间，但不会改变容器的大小，只是增加容器的容量，如果超过容器的容量，会重新分配内存。

resize则是直接改变容器的大小，如果改变后的大小比原来的小，会删掉多余的元素，如果比原来的大，会添加默认值的元素。

总之：reserve 改变容器的容量——对应capacity

? ? ? ? ? ?resize 改变容器的大小——对应size，resize后 都为 有效元素

四.? 修改相关操作接口

? ? ? ?push_pack?

?push_back：将字符?c?追加到字符串的末尾，使其长度增加 一。

?

void push_back(char c)
{
	if (_size == _capacity) //检查容量
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
	}
	_str[_size] = c;
	_size++;
	_str[_size] = '\0'; //注意处理末尾\0
}

?append

??

?功能：在字符串当前值的末尾追加一个字符串

string& append(const char* str)
{
	size_t len = strlen(str);    //计算追加字符串的长度
	if (_size + len > _capacity) //检查容量
	{
		reserve(_size + len);
	}
	strcpy(_str + _size, str);  //把要追加的字符串追加到该字符串的末尾
	_size += len;
    return *this;
}

? ?

insert 与 erase?

insert：在pos位置插入一个字符

// 在pos位置上插入字符c/字符串str，并返回该字符的位置
string& insert(size_t pos, char c)
{
	assert(pos <= _size);
	if (_size == _capacity) //检查容量
	{
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
	}
	//注意size_t为无符号；这种写法程序会崩
	/*size_t end = _size;
	while (end >= pos)           
	{
		_str[end + 1] = _str[end];
		--end;
	}*/
	size_t end = _size + 1;  
	while (end > pos)         //pos位置后元素向后挪
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = c;
	_size++;
	return *this;
}

? ? ? ? ? ?

insert：在pos位置插入一个字符串

string& insert(size_t pos, const char* str)
{
	assert(pos <= _size);

	size_t len = strlen(str);      //计算原字符串的长度
	if (_size + len > _capacity)   //检查容量
	{
		reserve(_size + len);
	}
	size_t end = _size + 1;
	while (end > pos)              //pos后的元素向后挪动(end+len)个长度
	{
		_str[end + len - 1] = _str[end - 1];
		--end;
	}
	strncpy(_str + pos, str, len);  //注意这里不要用strcpy
	_size += len;
	return *this;
}

说明：①挪动数据时从\0 开始挪动 (即 \0 也要挪动)

? ? ? ? ? ?②这里不使用strcpy 而 使用strncpy,? 是因为strcpy会把 \0 也拷贝进去，这样拷贝后有效数据元素的个数（即size）就不一定对了。

? ? erase?

功能：删除字符串值中从字符位置 pos 开始并跨越 len 个字符的部分（如果内容太短? ? ? ? ? ? 或?len?为?nops，则删除直到字符串末尾的部分。

注意：如果不写len(即为默认参数)，则会删除pos往后的所有字符（有多少删多少）?

// 删除pos位置上的元素，并返回该元素的下一个位置
	string& erase(size_t pos, size_t len)
	{
		assert(pos < _size);

		if (len == npos || pos + len >= _size)
		{
			_str[pos] = '\0';
			_size = pos;
			return *this;
		}
		strcpy(_str + pos, _str + pos + len);
		_size -= len;
		return *this;
	}

? ? ? ? ? 图解?：

? ? ?

? ? operator+=

??

? ?功能：在字符串当前值的末尾追加一个字符

string& operator+=(char c)
{
	push_back(c); //复用push_back即可
	return *this;
}

功能：在字符串当前值的末尾追加一个字符串

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

? ? ?find?

功能：从指定的pos位置处开始（若不指定默认从第一个字符开始）查找一个匹配的字符c

返回值：返回c在字符串中第一次出现的位置

// 返回c在string中第一次出现的位置
size_t find(char c, size_t pos) const
{
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] == c)
			return i;
	}
	return npos;
}

? ? ? ? ? ?? ? ? ? ? ?

功能：从指定的pos位置处开始（若不指定默认从第一个字符开始）查找一个匹配的字符串

返回值：第一个匹配项的第一个字符的位置。
? ? ? ? ? ? ? 如果未找到匹配项，该函数将返回?string::npos。

// 返回子串s在string中第一次出现的位置
size_t find(const char* s, size_t pos) const
{
	const char* ptr = strstr(_str + pos, s);
	if (ptr == nullptr)
		return npos;
	return ptr - _str;
}

? ? ?substr

?返回值：返回一个新构造的对象，其值初始化为此对象的子字符串的副本 ??

string substr(size_t pos, size_t len)
{
	assert(pos < _size);

	size_t end = len + pos;
	if (len == npos || pos + len >= _size)
	{
		end = _size;
	}
	string str;
	str.reserve(end - pos);
	for (size_t i = pos; i < end; i++)
	{
		str += _str[i];
	}
	return str;
}

? ? ?图解：??? ?

? ?clear

? ? ? ? ?功能：擦除字符串的内容，该字符串将变为空字符串（长度为?0?个字符）。

void clear()
{
	_str[0] = '\0'; //注意首字符置为\0
	_size = 0;
}

五.? 遍历访问相关接口

? ? ? ?使用迭代器

?begin:

功能：如果字符串对象是 const 限定的，则该函数返回const_iterator。否则，它将返回一个迭代器。 ? ? ? ??

//返回iterator迭代器 
iterator begin()
{
	return _str;
}

//返回const_iterator迭代器
const_iterator begin() const
{
	return _str;
}

end:

功能：如果字符串对象是 const 限定的，则该函数返回const_iterator。否则，它将返回一个迭代器。

//返回iterator 迭代器
iterator end()
{
	return _str + _size;
}

//返回const_iterator 迭代器
const_iterator end() const
{
	return _str + _size;
}

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];
}

?六.? 非成员函数流插入和流提取运算符重载?(<<、>>)

? <<:? ?? ? 功能：将符合?str?值的字符序列插入到?os?中。??

ostream& operator<<(ostream& out, const string& s)
{
	for (auto ch : s)
	{
		out << ch;
	}
	return out;
}

>>:

功能：从输入流中提取字符串，将序列存储在 str 中，该序列被覆盖（替换了?str?的先前值）。

注意：输入流提取操作使用空格作为分隔符(在获取字符时会自动忽略空格)，因此操作将仅从流中提取可视为单词的内容

istream& operator>>(istream& in, string& s)
{
	char ch = in.get(); //这里用get()获取字符(包括空格)，直到遇到换行结束
	while (ch != ' ' && ch != '\0')
	{
		s += ch;
		ch = in.get();
	}
	return in;
}

附：完整代码实现

#include <iostream>
#include <assert.h>
using namespace std;

namespace mystring
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;
	public:
		
		string(const char* str = "");
		~string();

		string(const string& s);
		string& operator=(const string& s);
		
		void resize(size_t n, char c);
		void resize(size_t n);
		void reserve(size_t n);

		void push_back(char c);
		string& operator+=(char c);
		string& operator+=(const char* str);
		void append(const char* str);

		void clear();
		void swap(string& s);


		char& operator[](size_t pos);
		const char& operator[](size_t pos) const;

		size_t find(char c, size_t pos = 0) const;       
		size_t find(const char* s, size_t pos = 0) const; 
		string substr(size_t pos = 0, size_t len = npos);
		string& insert(size_t pos, char c);              
		string& insert(size_t pos, const char* str);
		string& erase(size_t pos, size_t len = npos);     

	private:
		char* _str;
		size_t _size;
		size_t _capacity;

		const static size_t npos = -1;
	};

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

		strcpy(_str, str);
	}
	
	string(const string& s)
	{
		string tmp(s._str);
		swap(tmp);
	}

	string& operator=(string s)
	{
		swap(s);
		return *this;
	}

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

    // 容量
	size_t size() const
	{
		return _size;
	}

    size_t capacity() const
    {
	    return _capacity;
    }

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

	void string::resize(size_t n, char c)
	{
		if (n < _size)
		{
			_size = n;
			_str[_size] = '\0';
		}
		else 
		{
			if (n > _capacity)
				reserve(n);
			for (size_t i = _size; i < n; i++)
			{
				_str[i] = c;
			}
			_str[n] = '\0';
			_size = n;
		}
	}

	void string::resize(size_t n)
	{
		if (n < _size)
		{
			_size = n;
			_str[_size] = '\0';
		}
		else
		{
			if (n > _capacity)
				reserve(n);
			for (size_t i = _size; i < n; i++)
			{
				_str[i] = '\0';
			}
			_size = n;
		}
	}

	// 修改
	void string::push_back(char c)
	{
		if (_size == _capacity)
		{
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
		_str[_size] = c;
		_size++;
		_str[_size] = '\0';
	}

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

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

	void string::append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
		strcpy(_str + _size, str);
		_size += len;
	}

	void string::clear()
	{
		_str[0] = '\0';
		_size = 0;
	}

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

	// 访问
	iterator begin()
	{
		return _str;
	}

	const_iterator begin() const
	{
		return _str;
	}

	iterator end()
	{
		return _str + _size;
	}

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

	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];
	}

	// 返回c在string中第一次出现的位置
	size_t string::find(char c, size_t pos) const
	{
		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == c)
				return i;
		}
		return npos;
	}

	// 返回子串s在string中第一次出现的位置
	size_t string::find(const char* s, size_t pos) const
	{
		const char* ptr = strstr(_str + pos, s);
		if (ptr == nullptr)
			return npos;
		return ptr - _str;
	}

	string string::substr(size_t pos, size_t len)
	{
		assert(pos < _size);
		size_t end = len + pos;
		if (len == npos || pos + len >= _size)
		{
			end = _size;
		}
		string str;
		str.reserve(end - pos);
		for (size_t i = pos; i < end; i++)
		{
			str += _str[i];
		}
		return str;
	}

	// 在pos位置上插入字符c/字符串str，并返回该字符的位置
	string& string::insert(size_t pos, char c)
	{
		assert(pos <= _size);
		if (_size == _capacity)
		{
			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newcapacity);
		}
		size_t end = _size + 1;
		while (end > pos)
		{
			_str[end] = _str[end - 1];
			--end;
		}
		_str[pos] = c;
		_size++;
		return *this;
	}

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

	// 删除pos位置上的元素，并返回该元素的下一个位置
	string& string::erase(size_t pos, size_t len)
	{
		assert(pos < _size);
		if (len == npos || pos + len >= _size)
		{
			_str[pos] = '\0';
			_size = pos;
			return *this;
		}
		strcpy(_str + pos, _str + pos + len);
		_size -= len;
		return *this;
	}
    
    //流插入、流提取
	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto ch : s)
		{
			out << ch;
		}
		return out;
	}

	istream& operator>>(istream& in, string& s)
	{
		char ch = in.get();
		while (ch != ' ' && ch != '\0')
		{
			s += ch;
			ch = in.get();
		}
		return in;
	}

}

---