C++教你如何模拟实现string,如何实现string写时拷贝

文章目录

  • 前言
  • 成员变量
  • 默认成员函数
    • 默认构造函数
    • 拷贝构造函数
    • 析构函数
    • 赋值运算符重载
  • 容量相关函数(Capacity)
    • reserve函数
    • resize函数
    • size函数
    • capacity 函数
    • clear函数
  • 修改函数(Modifiers)
  • swap函数
    • insert函数
      • 字符插入
      • 字符串插入
    • append函数
    • push_back函数
    • erase函数
    • +=重载
  • 元素获取函数(Element access)
  • operator[]
  • 操作函数(String operations)
    • c_str函数
    • substr函数
    • find函数
  • 运算符重载
    • 流插入运算符<<重载
    • 流提取运算符>>重载
  • 完整代码
  • 写实拷贝
    • 写时拷贝完整代码

前言

本文将要对STL容器string进行模拟实现,将要实现string常用构造函数,析构函数,拷贝构造函数以及常用增删查改接口,介绍如何通过函数复用以达到简化代码,如何通过写实拷贝提高程序效率,通过模拟实现达到加深对string的理解,提高自身编程技巧的效果。

注:本文在读者拥有string相关知识储备的基础下更易于理解,可跳转链接阅读博主的另一篇文章掌握如何使用string后再来阅读


成员变量

cpp 复制代码
	private:		
		char* _str=nullptr;//字符串
		size_t _capacity=0;//容量
		size_t _size=0;//有效字符个数
		static const size_t npos;
		//static const size_t npos=-1  vs下int类型支持给static和const同时修饰的变量用缺省值

默认成员函数

默认构造函数

默认构造函数(无参构造函数)是构造一个空的字符串。

cpp 复制代码
        string()
			:_str(new char[1])
			, _capacity(0)
			, _size(0)
		{
			_str[0] = '\0';
		}

像上面这样写如何?可以,但是可以更简洁一些。

像下面这样写更加简洁并且好处在于C-string构造函数可以同时担任默认构造函数与C-string构造函数的角色,这一点利用了语言的语法规则,如果我们显示定义构造函数后编译器则不会再生成默认构造函数

cpp 复制代码
		string(const char* str="")//对象实例化不传递参数则默认用空字符串拷贝构造
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

注:实现string(const char* str="")后不可以再显示实现默认构造函数,否则会造成调用歧义。

在调用方面,如果我们想要实例化一个空字符串的string对象要以以下方式调用

cpp 复制代码
string s1;

绝对不可以用以下的方式调用,错误示例如下:

在这种情况下编译器会把它识别为函数声明

cpp 复制代码
string s1();

拷贝构造函数

拷贝构造函数是用一个类对象实例化另一个类对象

cpp 复制代码
		string(const string& str)
		{
			_size = str._size;
			_capacity = str._capacity;
			_str = str._str;
		}

如果以以上方式编写后进行调用会发生什么

在调用之前我们先实现一个方便我们观察运行时现象的析构函数

析构函数

清理对象占用内存资源

cpp 复制代码
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = 0;
			_capacity = 0;
			//cout<<~string()<<endl;此语句仅为观察使用
		}

运行程序

监视窗口

RUN:运行错误
  以上为典型浅拷贝引起的delete内存释放错误,浅拷贝使得两个对象共享同一块内存资源,在内存释放时对同一内存空间进行多次释放引起错误。

默认拷贝构造函数同样是浅拷贝,仅对对象的成员变量的值进行拷贝。

什么是浅拷贝?

浅拷贝:也称位拷贝,编译器只是将对象中的值拷贝过来。如果对象中管理资源,最后就会导致多个对象共享同一份资源,当一个对象销毁时就会将该资源释放掉,而此时另一些对象不知道该资源已经被释放,以为还有效,所以当继续对资源进项操作时,就会发生发生了访问违规。其实我们可以采用深拷贝解决浅拷贝问题,即:每个对象都有一份独立的资源,不要和其他对象共享。

