Implementation string mystring

#include <vector>
#include<iostream> //istream ,ostream
#include<assert.h>
#include<fstream>
using namespace std;
class MyString
{
private:
	struct StrNode
	{
		int ref;// Reference count ( Indicates how many customers are using )
		int len;// Character length 
		int capc;// Capacity 
		char data[0];// Flexible array （ Or to 0, Or give nothing ）
	};
	enum{ALGIN=8};// enumeration 
private:
	StrNode* pstr;// Pointer to structure type 
	size_t round_up(size_t n)// The improvement of its way 
	{
		return (n + ALGIN - 1) & ~(ALGIN - 1);
		//return ((n - 1) / ALGIN + 1) * ALGIN;    Such as ：1,2,3,4,5,6,7,8=>8  ;  9,10,11,...,16=>16
		
	}
	static StrNode* M_Malloc(size_t size)//size Space for flexible arrays 
	{
		// encapsulation malloc, And the tail information 
		StrNode* s = (StrNode*)malloc(sizeof(StrNode) + sizeof(char) * size);
		if (nullptr == s)
		{
			exit(1);
		}
		return s;
	}
	static StrNode* M_Realloc(StrNode* p, size_t size)
	{
		StrNode* s = (StrNode*)realloc(p, sizeof(StrNode) + sizeof(char) * size);
		if (nullptr == s)
		{
			exit(1);
		}
		s->capc = size-1;
		return s;
	}
	static StrNode* cloneStrNode(StrNode* ps)// clone 
	{
		StrNode* s = M_Malloc(ps->capc + 1);
		memmove(s, ps, sizeof(StrNode) + ps->len + 1);
		s->ref = 1;
		s->len =ps->len;
		s->capc = ps->capc;
		return s;
	}
public:
	typedef char value_type;// The value type is set to char
	typedef char* iterator; // The iterator is set to char
	typedef const char* const_iterator;// Constant iterator , Can only point to you , Can't modify you 
public:
	iterator begin()
	{
		return pstr->data;
	}
	iterator end()
	{
		return pstr->data + pstr->len;
	}
	const iterator begin() const
	{
		return pstr->data;
	}
	const iterator end() const
	{
		return pstr->data + pstr->len;
	}

public:
	void clear()  // Clearing is to reduce the reference count , When the reference count is 0 when , To be eligible for release 
	{
		if (nullptr != pstr && --pstr->ref == 0)
		{
			free(pstr);
		}
		pstr = nullptr;
	}
	// Capacity function 
	size_t size() const // The number of strings 
	{
		//assert(pstr != nullptr);
		return (pstr != nullptr) ? pstr->len : 0;
	}
	size_t length() const { return size(); }
	bool empty() const{ return size() == 0; }
	size_t capacity() const
	{
		return (pstr != nullptr) ? pstr->capc : 0;
	}
	void reserve(size_t newsz);// Keep the storage function 
	// Element access function 
	char& at(const int index) // Copy while writing 
	{
		return operator[](index);
	}

	const char& at(const int index) const
	{
		return operator[](index);
	}
	char& operator[](const int index)// Overload subscript operators 
	{
		assert(pstr != nullptr && index >= 0 && index < pstr->len);
		if (pstr->ref > 1)
		{
			pstr->ref -= 1;
			pstr = cloneStrNode(pstr);
		}
		else
		{
			return pstr->data[index];
		}
	}
	const char& operator[](const int index) const
	{
		assert(pstr != nullptr && index >= 0 && index < pstr->len);
		return pstr->data[index];
	}

