c++ 库中string的简单实现

string

构造函数string()

这里直接开一个新空间 把传过来的字符内容赋值到 _str上
用const 不管是const和非const 都可以通用
初始化的时候要放\0到 字符里面
如果不放\0那么 穿空串会报错

	string(const char* str = "")
	{
		_size = strlen(str);
		_str = new char[_size + 1];
		_capacity = _size;
		strcpy(_str, str);
	}

拷贝构造string()

把传过来的 对象 用新空间来接受 把 新空间赋给 _str
开空间是为了让 _str有足够的空间来接受

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

长度size()

因为查看长度是不会改变的，所以用const来定义

size_t size() const
{
	return _size;
}

下标引用[]`//返回这个字符串

const char* c_str() const
{
return _str;
}`

用引用传值，来减少时间
下标引用需要重载2个版本，一个是const的版本，一个是非const的
const的是给一些不需要改变的成员函数和用const定义的对象使用
非const 是给一些需要改变下标内的成员函数和普通对象使用

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

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

类型间的转化c_str

类型间的转化

const char* c_str() const
{
	return _str;
}

迭代器iterator、begin、end

在string中 迭代器iterator其实就是指针
iterator需要重载 const和非const的版本
begin: 指向 对象的开始位置
end: 指向 对象的末尾位置
同样begin和end也需要重载2个版本
重载2个版本是因为有静态变量

//string 迭代器
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;
}

print打印

void print_str(const string& str)
{
	for (size_t i = 0; i < _size; i++)
	{
		cout<<str[i]<<" ";
	}
	cout << endl;
}

扩容reserve

如果需要扩容的对象原本可存长度小于需要的长度那么直接扩容
如果是想缩容的话 我们不理会

void reserve(size_t n = 0)
{
	//如果n>_capacity 那么开辟一块新空间 把 str里面的值拷贝给tmp 
	// 把旧空间释放
	// 把tmp 赋给 _str
	if (n > _capacity)
	{
		char* tmp = new char[n+1];
		strcpy(tmp, _str);
		delete[] _str;
		_str = tmp;
		_capacity = n;
	}

}

push_bacak尾插

把一个字符直接尾插到对象里面
同样如果位置不够也是需要扩容的

	void push_back(char str)
{
	assert(str);
	if (_size == _capacity)
	{
		size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newCapacity);
	}
	_str[_size++] = str;
	_str[_size] = '\0';
}

append尾插入一个字符串

把一个字符串插入到对象里面
如果位置不够也需要扩容

void append(const char* str)
{
	assert(str);
	size_t pos = strlen(str);
	//如果 插入后越界就会出问题
	if (_size + pos >= _capacity)
	{
		reserve(_size+pos);
	}
	strcpy(_str + _size, str);
	_size += pos;
}

+=尾部插入

+=是可以插入一个字符和一个字符串
所以要重载2个版本

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

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

= 赋值

开辟一个新空间 让传过来的对象 赋值到 新空间上
把_str指向新空间
把旧的空间释放

string& operator=(const string& str)
{
	//如果拷贝的时候 str的内容长度大于 this的内如长度 
	//那么则需要 新开辟一个空间
	//让这个 空间让 str内容一样
	//释放原来的旧this 内容
	//把this指向那段新开辟的空间
	if (this != &str)
	{
		char* tmp = new char[str._capacity + 1];
		strcpy(tmp, str._str);
		delete[] _str;
		_size = str._size;
		_capacity = str._capacity;
		_str = tmp;
	}
	return *this;
}

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

因为是需要插入一个字符或者字符串
那么肯定是需要重载2个版本的
还要判断扩容，以及是否插入之后会越界