什么是深拷贝

深拷贝是指在进行对象拷贝时,不仅复制对象本身的成员变量,还复制对象所指向的动态分配的资源(例如堆内存)到新的对象中。这意味着拷贝后的对象和原对象拥有独立的资源副本,彼此之间不会相互影响。

当对象中含有动态分配的资源,如指针指向的内存块,或者其他动态分配的资源(文件句柄、网络连接等),进行深拷贝是非常重要的,以避免多个对象共享同一块资源导致释放重复、悬挂指针(悬挂指针:指的是一个指针变量指向了曾经被分配的内存地址,但该内存已经被释放或者回收了。在这种情况下,指针仍然指向原来的内存地址,但那个地址现在可能已经被操作系统重新分配给了其他程序或变量,或者已经被标记为不可用。)等问题。

如果一个类中涉及到资源的管理,其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供

拷贝构造正确编写方法

cpp 复制代码
		string(const string& str)
		{
			_str = new char[str._capacity + 1];
			strcpy(_str, str._str);
			_size = str._size;
			_capacity = str._capacity;
		}

通过函数复用进行优化

cpp 复制代码
		void swap(string& str)//交换对象内容
		{
			std::swap(_size, str._size);
			std::swap(_capacity, str._capacity);
			std::swap(_str, str._str);
		}
		string(const string& str)
		:_str(nullptr)//_str用nullptr初始化是为了确保与之交换的指针不会成为野指针,导致不必要错误
        ,_size(0)
        ,_capacity(0)
		{
			string temp(str._str);
			swap(temp);
			//this->swap(temp);编译器为每个非静态的成员函数配备一个this指针
			//这个this指针可以显示使用,也可以不显示使用
		}

这样设计的原理是调用C-string构造函数后再交换两个对象的内容,temp对象出作用域之后自动销毁。

这种方法虽然简化了代码但存在着一定问题,像_size 与_capacity的大小可能与被拷贝对象的值不相同,但问题可忽略。

关于为什么不使用标准库的swap函数进行数据交换

在C++之前swap是以下形式实现
  它首先会拷贝构造一个对象,然后再进行赋值拷贝,这种实现方法十分低效

C++11之后新增的运行移动语义使得其实现更高效,如果使用C++之后的swap,它的效率与我们模拟实现的方法的效率相比更高效,它省去了一切资源的开辟。

此内容需要大篇幅讲解才能理清逻辑,因本文重点不在此,故不进行详细讲解。

赋值运算符重载

cpp 复制代码
		string& operator =(const string& s)
		{
			if (this != &s)//如果"自己"给"自己"赋值则直接跳过
			{
				char* temp = new char[s._capacity + 1];
				strcpy(temp, s._str);
				delete[] _str;
				_str = temp;
				_size = s._size;
				_capacity = s._capacity;
			}
			return *this;
		}

优化

cpp 复制代码
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				string temp(s);
				swap(temp);
			}
			return *this;
		}

再优化

cpp 复制代码
		string& operator=(string s)
		{
			swap(s);
			return *this;
		}

通过值拷贝的方式传递参数,直接生成一个临时对象,再交换对象内容,达到简化代码的效果。


容量相关函数(Capacity)

reserve函数

根据Windows平台下的reserve规则

n > _capacity时对对象的容量进行扩容

n<=_capacity时不对对象的容量进行修改

cpp 复制代码
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;

				_str = tmp;
				_capacity = n;
			}
		}

开辟新空间,转移数据,释放原空间,修改成员变量

resize函数

根据Windows平台下的reserve规则

n>_size

首先判断n > _capacity是否成立,成立则首先进行扩容操作

再将[_size,n)区间内容填入指定字符ch

n<=_size时对对象的有效字符进行缩减,将有效字符缩减至指定个数

