mystring实现

#include <iostream>
using namespace std;

class mystring
{
public:
mystring();
~mystring() {}
mystring(const char *str);
mystring(mystring &str);
mystring &operator =(const mystring &str);
mystring &operator =(const char *c_str);
char operator [](const unsigned int index);
mystring strcat (const mystring &str);
mystring strcat (const char *c_str);
mystring substring(int i, int j); //截取子链
mystring substring(int i);
bool operator >(const mystring &str);
bool operator >(const char *c_str);
bool operator >=(const mystring &str);
bool operator >=(const char *c_str);
bool operator <(const mystring &str);
bool operator <(const char *c_str);
bool operator <=(const mystring &str);
bool operator <=(const char *c_str);
mystring strcopy(mystring src);
mystring strcopy(char *str);
char *getstring();
int length();
void clear();
private:
char *m_string;
unsigned int m_size;
public:
friend ostream &operator <<(ostream &ostr, mystring &str)
{
ostr << str.getstring();
return ostr;
}
friend istream &operator >>(istream &istr, mystring &str)
{
char temp[255];
istr >> temp;
str = temp;
return istr;
}
};

mystring::mystring()
{
m_string = NULL;
m_size = 0;
}

mystring::mystring(const char *str)
{
int i = 0;
char *strings;
m_size = 0;
while (str[m_size] != '\0')
{
m_size++;
}
m_string = new char[m_size+1];
strings = m_string;
while(str[i] != '\0')
{
*strings = str[i];
strings++;
i++;
}
*strings = '\0';
}

mystring::mystring(mystring &str)
{
char *strings, *strings1;
strings1 = str.m_string;
m_size = str.m_size;
strings = new char[m_size];
m_string = strings;
while(*strings1 != '\0')
{
*strings = *strings1;
strings1++;
strings++;
}
*strings = '\0';
}

char *mystring::getstring()
{
return m_string;
}

int mystring::length()
{
return m_size;
}

void mystring::clear()
{
if( !m_string )
{
delete []m_string;
m_string = NULL;
}
m_size = 0;
}

mystring &mystring::operator =(const mystring &str)
{
int i = 0;
char *strings;
clear();
m_size = str.m_size;
strings = new char[m_size];
m_string = strings;
while(str.m_string[i] != '\0')
{
*strings = str.m_string[i++];
strings++;
}
*strings = '\0';
return *this;
}

mystring &mystring::operator =(const char *c_str)
{
int i = 0;
char *mm_string;
cout << c_str;
while (c_str[i] != '\0')
i++;
clear();
m_string = new char[i];
mm_string = m_string;
while (c_str[i] != '\0')
{
*mm_string = c_str[i];
i++;
mm_string++;
}
*mm_string = '\0';
return *this;
}

char mystring::operator [](const unsigned int index)
{
return(m_string[index]);
}

mystring mystring::strcat (const mystring &str)
{
int i, j = 0;
char *strings1, *strings2;
i = str.m_size + m_size;
strings1 = new char[i+1];
strings2 = strings1;
while (m_string[j] != '\0')
{
*strings1 = m_string[j];
strings1++;
j++;
}
j = 0;
while(str.m_string[j] != '\0')
{
*strings1 = str.m_string[j];
strings1++;
j++;
}
*strings1 = '\0';
return mystring(strings2);
}

mystring mystring::strcat (const char *c_str)
{
int i = 0, j = 0;
char *strings1, *strings2;
while(c_str[i++] != '\0');
i += m_size;
strings1 = new char[i+1];
strings2 = strings1;
while (m_string[j] != '\0')
{
*strings1 = m_string[j];
strings1++;
j++;
}
j = 0;
while(c_str[j] != '\0')
{
*strings1 = c_str[j];
strings1++;
j++;
}
*strings1 = '\0';
return mystring(strings2);
}

mystring mystring::substring(int i, int j)
{
char *strings = new char[j];
int k = 0;
while (k <= j - 1)
strings[k++] = m_string[i];
strings[k] = '\0';
return mystring(strings);
}

mystring mystring::substring(int i)
{
return substring(i, m_size - i + 1);
}
bool mystring::operator >(const char *c_str)
{
unsigned int i = 0;
bool flag;
while(m_string[i] != '\0' && c_str[i] != '\0')
{
if (m_string[i] == c_str[i])
{
i++;
continue;
}
else if (m_string[i] > c_str[i])
{
flag = true;
break;
}
else
{
flag = false;
break;
}
}
if (i >= m_size) flag = false;
else flag = m_string[i] > c_str[i];
return flag;
}
bool mystring::operator >(const mystring &str)
{
mystring a(m_string);
return (a > str.m_string);
}

bool mystring::operator >=(const char *c_str)
{
unsigned int i = 0;
bool flag;
while(m_string[i] != '\0' && c_str[i] != '\0')
{
if (m_string[i] == c_str[i])
{
i++;
continue;
}
else if (m_string[i] > c_str[i])
{
flag = true;
break;
}
else
{
flag = false;
break;
}
}
if (m_string[i] == '\0' && c_str[i] == '\0') flag = true;
else flag = m_string[i] > c_str[i];
return flag;
}

bool mystring::operator >=(const mystring &str)
{
mystring a(m_string);
return (a >= str.m_string);
}
bool mystring::operator <(const char *c_str)
{
mystring a(m_string);
return !(a >= c_str);
}

bool mystring::operator <(const mystring &str)
{
mystring a(m_string);
return !(a >= str.m_string);
}
bool mystring::operator <=(const mystring &str)
{
mystring a(m_string);
return !(a > str.m_string);
}
bool mystring::operator <=(const char *c_str)
{
mystring a(m_string);
return !(a > c_str);
}

mystring mystring::strcopy(char *str)
{
clear();
int i = 0;
while (str[i] != '\0')
{
m_string[i] = str[i];
i++;
}
m_string[i] = '\0';
m_size = i;
return *this;
}