C++中string类的剖析与实现

什么是string类.

在C++中,string类是一个C++标准模板库中的一个容器,主要用来管理字符串和进行一些相关的操
作.该类的接口与一半容器接口基本相同,还有一些专门操作字符类型的接口,它的底层是用char类
型实例化了basic_string模板类,不能操作多字符或变长字符序列.

string类的构造

string() ;			
string类的无参构造函数,生成一个空的string类对象.
string(const char* s);		 
用C-string构造一个string类对象.
string(size_t n,char c);
用n个字符c构建一个string类对象.
string(const string& s);
用string类调用拷贝构造创建一个string类对象.
string（const string＆str，size_t pos，size_t len = npos）;
复制从字符位置pos开始并跨越len个字符的str部分（如果str太短或len是string :: npos，
则复制到str的结尾）构成string类对象.
string（const char * s，size_t n）;
从s指向的字符数组中复制前n个字符构成string类对象.

string类的常用接口

size();
返回string类所存储的字符个数.
capacity();
返回当前string类的容量.
resize（size_t n，char c）;
将字符串的大小调整为n个字符的长度。 如果n小于当前字符串长度，则将当前值缩短到其前n个字
符，并删除第n个字符之外的字符。 如果n大于当前字符串长度，则通过在结尾处插入任意数量的
字符来扩展当前内容，以达到n的大小。如果指定了c，则新元素被初始化为c的副本，否则，用空
字符代替.
empty();
检查当前对象是否为空,空返回true,否则返回false.
clear();
清空当前string对象中的有效字符.
reserve(size_t n);
该函数使容器将其容量增加到n个字符.
operator[](size_t pos);
返回string中第pos个字符的引用,如果字符串对象是const限定的，则该函数返回const char
＆。否则，它返回一个char＆.
begin() && end();
返回一个迭代器,分别指向第一个有效字符和最后一个有效字符的下一位.
rbegin() && rend();
返回一个反向迭代器.分别指向末尾和开始.
push_back(char c);
尾插字符c.
append (const string& str);
尾插一个string.
append (size_t n, char c);
尾插n个字符c.
operator+= (const string& str);
尾插一个string.
operator+= (const char* s);
尾插C-string.
operator+= (char c);
尾插一个字符c.
c_str() const;
返回一个C-string.
substr (size_t pos = 0, size_t len = npos) const;
返回一个新构造的 串对象，其值初始化为该对象的子字符串的副本。子字符串是对象的一部分，
从字符位置pos开始并跨越len个字符

string类的模拟实现

class String {

	char* _str;
	size_t _size;
	size_t _capacity;
public:
	typedef char* iterator;
	typedef const char* const_iterator;
	iterator begin()
	{
		return _str;
	}

	iterator end()
	{
		return _str + _size;
	}

	const_iterator begin() const
	{
		return _str;
	}

	const_iterator end() const
	{
		return _str + _size;
	}
	static const size_t npos;
	String()
		:_size(0)
		,_capacity(15)
	{
		_str = new char[15 + 1];
		_str[_size] = '\0';
	}
	String(const char* str)
		:_size(strlen(str))
		,_capacity(strlen(str))
	{
		_str = new char[_size + 1];
		strcpy(_str, str);
	}
	void Swap(String& str) {
		swap(str._capacity, _capacity);
		swap(str._size, _size);
		swap(str._str, _str);
	}
	String(const String& str)
		:_str(nullptr)
		,_size(0)
		,_capacity(0)
	{
		String tmp(str._str);
		Swap(tmp);
	}
	String& operator=(String str) {
		Swap(str);
		return *this;
	}
	const char* c_str() const {
		return _str;
	}
	~String() {
		if (_str) {
			delete _str;
			_str = nullptr;
			_size = 0;
			_capacity = 0;
		}

	}
	void pushBack(const char& ch) {
		if (_size == _capacity) {
			size_t newC = _capacity == 0 ? 15 : 2 * _capacity;
			reserve(newC);
		}
		_str[_size] = ch;
		_size++;
		_str[_size] = '\0';
	}

	void reserve(size_t n) {
		if (n > _capacity) {
			char* tmp = new char[n];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = n;
		}
	}
	char& operator[](size_t n) {
		if (n < _size) {
			return _str[n];
		}
	}
	const char& operator[](size_t n) const {
		if (n < _size) {
			return _str[n];
		}
	}
	size_t size() const {
		return _size;
	}
	void Append(const char* str) {
		int len = strlen(str);
		if (_capacity < len + _size) {
			reserve(len + _size);

		}
		strcpy(_str + _size, str);
		_size += len;
	}
	String& operator+=(const char& ch) {
		pushBack(ch);
		return *this;
	}
	String& operator+=(const char* str) {
		Append(str);
		return *this;
	}
	void insert(size_t pos, const char& ch) {
		if (pos > _size)
			return;
		if (_capacity == _size) {
			size_t newC = _capacity == 0 ? 15 : 2 * _capacity;
			reserve(newC);
		}
		size_t end = _size + 1;
		while (end > pos) {
			_str[end] = _str[end - 1];
			end--;
		}
		_str[pos] = ch;
		_size++;
	}
	void insert(size_t pos, const char* str) {
		if (pos > _size)
			return;
		int len = strlen(str);
		if (_capacity < _size + len) {
			reserve(_size + len);
		}
		size_t end = _size + len;
		while (end < pos + len) {
			_str[end] = _str[end - len];
			end--;
		}
		for (int i = 0; i < len; i++) {
			_str[pos + i] = str[i];
		}
		_size += len;
	}
	void resize(size_t n,const char& ch = '\0') {
		if (n > _capacity) {
			reserve(n);
		}
		if (n > _size) {
			memset(_str + _size, ch, n - _size);
		}
		_size = n;
		_str[_size] = '\0';
	}
	void popBack() {
		erase(_size - 1, 1);
	}
	void erase(size_t pos, size_t n) {
		if (pos < _size) {
			if (pos + n >= _size) {
				_size = pos;
				_str[_size] = '\0';
			}
			else {
				for (int i = pos + n; i <= _size; i++) {
					_str[pos++] = _str[i];
				}
			}
			_size -= n;
		}
	}
	size_t find(const char* str) {
		char* ptr = strstr(_str, str);
		if (str)
			return ptr - _str;
		else
			return npos;
	}
};
const size_t String::npos = -1;
String operator+(const String& s, const String& str)
{
	String ret(s);
	ret += str.c_str();
	return ret;
}
String operator+(const String& s, const char* str)
{
	String ret(s);
	ret += str;
	return ret;
}
String operator+(const String& s, const char& ch)
{
	String ret(s);
	ret += ch;
	return ret;
}
ostream& operator<<(ostream& cout, const String& str)
{

	for (const auto& ch : str)
		cout << ch;


	return cout;
}