cpp 复制代码
		void resize(size_t n, char ch = '\0')
		{
			if (n > _size)
			{
				reserve(n);
				for (int i = _size; i < n; ++i)
				{
					_str[i] = ch;
				}
			}
			_str[n] = '\0';//必须给_str[n]赋值'\0',以做字符串结束标志
			_size = n;
		}

size函数

返回字符串有效字符长度

cpp 复制代码
size_t size() const
{
	return _size;
}

capacity 函数

返回空间总大小

cpp 复制代码
size_t capacity() const
{
	return _capacity;
}

clear函数

cpp 复制代码
		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}

清空字符串内容只需要修改字符串结束标志,下次再对字符串进行操作会覆盖式写入内容。


修改函数(Modifiers)

swap函数

交换两个对象内容

cpp 复制代码
		void swap(string& str)
		{
			std::swap(_size, str._size);
			std::swap(_capacity, str._capacity);
			std::swap(_str, str._str);
		}

insert函数

字符插入

在指定位置插入一个字符

cpp 复制代码
string& insert(size_t pos, char ch)
{
	assert(pos <= _size);

	// 判断是否需要扩容
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}

	size_t end = _size + 1;
	while (end > pos)//将插入位置 pos 之后的字符依次向后移动一个位置。
	{
		_str[end] = _str[end - 1];
		--end;
	}

	_str[pos] = ch;//将字符 ch 插入到指定的插入位置 pos
	++_size;//插入字符后,将字符串的实际大小 _size 增加 1

	return *this;
}

字符串插入

在指定位置插入一个字符串

cpp 复制代码
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 + len;
	while (end >= pos + len)//将插入位置 pos 之后的字符依次向后移动 len 个位置,为新字符串的插入留出空间
	{
		_str[end] = _str[end - len];
		--end;
	}

	strncpy(_str + pos, str, len);//将字符串拷贝到指定位置
	_size += len;//插入字符后,将字符串的实际大小 _size 增加 len

	return *this;
}

append函数

在字符串后追加一个字符串

cpp 复制代码
void append(const char* str)
{
	size_t len = strlen(str);

// 判读是否需要扩容
	if (_size + len > _capacity)
	{
		reserve(_size+len);
	}

	strcpy(_str + _size, str);
	_size += len;
}

通过复用insert实现

cpp 复制代码
void append(const char* str)
{
	insert(_size, str);
}

push_back函数

字符串尾插一个字符

cpp 复制代码
void push_back(char ch)
{
	// 判读是否需要扩容
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}

	_str[_size] = ch;
	++_size;
	_str[_size] = '\0';//作为字符串必须要字符串结束标志
}

通过复用insert实现

cpp 复制代码
void push_back(char ch)
{
	insert(_size, ch);
}

erase函数

cpp 复制代码
		void erase(size_t pos, 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;
			}
		}

如果len 等于缺省值 npos则将pos及以后字符全部删除

如果删除字符个数超过pos位置后字符总和则同样将pos及以后字符全部删除

如果以上两种情况不成立则直接将从位置 pos + len 开始的字符复制到位置 pos,覆盖掉要删除的字符。

+=重载

+= 运算符在字符串的操作中通常被用作连接(拼接)操作。

连接一个字符

cpp 复制代码
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

连接一个字符串

cpp 复制代码
		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}

元素获取函数(Element access)

operator[]

返回pos位置的字符,可修改pos位置字符

cpp 复制代码
		char& operator[](size_t pos)
		{
			assert(pos < _size);

			return _str[pos];
		}

返回pos位置的字符,不可修改pos位置字符

cpp 复制代码
		const char& operator[](size_t pos) const
		{
			assert(pos < _size);

			return _str[pos];
		}

注意断言,下标位置不能等于_size,_size指向最后一个字符的下一个也就是字符0,但是实际库中的string的字符0我们是可以访问到的,这里主要表示有效数据的访问。


