作业：自行实现一个Mystring类

#define _CRT_SECURE_NO_WARNINGS  //VS避免安全检查周期预处理

#include<iostream>  //C++标准头文件
#include<cstdlib>   //stdlib.h头文件
#include<cstring>
#include <string>

#define Myc_str() Mydata()
#define Mylength() Mysize()
using size_type = int;

class Mystring//typeid(*this).name()
{
public:
	Mystring() :len(0), str(nullptr)//无参构造函数
	{std::cout << "无参构造函数" << typeid(*this).name() << std::endl;}
	//有参构造函数
	Mystring(const char* const chararr)
	{
		len = (int)strlen(chararr);
		str = new char[len + 1];
		strcpy(str, chararr);
		std::cout << "有参构造函数" << typeid(*this).name() << std::endl;
	}
	~Mystring()//析构函数
	{
		if (str != nullptr)
		{
			delete[] str;
			str = nullptr;
		}
		std::cout << "析构函数" << typeid(*this).name() << std::endl;
	}
	//拷贝构造函数
	Mystring(const Mystring& mystr)
	{
		len = (int)strlen(mystr.str);
		str = new char[len + 1];
		strcpy(str, mystr.str);
		std::cout << "拷贝构造函数" << typeid(*this).name() << std::endl;
	}
	//拷贝赋值函数
	Mystring& operator=(const Mystring& mystr)
	{
		if (&mystr != this)
		{
			len = mystr.len;
			if (str == nullptr)	str = new char[len + 1];
			else
			{
				delete[] str;
				str = nullptr;
				str = new char[len + 1];
			}
			strcpy(str, mystr.str);
		}
		//std::cout << "拷贝赋值函数" << typeid(*this).name() << std::endl;
		return *this;
	}
	//将字符串以C字符数组的形式返回
	char* Mydata(){return str;}//Myc_str()
	//返回字符串中字符的数量
	size_type Mysize(){ return len;}//Mylength()
	//如果字符串为空，返回真
	bool Myempty()
	{
		if (str == nullptr) return true;
		else return false;
	}
	//按给定索引值返回字符
	char& Myat(size_type index)
	{
		if (index >= len || index < 0)
		{
			std::cout << "index不在字符串范围内" << std::endl;
			return str[len-1];
		}
		else return str[index];
	}

	//连接两个字符串的对象
	Mystring operator+(const Mystring& s)const
	{
		Mystring p(new char[len + s.len + 1]);
		strcpy(p.str, str);
		strcat(p.str, s.str);
		return p;
	}
	//会改变左操作数
	/*const Mystring& operator+(const Mystring& s)
	{	
		char* p = new char[len + 1];
		strcpy(p, str);
		len = len + s.len;
		if (str != nullptr)
		{
			delete[] str;
			str = nullptr;
			str = new char[len + 1];
		}
		strcpy(str, p);
		delete[] p;
		strcat(str, s.str);
		return *this;
	}*/

	//测试运算符左侧的字符串对象是否不等于右侧的字符串对象
	bool operator!=(const Mystring& s)const
	{
		int res = strcmp(str, s.str);
		if (res == 0) return false;
		else return true;
	}

	//测试运算符左侧的字符串对象是否等于右侧的字符串对象
	bool operator==(const Mystring& s)const
	{
		int res = strcmp(str, s.str);
		if (res == 0) return true;
		else return false;
	}

	//测试运算符左侧的字符串对象是否小于右侧的字符串对象
	bool operator<(const Mystring & s)const
	{
		int res = strcmp(str, s.str);
		if (res < 0) return true;
		else return false;
	}

	//测试运算符左侧的字符串对象是否小于或等于右侧的字符串对象
	bool operator<=(const Mystring& s)const
	{
		int res = strcmp(str, s.str);
		if (res <= 0) return true;
		else return false;
	}