	char& front()// Access the first character 
	{
		return at(0);
	}
	const char& front() const
	{
		return at(0);
	}
	char& back()// Access the last character 
	{
		return at(pstr->len - 1);//return at(size()-1);
	}
	const char& back()const
	{
		return at(size() - 1);
	}
	const char* c_str() const
	{
		return (pstr == nullptr) ? nullptr : pstr->data;
	}
	const char* data() const
	{
		return (pstr == nullptr) ? nullptr : pstr->data;
	}
	char* data()
	{
		return (pstr == nullptr) ? nullptr : pstr->data;
	}

public:
	MyString(const char* p = nullptr) :pstr(nullptr)// Constructors , And initialize it 
	{
		if (nullptr != p)
		{
			int n = strlen(p);
			int total = round_up(2 * n);// Upgrade to 8 Multiple 
			//int total = 2* n;
			pstr = M_Malloc(total);//total Is the size of the flexible array 
			pstr->ref = 1;
			pstr->len = n;
			pstr->capc = total - 1;
			strcpy_s(pstr->data, total, p);
		}

	}
	~MyString() // Destructor 
	{
		/*if (nullptr != pstr && --pstr->ref == 0)// Indicates a structure that points to a flexible array , And the reference count is 0( This string is no longer used )
		{
			free(pstr);
		}
		pstr = nullptr;
		*/
		clear();
	}
	MyString(const MyString& s) :pstr(s.pstr)// Shallow copy constructors ( When the reference count is 0 when , Will die )
	{
		if (pstr != nullptr)
		{
			pstr->ref += 1;
		}
	}
	MyString& operator=(const MyString& sc) // The mutator 
	{
		if (this == &sc||this->pstr==sc.pstr) return *this;// Assign yourself a value , It doesn't make any sense 
		clear();//s1=s2, Before assignment , First the s1 eliminate 
		pstr = sc.pstr;
		if (pstr != nullptr)
		{
			pstr->ref += 1;
		}
		return *this;
	}
	MyString(MyString&& sc):pstr(sc.pstr)// Mobile construction ( Give resources in heap space to another space , The reference count does not change )
	{
		sc.pstr = nullptr;
	}
	MyString& operator=(MyString&& sc)// Move assignment 
	{
		if (this == &sc) return *this;
		clear();// Release your own resources first 
		pstr = sc.pstr;
		sc.pstr = nullptr;// After moving , Resource empty , Then empty it 
		return *this;
	}//s1=std::move(s2);

	ostream& operator<<(ostream& out) const // Output stream 
	{
		if (pstr != nullptr)
		{
			out << pstr->data;
		}
		return out;
	}

	void Print() const
	{
		if (pstr != nullptr)
		{
			cout << pstr->data << endl;
		}
	}
	MyString operator+=(const MyString& sc) ;// Add string objects 
	MyString operator+=(const char* p);// Add string constants 
	MyString& operator += (const char ch)// Append character 
	{
		char str[2] = { ch,'\0' };
		if (pstr == nullptr) 
		{
			*this= MyString(str);
		}
		else if(pstr->ref==1)
		{
			if (pstr->capc - pstr->len >= 0)
			{
				pstr->data[pstr->len] = ch;
				pstr->data[++pstr->len] = '\0';
			}
			else
			{
				pstr = M_Realloc(pstr, round_up(pstr->len * 2));// Capacity expansion 
			}
		}
		else
		{
			pstr->ref -= 1;
			pstr = cloneStrNode(pstr);
			if (pstr->capc - pstr->len >= 0)
			{
				pstr->data[pstr->len] = ch;
				pstr->data[++pstr->len] = '\0';
			}
			else
			{
				pstr = M_Realloc(pstr, round_up(pstr->len * 2));// Capacity expansion 
			}

		}
		return *this;
	}
};
MyString operator+(const char* p, const MyString& sc) ;// Character constants are added to string objects 

ostream& operator<<(ostream& out, const MyString& s)// Global output function 
{
	s << out;//s.operator<<(out); operator<<(s,out);
	return out;
}
int main()
{
	MyString s1("yhping");
	MyString::iterator it = s1.begin();
	for (; it != s1.end(); ++it)
	{
		//cout << *it << endl;
	}
	for (char ch:s1)// Range for
	{
		cout << ch << endl;
	}
	size_t n = s1.size();
	for (int i = 0; i<n; i++)
	{
		cout << s1.at(i) << " ";
		//cout << s1[i] << "  ";
	}
	s1.Print();
	const char* str = s1.c_str();
	if (str != nullptr)
	{
		cout << str << endl;
	}
	return 0;
}

Running results ：