操作函数(String operations)

c_str函数

返回C格式字符串

cpp 复制代码
		const char* c_str() const
		{
			return _str;
		}

substr函数

获取一个子字符串

cpp 复制代码
		string substr(size_t pos, size_t len = npos) const
		{
			assert(pos < _size);
			string str;
			if (len == npos || pos + len >= _size)
			{
				str.reserve(_size-pos);
				str._size = _size - pos;
				strcpy(str._str, _str + pos);
			}
			else
			{
				str.reserve(len);
				str._size = len;
				strncpy(str._str,_str + pos,len);
				str._str[_size] = '\0';
			}
			return str;
		}

如果len长度超过pos位置后字符总和或者为缺省值则将pos及以后字符全部复制,反之则复制其区间到目标字符串str,然后将字符串末尾添加字符串结束标志'\0'.

优化

cpp 复制代码
		string substr(size_t pos, size_t len = npos) const
		{
			assert(pos < _size);
			size_t end = pos+len;
			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;
		}

确定被拷贝字符串的末尾位置,然后将被拷贝字符串的字符依次连接到目标字符串中。

find函数

查找一个字符查找成功返回其下标,查找一个字符串查找成功返回其字符串的起始下标,查找失败均返回npos值

cpp 复制代码
size_t find(const char ch, size_t pos = 0)
{
    assert(pos < _size);
	while (pos < _size)
    {
        if (_str[pos] == ch)
        {
            return pos;
		}
        ++pos;
	}
    return npos;
}
size_t find(const char* str, size_t pos = 0)
{
    const char* ptr = strstr(_str + pos, str);
    if (ptr == nullptr)
    {
        return npos;
    }
    else
    {
        return ptr - _str;
    }
}

strstr 是一个库函数,用于在一个字符串中查找另一个字符串的首次出现位置

char *strstr(const char *haystack, const char *needle);

haystack 是要在其中进行搜索的字符串,也被称为主字符串。

needle 是要在 haystack 中查找的子字符串。

如果 needle 在 haystack 中找到,则 strstr 返回指向 haystack 中 needle 首次出现位置的指针。如果未找到 needle,则返回 NULL。

运算符重载

流插入运算符<<重载

流插入运算符<<重载要定义为全局函数,因为定义为全局函数,因此在其实现中不能直接访问类的私有成员,而需要通过类的公有接口进行访问,或者将其定义为类的友元函数进而访问其私有成员。

cpp 复制代码
	std::ostream& operator<<(std::ostream& out, const string& s)
	{
		for (size_t i = 0; i < s.size(); ++i)
		{
			out << s[i];
		}
		return out;
	}

流提取运算符>>重载

cpp 复制代码
	std::istream& operator>>(std::istream& in, string& s)
	{
		s.clear();
		char ch = in.get();
		while (ch != ' ' && ch != '\n')
		{
			s += ch;
			ch = in.get();
		}
		return in;
	}

使用istream的成员函数get,每次读入一个字符
  以上设计方法存在频繁扩容的问题,如果我们频繁输入就会频繁进行扩容操作,频繁进行函数调用会降低效率,因此我们可以创建一个"输入缓冲区buff"当缓冲区填满则将缓冲区内容刷新出去,当输入结束再将未刷新的缓冲区进行刷新,该策略在语言层面和操作系统层面有着广泛应用。

cpp 复制代码
	std::istream& operator>>(std::istream& in, string& s)
	{
		s.clear();
		char buff[128] = { '\0' };
		size_t i = 0;
		char ch = in.get();
		while (ch != ' ' && ch != '\n')
		{
			if (i == 127)
			{
				s += buff;
				i = 0;
			}
			buff[i++] = ch;
			ch = in.get();
		}
		if (i >= 0)
		{
			buff[i] = '\0';
			s += buff;
		}
		return in;
	}

完整代码

