C++学习笔记 lesson11 MyString类讲解

实现String类

#ifndef  _MYSTRING_H_
#define _MYSTRING_H_
#include<limits>
#include<cstring>

namespace PoEdu {


	class MyString
	{
	public:
		static const std::size_t npos = -1;
		MyString(const char* str = "") :max_size_(UINT_MAX)
		{
			str_ = Alloc(str);
		};
		MyString(const MyString& other) :max_size_(UINT_MAX)
		{
			str_ = Alloc(other.str_);
		}
		MyString(const char* str, unsigned int len) :max_size_(UINT_MAX)
		{
			int str_len = strlen(str);
			str_ = new char[len + sizeof(char)];
			memset(str_, 0, len + sizeof(char));
			length_ = len;
			for (unsigned int i = 0; i < str_len; ++i)
			{
				str_[i] = str[i];
				if (i == len)
					break;
			}
		}
		MyString(unsigned int len, const char c) :max_size_(UINT_MAX)
		{
			str_ = new char[len + sizeof(char)];
			memset(str_, 0, len + sizeof(char));
			length_ = len;
			for (unsigned int i = 0; i < len; ++i)
			{
				str_[i] = c;
			}

		}
		MyString(const MyString&other, std::size_t pos, std::size_t len = MyString::npos) :max_size_(UINT_MAX)
		{
			if (len == npos)
				length_ = other.length_ - pos;
			else
				length_ = len;
			str_ = new char[length_ + sizeof(char)];
			for (unsigned int i = pos; i < length_ + pos; ++i)
			{
				str_[i - pos] = other.str_[i];
			}
		}
		MyString(const char *first, const char *last) :max_size_(UINT_MAX)
		{
			length_ = (last - first);//区间长度
			//指针计算出来的是地址偏移的值
			str_ = new char[length_ + sizeof(char)];
			memset(str_, 0, length_ + sizeof(char));
			memcpy(str_, first, length_);
		}
		~MyString()
		{
			delete[] str_;
		};
		char* begin()const
		{
			return str_;
		}
		char *end()const
		{
			return &(str_[length_ + 1]);//最后一个元素+1的位置 '/0'之后，未维护的值
		}
		char* rbegin()const
		{
			return end();
		}
		char *rend()const
		{
			return begin();
		}

		MyString&operator =(const MyString &str) 
		{
			if (this != &str)//判断是否是自身
			{	//深拷贝
				delete[]str_;//是自身的话会被删除，引发错误
				str_ = Alloc(str.str_);
				return *this;
			}
		}
		MyString&operator =(const char *s)
		{
			delete[]str_;
			str_ = Alloc(s);
			return *this;
		}
		MyString&operator =(char c)
		{
			delete[]str_;
			length_ = 1;
			str_ = new char[length_ + sizeof(char)];
			memset(str_, 0, length_ + sizeof(char));
			str_[0] = c;
			return *this;
		}
		unsigned int size()const
		{
			return length_;
		}
		unsigned int length()const
		{
			return length_;
		}
		void resize(unsigned int len)
		{
			length_ = len;
			char *temp = new char[len + sizeof(char)];//扩容
			memset(temp, 0, len + sizeof(char));
			strcpy(temp, str_);
			delete[]str_;
			str_ = temp;
		}
		void resize(unsigned int len, char c)
		{
			unsigned int length = length_;
			resize(len);
			for (; length_ < len; ++length)
			{
				str_[length_] = c;
			}
		}
		bool empty()const
		{
			return !length_;
		}
		char &operator[](unsigned int index)
		{
			return const_cast<char&>(static_cast<const MyString&>(*this)[index]);
		}
 		 const char &operator[](unsigned int index) const
		{
			 return str_[index];
		}
		 char & at(unsigned int index)
		 {
			 return const_cast<char&>(static_cast<const MyString&>(*this).at[index]);
		 }
		 const char &at(unsigned int index) const
		 {
			 int temp = index;
			 if (index >= length_)
			 {
				 //printf("超出范围");
				 temp = length_;
			 }
			 return str_[temp];
		 }
		 MyString &operator+=(const MyString &other)
		 {
			 return this->operator+=(other.str_);
		 }
		 MyString &operator+=(const char *s)
		 {
			 length_ += strlen(s);
			 char *temp = new char[length_ + sizeof(char)];
			 memset(temp, 0, length_ + sizeof(char));
			 strcpy(temp, str_);
			 strcat(temp, s);
			 delete[]str_;
			 str_ = temp;
			 return *this;
		 }
		 MyString &operator+=(char c)
		 {
			 char temp[2] = { 0 };
			 temp[0] = c;
			 return this->operator+=(temp);
		 }
		 friend MyString operator+(const MyString&lhs, const MyString&rhs)
		 {
			  
			 return MyString(lhs)+=rhs;
		 }
		 friend MyString operator+(const MyString&lhs, const  char*rhs)
		 {
			  
			 return MyString(lhs)+=rhs;
		 }
		 friend MyString operator+(const char*lhs, const MyString&rhs)
		 {
			 return MyString(lhs) += rhs;
		 }
		 friend MyString operator+(const MyString&lhs, char rhs)
		 {
			 return MyString(lhs) +=  rhs ;
		 }
		 friend MyString operator+(char lhs, const MyString&rhs)
		 {
			 char temp[2] = { 0 };
			 temp[0] = lhs;
			 return MyString(temp) += rhs;
		 }
	private:
		char *str_;
		unsigned int length_;//当前长度
		const int max_size_; //最大长度
		char *Alloc(const char*data)
		{
			length_ = strlen(data);
			char *temp = new char[length_ + sizeof(char)];
			strcpy(temp, data);
			return temp;
		}
	};
}
#endif // ! _MYSTRING_H_