string类的基础上的运算符重载

class myString
{

private:
	char* str;  //记录C风格的字符串
	int size;   //字符串的实际长度

public:
	//无参构造
	myString() :size(32)
	{
		str = new char[size];   //构造一个长度为10的字符串
		cout << "this = " << this << endl;
		cout << "无参构造" << endl;
	}

	//字符串大小构造
	myString(int _size):size(_size)
	{
		str = new char[_size + 1];
		*str = '\0';    //没有此语句，会乱码
		cout << "字符串尺寸this = " << this << endl;
		cout << "有参构造size" << endl;
	}

	//有参构造
	myString(const char* s)
	{
		size = strlen(s);

		str = new char[size + 1];
		strcpy(str, s);
		//cout << "----" << str << endl;   //只有有参构造才会调用此语句，此时输出内容即为初始化输入内容
		//cout << "size = " << size << endl;

		cout << "this = " << this << endl;
		cout << "有参构造" << endl;
	}

	//拷贝构造
	myString(const myString& other):size(other.size)
	{
		str = new char[size + 1];   //计算\0的空间，申请空间
		strcpy(str, other.str);

		cout << "构造拷贝this = " << this << endl;
		cout << "拷贝构造" << endl;
	}
	//拷贝赋值
	myString& operator=(const myString& other)
	{
		if (this != &other)  //排除给自己赋值的情况
		{
			//先释放自己的内存，因为要存储新的东西，所以干脆释放掉原空间
			delete[]str;
			//再申请
			this->size = other.size;
			str = new char[size + 1];
			strcpy(str, other.str);
		}

		cout << "构造赋值this = " << this << endl;
		cout << "拷贝赋值" << endl;
		return *this;
	}
	//析构函数
	~myString()
	{
		cout << "析构this = " << this << endl;
		
		delete[]str;   //成员变量有指针成员指向的内存空间，所以析构函数中需要delete

		cout << "析构函数" << endl;
	}
	//判空函数
	bool empty()
	{
		if (size == 0)
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}
	//size函数
	int mysize()
	{
		//return size;
		return strlen(str);
	}
	//c_str函数
	char* c_str()
	{
		return str;
	}
	//at函数
	char& at(int i)   //调用at后可以赋值，左值函数，传递过来可以修改，返回值采用引用
	{
		if (i<0 || i>size)
		{
			cout << "越界" << endl;
			//此时的返回值应该是错误的返回
		}
		//return *(str + i);
		return str[i];
	}

	//字符串打印
	void show()
	{
		cout << "===" << str << endl;
	}

	//运算符重载，+号，完成字符串的拼接
	const myString operator+(const myString& R)const
	{
		int mysize = this->size + R.size;
		myString temp(mysize);
		*temp.str = '\0';
		strcat(temp.str, this->str);
		strcat(temp.str, R.str);
	
		return temp;
	}

	//重载-，字符串比较
	const myString operator-(const myString& R)const
	{
		int mysize = 0;
		this->size > R.size ? mysize = this->size : mysize = R.size;
		
	}

};

int main6_5()
{
	/*myString s1;

	myString s2("hello");

	myString s5("world");

	myString s3(s2);

	cout << "***********1**********" << endl;
	myString s4;
	s4 = s2;
	s4.show();
	cout << "***********2**********" << endl;*/

	myString s1("hello hello");
	myString s2("world");   //调用有参构造
	myString s3;   //调用无参构造
	/*都在堆区，先构造的后析构*/
	
	cout << "***********3**********" << endl;

	//s3 = s1 + s2;   //会调用拷贝构造函数
	s3 = s1;   //调用拷贝赋值
	s1.show();
	s3.show();

	cout << "***********3333**********" << endl;
	s1 = s2;
	s1.show();
	s3.show();

	cout << "***********4**********" << endl;

	return 0;
}