cpp 复制代码
#pragma once
#include<Cassert>
namespace zyc
{
	class string
	{
		//friend std::ostream& operator<<(std::ostream& out, const zyc::string& s);//设置为友元函数直接访问类的私有成员变量
		typedef char* iterator;
		typedef const char* const_iterator;
	public:
		string(const char* str = "")
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		void swap(string& str)
		{
			std::swap(_size, str._size);
			std::swap(_capacity, str._capacity);
			std::swap(_str, str._str);
		}
		string(const string& str)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			string temp(str._str);
			swap(temp);
		}
	
		string& operator=(string s)
		{
			swap(s);
			return *this;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = 0;
			_capacity = 0;
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;

				_str = tmp;
				_capacity = n;
			}
		}
		void resize(size_t n, char ch = '\0')
		{
			if (n > _size)
			{
				reserve(n);
				for (int i = _size; _size < n; i++)
				{
					_str[i] = ch;
				}
			}
			_str[n] = '\0';
			_size = n;
		}
		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);

			// 满了就扩容
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			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* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}

			// 挪动数据
			size_t end = _size + len;
			while (end >= pos + len)
			{
				_str[end] = _str[end - len];
				--end;
			}

			strncpy(_str + pos, str, len);
			_size += len;

			return *this;
		}
		void append(const char* str)
		{
			size_t len = strlen(str);

			// 满了就扩容
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}

			strcpy(_str + _size, str);
			_size += len;
		}
		/*void append(const char* str)
		{
			insert(_size, str);
		}*/
		void push_back(char ch)
		{
			// 满了就扩容
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		void erase(size_t pos, 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;
			}
		}
		/*string substr(size_t pos, size_t len = npos) const
		{
			assert(pos < _size);
			string str;
			if (len == npos || pos + len >= _size)
			{
				str.reserve(_size-pos);
				str._size = _size - pos;
				strcpy(str._str, _str + pos);
			}
			else
			{
				str.reserve(len);
				str._size = len;
				strncpy(str._str,_str + pos,len);
				str._str[_size] = '\0';
			}
			return str;
		}*/
		string substr(size_t pos, size_t len = npos) const
		{
			assert(pos < _size);
			size_t end = pos+len;
			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;
		}

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

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

		
		const char* c_str() const
		{
			return _str;
		}
		size_t size() const
		{
			return _size;
		}
		size_t capacity() const
		{
			return _capacity;
		}
		size_t find(const char ch, size_t pos = 0)
		{
			assert(pos < _size);
			while (pos < _size)
			{
				if (_str[pos] == ch)
				{
					return pos;
				}
				++pos;
			}
			return npos;
		}
		size_t find(const char* str, size_t pos = 0)
		{
			const char* ptr = strstr(_str + pos, str);
			if (ptr == nullptr)
			{
				return npos;
			}
			else
			{
				return ptr - _str;
			}
		}

		const char& operator[](size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}

	private:
		char* _str;//字符串
		size_t _capacity;//容量
		size_t _size;//有效字符个数
		static const size_t npos = -1; //vs下int类型支持给static和const同时修饰的变量用缺省值
	};
	std::ostream& operator<<(std::ostream& out, const string& s)
	{
		for (size_t i = 0; i < s.size(); ++i)
		{
			out << s[i];
		}
		return out;
	}
/*std::istream& operator>>(std::istream& in, string& s)
	{
		s.clear();
		char ch = in.get();
		while (ch != ' ' && ch != '\n')
		{
			s += ch;
			ch = in.get();
		}
		return in;
	}*/

	std::istream& operator>>(std::istream& in, string& s)
	{
		s.clear();
		char buff[128] = { '\0' };
		size_t i = 0;
		char ch = in.get();
		while (ch != ' ' && ch != '\n')
		{
			if (i == 127)
			{
				s += buff;
				i = 0;
			}
			buff[i++] = ch;
			ch = in.get();
		}
		if (i >= 0)
		{
			buff[i] = '\0';
			s += buff;
		}
		return in;
	}

}