	//测试运算符左侧的字符串对象是否大于右侧的字符串对象
	bool operator>(const Mystring& s)const
	{
		int res = strcmp(str, s.str);
		if (res > 0) return true;
		else return false;
	}

	//测试运算符左侧的字符串对象是否大于或等于右侧的字符串对象
	bool operator>=(const Mystring& s)const
	{
		int res = strcmp(str, s.str);
		if (res >= 0) return true;
		else return false;
	}

	//一个模板函数，用于向输出流插入字符串
	friend std::ostream& operator<<(std::ostream& ostr, const Mystring& str);

	//一个模板函数，用于从输入流提取字符串
	friend std::istream& operator>>(std::istream& ostr,  Mystring& s);

private:
	char* str;
	int len;
};

//一个模板函数，用于向输出流插入字符串
std::ostream& operator<<(std::ostream& ostr,const Mystring& s)
{
	std::cout << s.str;
	return ostr;
}

//一个模板函数，用于从输入流提取字符串
std::istream& operator>>(std::istream& ostr, Mystring& s)
{
	std::cout << "请输入>>>";
	char buf[100] = { 0 };
	std::cin >> buf;
	s.len = strlen(buf);
	if (s.str != nullptr)
	{
		delete[] s.str;
		s.str = nullptr;
	}
	s.str = new char[s.len + 1];
	return ostr;
}

int main(int count, const char* strarr[])
{
	Mystring str1;//Myempty()和无参构造函数的测试
	std::cout << "Myempty() str1测试:" << std::boolalpha << str1.Myempty() << std::endl;
	Mystring str2("hello world");//有参构造函数的测试
	Mystring str3 = str2;//拷贝构造函数的测试
	str1 = str2;//拷贝赋值函数的测试
	
	//Mylength()
	std::cout << "Mylength():" << str1.Mylength() << std::endl;
	//Myc_str()
	char* str = str1.Myc_str();
	std::cout << "str:" << str << std::endl;
	std::cout << "strlen(str1.Myc_str()):" << strlen(str) << std::endl;
	
	//Myat()
	std::cout << "str1.Myat(12):" << str1.Myat(12) << std::endl;
	char ch = str1.Myat(6);
	std::cout << "str1.Myat(6):" << ch << std::endl;

	//连接两个字符串对象
	str3 = str1 + str2; 
	std::cout << "str3:" << str3 << std::endl << "str1 + str2:" << str1 + str2 << std::endl;

	Mystring str4 = "abcdef";
	Mystring str5 = "abcde";
	//测试运算符左侧的字符串对象是否不等于右侧的字符串对象
	std::cout << std::boolalpha << "str1!=str2?  " << (str1 != str2) << std::endl;
	//测试运算符左侧的字符串对象是否等于右侧的字符串对象
	std::cout << std::boolalpha << "str1==str2?  " << (str1 == str2) << std::endl;
	//测试运算符左侧的字符串对象是否小于右侧的字符串对象
	std::cout << std::boolalpha << "str4<str5?  " << (str4 < str5) << std::endl;
	//测试运算符左侧的字符串对象是否小于或等于右侧的字符串对象
	std::cout << std::boolalpha << "str4<=str5?  " << (str4 <= str5) << std::endl;
	//测试运算符左侧的字符串对象是否大于右侧的字符串对象
	std::cout << std::boolalpha << "str4>str5?  " << (str4 > str5) << std::endl;
	//测试运算符左侧的字符串对象是否大于或等于右侧的字符串对象
	std::cout << std::boolalpha << "str4>=str5?  " << (str4 >= str5) << std::endl;

	//一个模板函数，用于向输出流插入字符串
	std::cout << "str4:" << str4 << std::endl;
	//一个模板函数，用于从输入流提取字符串
	Mystring str6;
	//std::string s;
	//std::cin >> s;
	//std::cout << "s:" << s << std::endl;
	std::cin >> str6;
	std::cout << "str6:" << str6 << std::endl;

	return 0;
}