void insert(size_t pos, char ch)
{
	assert(pos < _size);
	if (_size == _capacity)
	{
		size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newCapacity);
	}
	//这里要指向 size+1 不然的话 有可能pos ==1 end会变成 -1
	size_t end = _size + 1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		end--;
	}
	_str[pos] = ch;
	_size++;
}
//在pos位置插入一个字符串
void insert(size_t pos, const char * s)
{
	assert(pos < _size);
	size_t sz = strlen(s);
	if (_size + sz > _capacity)
	{
		reserve(_size + sz);
	}
	size_t end = _size;
	//把 数组中末尾位置的数据挪动到end+sz位置处
	//给s数组 预留sz个位置
	while (end >= (int)pos)
	{
		_str[end+sz] = _str[end];
		end--;
	}
	strncpy(_str + pos, s,sz);
	_size += sz;
}

erase从pos位置开始删除len个字符

如果从pos+len >原对象的长度的话那么 直接 插入一个\0到pos位置就可以了
如果不大于 那么就需要把 _str+pos+len位置的给到 _str+pos位置

void erase(size_t pos, size_t len = npos)
{
	assert(pos <= _size);
	//如果大于或 等于 _size - pos 的长度 那么 直接插入一个'\0' 因为他不管怎么样 都是删完
	if (len==npos||npos >= _size - pos)
	{
		_str[pos] = '\0';
	}
	else
	{
		//这里拷贝的时候会从pos位置开始 拷贝 pos+len位置的值到的结束
		strcpy(_str + pos, _str + pos+len);
		_size -= len;
	}
}

swap 交换类

直接调用库里面的模版

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

find 找一个字符在一个对象里面的下标

size_t find(char ch, size_t pos = 0)
{
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] == ch)
		{
			return i;
		}
	}
} 

finde找子串

找到子串返回 子串在 _str 的起始坐标

size_t find(const char * str,size_t pos = 0)
{
	//如果找到子串赋给tmp
	const char * tmp = strstr(_str+pos, str);
	if (tmp == nullptr)
	{
		return npos;
	}
	//如果找到了 返回下标
	//指针-指针=他们之间的差值
	else
	{
		return tmp - _str;
	}
}

substr从pos位置开始 返回len长度的的字符串

需要开新空间接受这段字符串
返回值的时候如果没有写拷贝构造那么他会报错
原因是因为他指向的那块空间和函数里的新开辟一样
如果出了函数那么 创造的那个新空间会调用析构函数
那么会出现指向野指针的情况

string substr(size_t pos = 0, size_t len = npos)
{
	assert(pos < _size);
	size_t end = pos + len;
	if (len == npos||end>=_size)
	{
		end = _size;
	}
	string str;
	//开空间 让str可以存储
	str.reserve(end - pos);
	for (size_t i = 0; i < end; i++)
	{
		str += _str[i];
	}

	//这里要调拷贝构造才能正常返回
	//如果这么没写拷贝构造
	//那么会默认浅拷贝(值拷贝)
	//浅拷贝:让 临时拷贝的对象指向跟str一样的空间
	//但是出了函数 str会 析构
	//会把临时对象指向的空间变成 野指针
	return str;
}

~stirng()析构函数

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

>>流提取

流插入(>>)的时候需要定义一个新的数组和一个字符
用字符存到数组里面
把数组尾插到串过来的对象里面
最后在 数组的尾部在插入一个\0来终止字符
如果直接插入的话会出现报错
这个报错就是出了这个函数这个 传过来的会调用析构

	istream& operator>> (istream& in, string& str)
	{
		char ch = in.get();
		char arr[128];
		int a = 0;
		while (ch!=' '&&ch!='\n')
		{
			arr[a++] = ch; 
			if (a == 127)
			{
				arr[a] = '\0';
				str += arr;
				a = 0;
			}
			ch = in.get();	
		}
		if (a != 0)
		{
			arr[a] = '\0';
			str += arr;
		}
		return in;
	}

流插入<<

直接用for来打印

ostream& operator<< (ostream& os, const string& str)
{
	for (size_t i = 0; i < str.size(); i++)
	{
		os << str[i];
	}
	return os;
}