C++—string

一、string类的常用接口说明
二、string类的模拟实现
之间再简单介绍一下深、浅拷贝 以及 写时拷贝

string类的常用接口

string常见构造

string() 构造空的string对象
string(const char* s) 用C-string来改造string类对象
string(size_t n, char c) string类对象中包含n个字符c
string(const string& s) 拷贝构造函数
string(const string& s, size_t n) 用对象s的前n个字符构造新的string类对象

string类对象的容量操作

size_t size() const 返回字符串的有效长度
size_t length() cosnt 返回字符串的有效长度（与size（）实现方法一样）
size_t capacity() const 返回空间总大小
bool empty() const 判断字符串是否为空，是返回true
void clear() 清空字符串的有效字符
void resize(size_t,char c) 将有效字符个数改为n，多处的空间用字符c填充
void resize(size_t n) 将有效字符个数改为，多出的字符用0填充
void reserve(size_res_arg = 0) 为字符串预留空间

string底层使用char*实现的，所以依旧有可以直接访问的接口

char& operator[](size_t pos)、const char& operator[]（size_t pos) const

string类对象的修改操作

void push_back(char c) 尾插字符c
string& append(const char* s) 在字符串后加一个字符串
string& operator+=(const string& str) 在字符串后缀加一个字符串
string& operator(const char* s)
string& operator(char c)
const char* c_str() const 返回一个c格式的字符串
size_t find(char c, size_t pos = npos) 从字符串的pos位置开始往后查找字符c，返回该字符在字符 串中的位置
size_t rfind(char c,size_t pos = npos) 往前查找…
string substr(size_t pos = 0, size_t n = npos) const 从str中从pos位置开始，截取n个字符，然后将其返回

模拟实现string

#include <iostream>
#include <assert.h>
#include <string>
#include <stdio.h>
using namespace std;
class String
{
public:
	typedef char* iterator;
	typedef const char* const_iterator;
	//构造
	String(const char* str = "")
	{
		assert(str != nullptr);
		//strlen 不包括'\0'
		_size = strlen(str);
		//新建一个字符数组
		_str = new char[_size + 1];
		strcpy(_str, str);
		_capacity = _size;
	}
	void Swap(String& s)
	{
		swap(_str, s._str);
		swap(_size, s._size);
		swap(_capacity, s._capacity);
	}
	String(const String& s)
	{
		String tmp(s._str);
		Swap(tmp);
	}
	char& operator[](size_t pos)
	{
		assert(pos < _size);
		return _str[pos];
	}
	const char& operator[](size_t pos) const
	{
		assert(pos < _size);
		return _str[pos];
	}
	int Size() const
	{
		return _size;
	}
	int Capacity() const
	{
		return _capacity;
	}
	~String()
	{
		if (_str)
		{
			delete(_str);
			_str = nullptr;
			_size = 0;
			_capacity = 0;
		}
	}
	const_iterator begin() const
	{
		return _str;
	}
	const_iterator end() const
	{
		return _str + _size;
	}
	const char* c_str() const
	{
		return _str;
	}
	void Reserve(size_t n)
	{
		if (n > _capacity)
		{
			char* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete _str;
			_str = tmp;
			_capacity = n;
		}
	}
	void PushBack(char c)
	{
		if (_size == _capacity)
		{
			size_t newc = (_capacity == 0 ? 15 : 2 * _capacity);
			Reserve(newc);
		}
		_str[_size] = c;
		_size++;
		_str[_size] = '\0';
	}
	void PopBack()
	{
		if (_size > 0)
		{
			_str[--_size] = '\0';
		}
	}
	void Resize(size_t n, char c = '\0')
	{
		if (n > _capacity)
		{
			Reserve(n);
		}
		if (n > _size)
		{
			memset(_str + _size, c, n - _size);
		}
		_size = n;
		_str[_size] = '\0';

	}
	void Erase(size_t pos, size_t len)
	{
		assert(pos < _size);
		if (pos + len >= _size)
		{
			_size = pos;
			_str[_size] = '\0';
		}
		else
		{
			for (int i = pos + len; i <= _size; i++)
			{
				_str[pos++] = _str[i];
			}
			_size -= len;
		}
	}
	void Append(const char* str)
	{
		size_t sz = strlen(str);
		if (_size + sz > _capacity)
		{
			Reserve(_size + sz);
		}
		strcpy(_str + _size, str);
		_size += sz;
	}
	void Insert(size_t pos, char c)
	{
		assert(pos <= _size);
		if (_size == _capacity)
		{
			size_t newc = (_capacity == 0 ? 15 : _capacity * 2);
			Reserve(newc);
		}
		size_t end = _size;
		while (end > pos)
		{
			_str[end] = _str[end - 1];
			--end;
		}
		_str[pos] = c;
		++_size;
		_str[_size] = '\0';
	}
	void 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;
		//第一个挪动的是'\0';
		while (end > pos + len - 1)
		{
			_str[end] = _str[end - len];
			--end;
		}
		//插入新的字符串str,不能用strcpy(),
		//会把str中的'\0'一起拷贝过去，导致有效内容被覆盖
		strncpy(_str + pos, str, strlen(str));
		_size += len;
	}
	size_t Find(char c)
	{
		for (int i = 0; i < _size; i++)
		{
			if (_str[i] == c)
			{
				return i;
			}
		}
		return -1;
	}
	size_t Find(size_t pos, const char* str)
	{
		char* posPtr = strstr(_str + pos, str);
		if (posPtr)
		{
			return posPtr - _str;
		}
		else
			return -1;
	}
	String& operator+=(char c)
	{
		PushBack(c);
		return *this;
	}
	String& operator+=(const char* str)
	{
		Append(str);
		return *this;
	}
	String& operator+=(const String& s)
	{
		*this += s._str;
		return *this;
	}

private:
	friend ostream& operator<<(ostream& _cout, const String& s);
	char* _str;
	size_t _capacity;
	size_t _size;
};

在实现string过程中，遇到了拷贝的问题，所以在这总结一下深拷贝和浅拷贝

浅拷贝：也成为位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，但一个对象销毁时就会将该资源释放掉，全部拷贝过的对象的资源都将失效，所以C++引入了深拷贝
深拷贝：就是给每一个对象独立分配资源，保证多个对象之间不会因共享资源二造成多次释放 造成程序崩溃的问题

而写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给
计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该
对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。