string类的实现（C++）

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <assert.h>
using namespace std;
class String{
public:
	typedef char* iterator;
	typedef const char* const_iterator;
    //string的构造函数
	String(const char* str = "")
		:_size(strlen(str))
	    ,_capacity(_size)
	    ,_str(new char[_capacity + 1])
	{
		strcpy(_str, str);
	}
    //string的拷贝构造函数
	//申请空间，拷贝内容
	String(const String& s)
		:_str(new char[s._capacity+1])
		, _size(s._size)
		, _capacity(s._capacity)
	{
		strcpy(_str, s._str);
	}
	//赋值
	//现代写法：代码复用，简洁
	//自己不申请空间,不拷贝内容
	//通过调用拷贝构造函数（申请空间，拷贝内容）生成一个新的临时对象
	//直接获取临时对象的全部内容（通过交换指针），完成当前对象的拷贝构造
	//不需要检查是否自己给自己赋值，因为在赋值之前无空间的赋值操作
	String& operator=(String s){
		swap(_str, s._str);
		return *this;
	}
	//String& operator=(const String& s){
	//	//防止自己给自己赋值
	//	if (this != &s){
	//		char* pstr = new char[s._capacity + 1];
	//		strcpy(pstr, _str);
	//		delete[] _str;
	//		_str = pstr;
	//		_size = s._size;
	//		_capacity = s._capacity;
	//	}
	//	return *this;
	//}
    //string的析构函数
	~String(){
		if (_str){
			delete[] _str;
			_str = nullptr;
		}
	}
	//迭代器
	//实现类似于指针的解引操作
	//实现类似于指针的位置移动操作，++，--
	//具有==，！=的操作逻辑，但不能比较大小
	//begin()返回的迭代器表示的第一个元素的位置
	//end()返回的迭代器表示最后一个元素的下一个位置；
	iterator begin(){
		return _str;
	}
	iterator end(){
		return _str + _size;
	}
	 const_iterator begin() const{
		return _str;
	}
	 const_iterator end() const{
		return _str + _size;
	}
	 //后面插入字符
	 //检查是否空间已满
	 //如果空间已满，增容，如果空间为0，赋值15，否则增加两倍
	 //给_size的位置插入新元素c
	 //更新_size：++_size
	 //更新'\0'的位置，_str[_size] = '\0'
	void PushBack(char c){
		if (_size == _capacity){
			Reserve(_capacity == 0 ? 15 : (2 * _capacity));
		}
		_str[_size++] = c;
		_str[_size] = '\0';
	}
	//返回元素个数
	size_t Size()const{
		return _size;
	}
	//返回容量
	size_t Capacity()const{
		return _capacity;
	}
	//如果空间不够用则扩容
	//只增容，不减少容量
	//拷贝原有的空间到新的空间
	//释放原有空间
	//指向新空间
	//更新容量值
	void Reserve(size_t NewCapacity){
		//如果新容量大于旧容量，则开辟空间
		if (NewCapacity > _capacity){
			char* str = new char[NewCapacity + 1];
			strcpy(str ,_str);
			delete[] _str;
			_str = str;
			_capacity = NewCapacity;
		}
	}
	//打印
	void Print(){
		for (auto e : *this){
			cout <<e ;
		}
		cout << endl;
	}
	//
	char& operator[](size_t _index){
		assert(_index < _size);
		return _str[_index];
	}
	const char& operator[](size_t _index)const{
		assert(_index < _size);
		return _str[_index];
	}
	//在末尾插入字符串
	//检查空间是否足够，strlen（str） + _size > capacity;
	//如果空间不足，即strlen（str）>capacity,增容
	//在尾部插入字符串，可调用strcpy；
	//更新size
	void Append(const char* str){
		if (strlen(str) + _size > _capacity){
			Reserve(strlen(str) + _size);
		}
		strcpy(_str + _size, str);
		_size += strlen(str);
	}
	//在pos的前面插入字符串
	void Insert(size_t pos, const char* str){
		assert(pos <= _size);
		size_t len = strlen(str);
		size_t end = len + _size;
		if (end > _capacity){
			Reserve(end);
		}

		while (end > pos+len-1){
			_str[end] = _str[end - len];
			end--;
		}
		strncpy(_str+pos, str, strlen(str));
		_size += len;
		/*assert(pos <= _size);
		int len = strlen(str);
		if (_size + len > _capacity){
			Reserve(_size + len);
		}
		int end = _size;
		while (end + len >= pos + len){
			_str[end + len] = _str[end];
			end--;
		}
		for (int i = 0; i < len; i++){
			_str[pos] = str[i];
			pos++;
		}
		_size += len;*/

	}
	//删除pos后面len个字符
	void Erase(size_t pos, size_t len){
		assert(pos < _size);
		//大于_size,后面全部删除，pos处置为'\0’
		if (pos + len > _size){
			_size = pos;
			_str[pos] = '\0';
		}
		else{
			size_t _start = pos + len;
			while (_start < _size){
				_str[pos++] = _str[_start++];
			}
			_size -= len;
			_str[_start] = '\0';
		}
	}
	//加一个字符
	String& operator+=(char c) {
		PushBack(c);  
		return *this; 
	}
	//加一个字符串
	String& operator+=(const char* str){
		int len = strlen(str);
		if (_size + len > _capacity){
			Reserve(_size + len);
		}
		strncpy(_str + _size, str, len);
		_str[_size+len] = '\0';
		_size += len;
		return *this;
	}
	//计算字符串的长度
	int Length(const String& s){
		int count = 0;
		while (s._str[count++]){
		}
		return count;
	}
	//<
	bool operator<(const String& s){
		int i = 0;
		for (auto e : *this){
			if (e<s._str[i]){
				/*cout << true<<endl;*/
				return true;
			}
			++i;
		}
		/*cout << false << endl;*/
		return false;
	}
	//<=
	bool operator<=(const String& s){
			if (!operator>(s)){
				/*cout << true << endl;*/
				return true;
			}
			/*cout << false << endl;*/
			return false;
	}
	//>
	bool operator>(const String& s) {
		int i = 0;
		for (auto e : *this){
			if (e>s._str[i]){
				/*cout << true << endl;*/
				return true;
			}
			++i;
		}
		/*cout << false << endl;*/
		return false;
	}
	//>=
	bool operator>=(const String& s){
		if (!operator<(s)){
			/*cout << true << endl;*/
			return true;
		}
		/*cout << false << endl;*/
		return false;
	}
	//==
	bool operator==(const String& s){
		int len = Length(s);
		if (len-1 == _size){
			int i = 0;
			for (auto e : *this){
				if (e == s._str[i]){
					i++;
				}
			}
			/*cout << true << endl;*/
			return true;
		}
		/*cout << false << endl;*/
		return false;
	}
	//!=
	bool operator!=(const String& s){
		if (!operator==(s)){
			/*cout << true << endl;*/
			return true;
		}
		/*cout << false << endl;*/
		return false;
	}
	//如果n>size,需要给空间赋值为c；
	//如果n>capacity,需要扩容，给增的空间赋值为字符c；
	//size=n，_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[n] = '\0';
	}
private:
	size_t _size;
	size_t _capacity;
	char* _str;
};

int main()
{
	String s;
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('a');
	s.PushBack('b');
	s.PushBack('c');
	s.PushBack('d');
	s.PushBack('d');
	s.Append("asdfghjkldsfgfdds");
	s.Insert(1, "abcgj");
	s.operator+=("abc");
	s.operator<("bcd");
	s.operator<=("f");
	s.Print();
	s.Erase(5, 9);
	s.Resize(100, 'f');
	s.Print();

	system("pause");
	return 0;
}