运算符重载之MyString

#ifndef _MYSTRING_H
#define _MYSTRING_H
#include<iostream>


using namespace std;


class MyString
{
private:
char *m_data;
int m_length;
public:
MyString();
MyString(char *str);
MyString(int a, char ch);
MyString(const MyString &a);
~MyString();


//重载<< >>运算符，实现为全局函数
friend ostream &operator <<(ostream &out, const MyString &s);
friend istream &operator >>(istream &in, MyString &s);


//重载=运算符
MyString &operator =(char *str);
MyString &operator =(const MyString &s);


//重载[]运算符
char &operator [](int index);


//重载+ +=运算符
MyString &operator +(char *str);
MyString &operator +(const MyString &s);
MyString &operator +=(char *str);
MyString &operator +=(const MyString &s);


//重载== !=运算符
bool operator ==(char *str);
bool operator ==(const MyString &s);
bool operator !=(char *str);
bool operator !=(const MyString &s);


//重载> <运算符
bool operator >(char *str);
bool operator >(const MyString &s);
bool operator <(char *str);
bool operator <(const MyString &s);
};

#endif

#include"MyString.h"
#include<iostream>
#include<cstring>


using namespace std;


MyString::MyString()
{
m_length = 0;
m_data = NULL;
}


MyString::MyString(char *str)
{
m_length = strlen(str);
m_data = new char [m_length + 1];
strcpy(m_data, str);
m_data[m_length] = '\0';
}


MyString::MyString(int a, char ch)
{
m_length = a;
m_data = new char[a + 1];
for(int i = 0; i < m_length; i ++)
{
m_data[i] = ch;
}
m_data[m_length] = '\0';
}


MyString::MyString(const MyString &s)
{
m_length = s.m_length;
m_data = new char[m_length + 1];
strcpy(m_data, s.m_data);
m_data[m_length] = '\0';
}


MyString::~MyString()
{
if(m_data != NULL)
{
delete[] m_data;
m_data = NULL;
}
}


ostream &operator <<(ostream &out, const MyString &s)
{
out << s.m_data;
return out;
}


istream &operator >>(istream &in, MyString &s)
{
char tmp[100] = {0};
in >> tmp;
s.m_length = strlen(tmp);
s.m_data = new char[s.m_length + 1];
strcpy(s.m_data, tmp);
s.m_data[s.m_length] = '\0';
return in;
}


MyString &MyString::operator =(char *str)
{
m_length = strlen(str);
if(m_data != NULL)
{
delete[] m_data;
}
m_data = new char[m_length + 1];
strcpy(m_data, str);
m_data[m_length] = '\0';
return *this;
}


MyString &MyString::operator =(const MyString &s)
{
m_length = s.m_length;
if(m_data != NULL)
{
delete[] m_data;
}
m_data = new char[m_length + 1];
strcpy(m_data, s.m_data);
m_data[m_length] = '\0';
return *this;
}


char &MyString::operator [](int index)
{
return m_data[index];
}


MyString &MyString::operator +(char *str)
{
char *tmp = m_data;
m_length = m_length + strlen(str);
m_data = new char[m_length + 1];
strcpy(m_data, tmp);
strcat(m_data, str);
delete[] tmp;
m_data[m_length] = '\0';
return *this;
}


MyString &MyString::operator +(const MyString &s)
{
char *tmp = m_data;
m_length = m_length + s.m_length;
m_data = new char[m_length + 1];
strcpy(m_data, tmp);
strcat(m_data, s.m_data);
delete[] tmp;
m_data[m_length] = '\0';
return *this;
}


MyString &MyString::operator +=(char *str)
{
char *tmp = m_data;
m_length = m_length + strlen(str);
m_data = new char[m_length + 1];
strcpy(m_data, tmp);
strcat(m_data, str);
delete[] tmp;
m_data[m_length] = '\0';
return *this;
}


MyString &MyString::operator +=(const MyString &s)
{
char *tmp = m_data;
m_length = m_length + s.m_length;
m_data = new char[m_length + 1];
strcpy(m_data, tmp);
strcat(m_data, s.m_data);
delete[] tmp;
m_data[m_length] = '\0';
return *this;
}


bool MyString::operator ==(char *str)
{
if(!strcmp(m_data, str))
{
return true;
}
else
{
return false;
}
}


bool MyString::operator ==(const MyString &s)
{
if(!strcmp(m_data, s.m_data))
{
return true;
}
else
{
return false;
}
}


bool MyString::operator !=(char *str)
{
if(strcmp(m_data, str))
{
return true;
}
else
{
return false;
}
}


bool MyString::operator !=(const MyString &s)
{
if(strcmp(m_data, s.m_data))
{
return true;
}
else
{
return false;
}
}


bool MyString::operator >(char *str)
{
if(strcmp(m_data, str) > 0)
{
return true;
}
else
{
return false;
}
}


bool MyString::operator >(const MyString &s)
{
if(strcmp(m_data, s.m_data))
{
return true;
}
else
{
return false;
}
}


bool MyString::operator <(char *str)
{
if(strcmp(m_data, str) < 0)
{
return true;
}
else
{
return false;
}
}


bool MyString::operator <(const MyString &s)
{
if(strcmp(m_data, s.m_data) < 0)
{
return true;
}
else
{
return false;
}

}

#include"MyString.h"
#include<iostream>


using namespace std;
#if 0
int main()
{
MyString s1(5,'a');
MyString s2("hello");
MyString s3(s2);
// MyString s4;
s3 = "hello";
cout << s1 << endl;
cout << s2 << endl;
cout << s3 << endl;
cout <<s3[0] << endl;
// cin >> s4;
// cout << s4 << endl;
cout << "***" << endl;
MyString s5 = s2 + "00000";
cout << s5 << endl;
return 0;
}

#endif

#if 0
int main()
{
MyString s1 = "helloworld";
MyString s2 = "hello";
if(s1 == s2)
{
cout << "s1 = s2" <<endl;
}


if(s1 != s2)
{
cout << "s1 != s2" << endl;
}


if(s1 > s2)
{
cout << "s1 > s2" << endl;
}
if(s2 < s1)
{
cout << "s2 < s1" << endl;
}
return 0;
}
#endif

int main()
{
MyString s1("111");
MyString s2("222");
cout <<"s1 + aaa = " <<  s1 + "aaa" << endl;
cout << "s1 = " << s1 << endl;
s2 += "bbb";
cout << "s2 += bbb" << s2 << endl;
cout << "************" << endl;
cout << "s1 + s2 = " << s1 + s2 << endl;
cout << "s1 = " << s1 << " " << "s2 = " << s2 << endl;
s1 += s2;
cout << "s1 += s2, s1 = " << s1 << endl;
return 0;
}

可作为参考。