string的模拟实现

#pragma once
#include<iostream>
#include<cstring>
using namespace std;
#include<assert.h>
//不用用free释放一段堆空间两次。因为可能释放完第一次后，操作系统把这块内存分配出去了，立即有释放会导致问题
//创建一个类，编译器会默认生成六个函数
//对空指针的解引用会照成异常。
namespace leb {
#define CAPACITY 5
	class string {
		//传统写法。  还有增删查改
	public:
		//string()   //默认构造
		//	:m_str(new char[1])
		//{
		//	*m_str = '\0';
		//}
		typedef  char * iterator;
		typedef  const char *  const_iterator;

		iterator begin() {
			return m_str;
		}
		const_iterator begin()  const {
			return  m_str;
		}
		iterator end() {
			return m_str + m_size;
		}
		const_iterator end() const {
			return m_str + m_size;
		}

		string(const char * str = "") :m_str(new char[strlen(str) + 1]) {
			//先在堆上开辟空间
			strcpy(m_str, str);   //将数据拷贝到m_str
			m_size = strlen(str);
			m_capacity = m_size + 1;   //实际开辟的大小
		}
		// 深拷贝。  浅拷贝会造成重复释放，有问题。
		string(const string & s) :m_str(new char[s.m_capacity]),
			m_size(s.m_size),
			m_capacity(s.m_capacity)
		{
			strcpy(m_str, s.m_str);
			//不用+1;

		}


		string& operator=(const string & s) {
			if (this != &s) {
				delete[] m_str;
				m_str = new char[s.m_capacity];
				strcpy(m_str, s.m_str);
				m_size = s.m_size;
				m_capacity = s.m_capacity;
			}
			return *this;

		}

		size_t size() {
			return m_size;
		}
		size_t capacity() {
			return m_capacity;
		}

		//返回 C风格字符串。
		const char * c_str() const {
			return m_str;
		}
		//重载[] 运算符。 
		char & operator[](size_t pos) {
			assert(pos < m_size);

			return m_str[pos];
		}
		~string() {
			if (m_str) {
				delete[] m_str;
				m_str = nullptr;
				m_size = m_capacity = 0;
			}

		}

		void resize(size_t size) {
			while (m_size != size) {
				push_back('\0');
			}
		}

		void reserve(size_t n) {

			char * tmp = new char[n];
			strcpy(tmp, m_str);
			delete[] m_str;
			m_str = tmp;
			m_capacity = n;
		}

		void push_back(char ch) {
			if (m_size == m_capacity - 1) {  //去掉最后一个字符
				  //扩容
				reserve((m_capacity) * 2);
			}

			m_str[m_size] = ch;
			m_size++;
			m_str[m_size] = '\0';

		}
		bool empty() {
			if (m_size == 0) {
				return true;
			}
			else {
				return false;
			}
		}
		void pop_back() {
			if (!empty()) {
				m_size--;
			}

		}
		//s1.append（"11111");

		void append(const char * str) {
			size_t len = strlen(str);
			if (m_size + len == m_capacity - 1) {
				//扩容
				reserve(m_capacity * 2);
			}
			for (int i = 0; i < len; i++) {
				this->push_back(str[i]);

			}


		}

		const string &	operator+=(char ch) {
			this->push_back(ch);
			return *this;
		}
		string &operator+=(const char * str) {
			append(str);
			return *this;
		}
		//实现find (char ch ,int pos) ;
		size_t find(char ch, int pos = 0) {
			if (pos < 0 || pos >= m_size) {
				return -1;
			}
			//找不为空。
			char*tmp = strchr(m_str + pos, ch);
			if (tmp) {
				return tmp - m_str;
			}
			return -1;
		}
		size_t find(const char * str, int pos = 0) {
			if (pos < 0 || pos >= m_size) {
				return -1;
			}
			const char * tmp = strstr(str + pos, str);
			if (tmp) {
				return tmp - m_str;
			}
			return -1;
		}
		size_t find(const string&s, int pos = 0) {
			if (pos < 0 || pos >= m_size) {
				return -1;
			}
			char * tmp = strstr(m_str + pos, s.c_str());
			if (tmp) {
				return tmp - m_str;
			}
			return -1;
		}
		string substr(size_t pos, size_t num) {
			string tmp;
			tmp.resize(num);
			strncpy(tmp.m_str, m_str + pos, num);
			return tmp;

		}
		bool operator>(const string& s)const {
			int i;
			int minsize = m_size < s.m_size ? m_size : s.m_size;
			for (int i = 0; i < minsize; i++) {
				if (m_str[i] > s.m_str[i])
				{
					return true;
				}
				else if (m_str[i] < s.m_str[i]) {
					return false;
				}
			}
			return  m_size > s.m_size;
		}
		/*bool operator == (const char *str)const {
		
		}*/


		bool operator == (const char * str) const
		{

			int tmp = strncmp(m_str, str, m_size);
			if (!tmp &&  strlen(str) == m_size)
			{
				return true;
			}

			return false;
		}
		friend ostream & operator<<(ostream & s, const string & ss);
		friend istream & operator>>(istream & s,  string & ss);
	private:
		char * m_str;
		size_t m_size;  //大小
		size_t m_capacity;  //容量、
	};
	ostream & operator<<(ostream & s, const string & ss)
	{
		s << ss.m_str << endl;
		return s;
	}
	istream & operator>>(istream & s,  string & ss) {
		char * tmp = new char[1024];
		s.getline(tmp,1024);
		ss.m_size = strlen(tmp); // m_size  大小。
		ss.m_capacity = 1024;
		delete[] ss.m_str;
		ss.m_str = tmp;
		
		return s;

	}

}