C＋笔记七十五：MyString类案例——重载大于小于操作符

strcmp函数，在C/C++函数，比较两个字符串。设这两个字符串为str1，str2，

（1）若str1==str2，则返回零；

（2）若str1

（3）若str1>str2，则返回正数。

注意，如果两个字符串长度不一致，并且前面的字符都相等，那么就是这个长的字符串要大。直接看程序

1

MyString.h

#pragmaonce

usingnamespacestd;

classMyString

{

//重载左操作符友元函数

friendostream&operator

public:

//无参构造函数，定义一个空串

MyString(void);

//有参构造函数

MyString(constchar*p);

//拷贝构造函数

MyString(constMyString& s);

//析构函数

~MyString(void);

public:

//等号操作符重载函数s4=s2;

MyString&operator=(constMyString& str);

//等号操作符重载函数s4="ab";

MyString&operator=(constchar* str);

//重载[]操作符

char&operator[](intindex);

//重载双等号操作符

booloperator==(MyString& str);

booloperator==(char*p);

//重载不等号操作符

boolMyString::operator!=(MyString& str);

boolMyString::operator!=(char* p);

//重载大于操作符

intoperator>(constchar*p);

intoperator>(constMyString& str);

//重载小于操作符

intoperator

intoperator

private:

intm_len;//储存字符串的长度

char*m_p;//指向字符串所在内存的首地址

};

2

MyString.cpp

#define_CRT_SECURE_NO_WARNINGS

#include

#include"MyString.h"

//无参构造函数，定义一个空串

MyString::MyString(void)

{

m_len=0;

m_p=newchar[m_len+1];

strcpy(m_p,"");

}

//有参构造函数

MyString::MyString(constchar*p)

{

if(NULL==p)

{

m_len=0;

m_p=newchar[m_len+1];

strcpy(m_p,p);

}

else

{

m_len=strlen(p);

m_p=newchar[m_len+1];

strcpy(m_p,p);

}

}

//拷贝构造函数

MyString::MyString(constMyString& s)

{

m_len=s.m_len;

m_p=newchar[m_len+1];

strcpy(m_p,s.m_p);

}

//析构函数

MyString::~MyString(void)

{

if(m_p!=NULL)

{

delete[]m_p;

m_p=NULL;

m_len=0;

}

}

//重载等号操作符,考虑链式编程

//s4=s2

//s4.operator=(s2)

//MyString& operator=(const MyString& str)

//s4的指针已经分配内存空间了，因此需要先把旧的释放掉

MyString& MyString::operator=(constMyString& str)

{

//(1)把旧的内存释放掉

if(m_p!=NULL)

{

delete[]m_p;

m_len=0;

}

//(2)根据str分配内存，str是类的对象，至少是空串

m_len=str.m_len;

m_p=newchar[m_len+1];

strcpy(m_p,str.m_p);

return*this;

}

//重载等号操作符,考虑链式编程

//s4="ab"

//s4.operator=("ab")

//MyString& operator=(const char* str)

//s4的指针已经分配内存空间了，因此需要先把旧的释放掉

MyString& MyString::operator=(constchar* str)

{

//(1)把旧的内存释放掉

if(m_p!=NULL)

{

delete[]m_p;

m_len=0;

}

//(2)根据str分配内存

if(NULL==str)

{

m_len=0;

m_p=newchar[m_len+1];

strcpy(m_p,"");

}

else

{

m_len=strlen(str);

m_p=newchar[m_len+1];

strcpy(m_p,str);

}

return*this;//支持链式编程，返回引用

}

//重载数组小标[]操作符

//s4[i]

//s4.operator[](int i)

//char& operator[](int i)

char& MyString::operator[](intindex)

{

returnm_p[index];//可以作为左值，返回引用

}

//重载双等号操作符

//s3==s4

//s3.operator==(s4)

//bool operator==(MyString& str)

boolMyString::operator==(MyString& str)

{

if(m_len!=str.m_len)

{

returnfalse;

}

return!strcmp(this->m_p,str.m_p);

}

//重载双等号操作符

//s3=="abcd"

//s3.operator==("abcd")

//bool operator==(char *p)

boolMyString::operator==(char*p)

{

if(NULL==p)

{

if(0==m_len)

{

returntrue;

}

returnfalse;

}

else

{

if(m_len==strlen(p))

{

//strcmp比较字符串是否相等，相等返回

return!strcmp(m_p,p);

}

else

{

returnfalse;

}

}

}

//重载不等号操作符

//s3！=s4

//s3.operator!=(s4)

//bool operator!=(MyString& str)

boolMyString::operator!=(MyString& str)

{

return!(*this==str);

}

//重载不等号操作符

//s3！="abcd"

//s3.operator!=("abcd")

//bool operator!=(char* p)

boolMyString::operator!=(char* p)

{

return!(*this==p);

}

//重载大于操作符

//s3>"abcd"

intMyString::operator>(constchar*p)

{

returnstrcmp(p,this->m_p);

}

//重载大于操作符

intMyString::operator>(constMyString& str)

{

returnstrcmp(str.m_p,this->m_p);

}

//重载小于操作符

//s3

intMyString::operator

{

returnstrcmp(this->m_p,p);

}

//重载小于操作符

intMyString::operator

{

returnstrcmp(this->m_p,str.m_p);

}

//cout

//operator

//只能用全局函数

ostream&operator

{

cout

returnout;

}

3

Test.cpp

#include

#include"MyString.h"

usingnamespacestd;

intmain()

{

//类定义对象时才调用构造函数

MyString s1;//调用无参构造函数

MyString s2("abcd");//调用有参构造函数

MyString s3=s2;//调用拷贝构造函数深拷贝

MyString s4="abcdefg";//调用有参构造函数

inttag=(s3

{

cout

}

elseif(tag

{

cout

}

else

{

cout

}

cout

system("pause");

return0;

}