写实拷贝

写时拷贝(Copy-on-Write,简称COW)是一种计算机程序设计领域的优化策略,用于延迟复制资源的实际发生,直到真正需要修改资源时。在写时拷贝的场景中,多个引用(或"视图")最初指向同一份资源。当某个引用尝试修改资源时,系统才会创建该资源的一个副本,并让修改的引用指向这个新的副本,而其他的引用仍然指向原始的资源。

写时拷贝就是一种拖延症,是在浅拷贝的基础之上增加了引用计数的方式来实现的,既然是引用计数,必然有一个变量类是某些类所共有的。当第一个类构造时,string的构造函数会根据传入的参数从堆上分配内存,当有其它类需要这块内存时,这个计数为自动累加,当有类析构时,这个计数会减一,直到最后一个类析构时,此时的引用计数变为1或0,这时对对象的空间进行释放。

关于这个引用计数怎么设计,我在这里介绍两种设计思路:

1:在类内部设置一个指针指向一片开辟的内存空间。

2:在string成员变量_str指向的堆内存空间中多开辟一个整形的空间进行计数(这里博主采用第二种设计思路)。

当我们知道引用计数的设计思路后,就要考虑什么时候应该进行写时拷贝

写时拷贝发生在对string对象进行修改操做时,比如insert,push_back,append,erease等成员函数+=,[],=赋值操作,以及析构操作时发生写时拷贝。

对于写时拷贝为主要实现了以下三个私有成员函数,方便发生写时拷贝时进行调用。

cpp 复制代码
//获得引用计数
		int& GetRefCount()
		{
			return *((int*)(_str - 4));
		}
cpp 复制代码
//写时拷贝
		void Sub(size_t n)
		{
			char* tmp = new char[n + 5];
			tmp += 4;
			size_t len = _size;
			strcpy(tmp, _str);
			Release();

			_str = tmp;
			GetRefCount() = 1;
			_capacity = n;
			_size=len;
		}

申请新空间,释放旧空间,在交换前前对引用计数--,交换后将新空间的引用计数置为1.

cpp 复制代码
//检查是否需要对空间进行释放
		void Release()
		{
			if (--GetRefCount() == 0)
			{
				delete[](_str - 4);
			}
		}

写时拷贝完整代码

cpp 复制代码
#pragma once
#include<Cassert>
#include<iostream>
namespace zyc
{
	class string
	{
		typedef char* iterator;
		typedef const char* const_iterator;
	public:
		string(const char* str = "")
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 5];
			_str += 4;
			GetRefCount()=1;
			strcpy(_str, str);
		}

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

		string(const string& str)
			:_str(str._str)
			,_size(str._size)
			,_capacity(str._capacity)
		{	
			++GetRefCount();
		}
		
		string& operator=(const string& s)
		{
			_str = s._str;
			_size = s._size;
			_capacity = s._capacity;
			++GetRefCount();
			return *this;
		}
		~string()
		{
			Release();
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				Sub(n);
			}
		}
		void resize(size_t n, char ch = '\0')
		{
			if (n > _size)
			{
				reserve(n);
				for (int i = _size; _size < n; i++)
				{
					_str[i] = ch;
				}
			}
			_str[n] = '\0';
			_size = n;
		}
		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);

			Sub(_capacity);
			// 满了就扩容
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			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* str)
		{
			assert(pos <= _size);
			Sub(_capacity);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}

			// 挪动数据
			size_t end = _size + len;
			while (end >= pos + len)
			{
				_str[end] = _str[end - len];
				--end;
			}

			strncpy(_str + pos, str, len);
			_size += len;

			return *this;
		}
		void append(const char* str)
		{
			insert(_size, str);
		}
		void push_back(char ch)
		{
			insert(_size, ch);
		}
		void erase(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			Sub(_capacity);
			if (len == npos || pos + len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
		}
	
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

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

		string substr(size_t pos, size_t len = npos) const
		{
			assert(pos < _size);
			size_t end = pos + len;
			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;
		}

		const char* c_str() const
		{
			return _str;
		}
		size_t size() const
		{
			return _size;
		}
		size_t capacity() const
		{
			return _capacity;
		}
		size_t find(const char ch, size_t pos = 0)
		{
			assert(pos < _size);
			while (pos < _size)
			{
				if (_str[pos] == ch)
				{
					return pos;
				}
				++pos;
			}
			return npos;
		}
		size_t find(const char* str, size_t pos = 0)
		{
			const char* ptr = strstr(_str + pos, str);
			if (ptr == nullptr)
			{
				return npos;
			}
			else
			{
				return ptr - _str;
			}
		}

		const char& operator[](size_t pos) const
		{
			assert(pos < _size);
			return _str[pos];
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			Sub(_size);
			return _str[pos];
		}
		void clear()
		{
			Sub(_capacity);
			_str[0] = '\0';
			_size = 0;
		}
		int count()
		{
			return GetRefCount();
		}
	private:
		void Release()
		{
			if (--GetRefCount() == 0)
			{
				delete[](_str - 4);
			}
		}
		int& GetRefCount()
		{
			return *((int*)(_str - 4));
		}
		void Sub(size_t n)
		{
			char* tmp = new char[n + 5];
			tmp += 4;
			size_t len = _size;
			strcpy(tmp, _str);
			Release();

			_str = tmp;
			GetRefCount() = 1;
			_capacity = n;
			_size = len;
		}
		char* _str;//字符串
		size_t _capacity;//容量
		size_t _size;//有效字符个数
		static const size_t npos = -1; //vs下int类型支持给static和const同时修饰的变量用缺省值
	};
	std::ostream& operator<<(std::ostream& out, const string& s)
	{
		for (size_t i = 0; i < s.size(); ++i)
		{
			out << s[i];
		}
		return out;
	}

	std::istream& operator>>(std::istream& in, string& s)
	{
		s.clear();
		char buff[128] = { '\0' };
		size_t i = 0;
		char ch = in.get();
		while (ch != ' ' && ch != '\n')
		{
			if (i == 127)
			{
				s += buff;
				i = 0;
			}
			buff[i++] = ch;
			ch = in.get();
		}
		if (i >= 0)
		{
			buff[i] = '\0';
			s += buff;
		}
		return in;
	}

}

注意:我们实现的写时拷贝存并不成熟,像以下修改策略,发生修改操作时,这种操作根本就不会被我们所发现。

cpp 复制代码
string str1 = "hello";
	char& ref = str1[0];
	string str2 = str1;
	ref = 'y';

并且库的string也存在着缺陷,详情我在这里推荐一篇文章,推荐大家阅读
C++的STD::STRING的"读时也拷贝"技术!


本章到此结束,感谢您的阅读!

相关推荐
paopaokaka_luck2 小时前
【360】基于springboot的志愿服务管理系统
java·spring boot·后端·spring·毕业设计
捕鲸叉4 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer4 小时前
【C++】vector 类深度解析:探索动态数组的奥秘
开发语言·c++·算法
码农小旋风4 小时前
详解K8S--声明式API
后端
Peter_chq4 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
Yaml44 小时前
Spring Boot 与 Vue 共筑二手书籍交易卓越平台
java·spring boot·后端·mysql·spring·vue·二手书籍
小小小妮子~4 小时前
Spring Boot详解:从入门到精通
java·spring boot·后端
hong1616884 小时前
Spring Boot中实现多数据源连接和切换的方案
java·spring boot·后端
青花瓷5 小时前
C++__XCode工程中Debug版本库向Release版本库的切换
c++·xcode
睡觉谁叫~~~5 小时前
一文解秘Rust如何与Java互操作
java·开发语言·后端·rust