[C++]学习String类的定义和使用（重载）

//String类的定义
Class String{
char*str;
intsize;
voidError(int errorType, int badIndex = 0) const; //出错报警函数
public:
String(char*s);
String(constString & s); //复制构造函数
~String(void);
// 重载赋值运算符函数
String& operator= (const String & s); //String类的对象赋值
String& operator= (char * s); //字符串赋值给对象
// 重载关系运算符函数
intoperator== (char * str, const String & s);
intoperator< (const String & s) const; //判断调用对象是否小于形参
intoperator< (char * str) const;
friendint operator< (char * str, const String & s);
intoperator> (const String & s) const;
intoperator> (char * str) const;
friendint operator> (char * str, const String & s);
// 重载算术运算符函数
Stringoperator+ (const String & s) const;
Stringoperator+ (char * str) const;
friendint operator+ (char * str, const String & s);
// 将对象转换成C++字符串
operatorchar* (void) const;
// 重载输出运算符函数
friendostream& operator << (ostream& ostr, const String & s);
intLength(void) const;
}; //类定义完毕

将类的定义在Visual C++环境下编译，并编译通过。

上面给出的类定义，需要配合环境调试通过，比如包含头文件，修改编辑以及编译错误等。

将String类的定义中的构造函数、析构函数实现

1) 实现构造函数 String(char*s);

2) 实现复制构造函数 String(constString & s);

3) 实现析构函数 ~String(void);

#include"iostream.h"
#include"string.h"
#include"conio.h"
#include"stdio.h"
#include"stdlib.h"
class String
{
private:
  char* str;
  int size;
  void Error(int errorType, int badIndex = 0) const; 
public:
  String(char* s);
  String(const String & s); 
  ~String(void);
  String & operator= (const String & s); 
  String & operator= (char * s);
  friend int operator== (char * str, const String & s);
  int operator< (const String & s) const; 
  int operator< (char * str) const;
  friend int operator< (char * str, const String & s);
  int operator> (const String & s) const; 
  int operator> (char * str) const;
  friend int operator> (char * str, const String & s);
  String operator+ (const String & s) const;
  String operator+ (char * str) const;
  friend int operator+ (char * str, const String & s);
  operator char* (void) const;
  friend ostream& operator << (ostream& ostr, const String & s);
  int Length(void) const;
}; 
String::String(char *s)
{
        size = strlen(s) + 1;
        str = new char[size];
        if(str == NULL){
                exit(1);}
                strcpy(str,s);
        cout<<"构造函数被调用"<<endl<<str<<endl;
}
String::String(const String & s)
{
        size = s.size;
        str = new char[size];
        if(str == NULL)exit(1);
        for(int i=0;i<size;i++) str[i]=s.str[i];
        cout<<"复制函数被调用"<<endl<<str<<endl;
}
String::~String(void)
{
        delete []str;
        cout<<"析构函数被调用"<<endl;
}
int main()
{
        String s1("欢迎");
        String s2(s1);
        return 0;
}

将String类的重载赋值运算符函数实现

1) 实现String类的对象赋值String& operator= (const String & s);

2) 实现字符串赋值给对象String &operator= (char * s);

2.2将String类的重载关系运算符函数实现

1) 实现字符串相等判断函数：

intoperator== (char * str, const String & s);

2) 实现调用对象所含的字符串是否小于形参s所含的字符串的判断：

intoperator< (const String & s) const;

3) 实现调用对象所含的字符串是否小于形参字符串str的判断：

intoperator< (char * str) const;

4) 实现调用形参字符串str是否小于形参s所含字符串的判断：

friendint operator< (char * str, const String & s);

5) 实现调用对象所含的字符串是否大于形参s所含的字符串的判断：

intoperator> (const String & s) const;

6) 实现调用对象所含的字符串是否大于形参字符串str的判断：

intoperator> (char * str) const;

7) 实现调用形参字符串str是否大于形参s所含字符串的判断：

friendint operator> (char * str, const String & s);

2.3将String类的重载算术运算符函数实现

8) 实现调用对象和形参对象所含的字符串相加

Stringoperator+ (const String & s) const;

9) 实现调用对象所含的字符串和形参的字符串str相加

Stringoperator+ (char * str) const;

10) 实现形参字符串str和形参s所含的字符串相加

friendint operator+ (char * str, const String & s);

2.4将String类的出错报警函数实现

11) 实现出错报警函数：

voidError(int errorType, int badIndex = 0) const;

出错报警函数能够根据入参传递的错误类型，给出相应的错误告警。

2.5将String类的重载输出运算符函数实现

12) 实现重载输出运算符函数

ostream&operator << (ostream& ostr, const String & s);

完成把s所含的字符串输出到屏幕上。

2.6 实现将字符串转换成String对象

13) 实现将字符串转换成String对象………..

operatorchar* (void) const;

2.7 实现返回对象所含字符串的长度

14) 实现返回对象字符串的长度

intLength(void) const;

2.8 检验字符串对象的连接、计算长度和输出

s1 =string，s2= class

要求完成连接功能，能够计算字符串的长度，编译运行得到输出：

string 和 class 连接成 string class

Length of “string class”= 12

2.9 检验字符串对象的复制、赋值、输出

1) 要求将上面的s1 + s2连接得到的字符串赋值到s4当中；

2) 再将s4的内容后面增加 “in MFC is”；

3) 将s4的内容后面连接上“Cstring class”

4) 将s4的内容输出到屏幕上；

按照要求完成程序，编译运行，得到输出：

string class in MFC is Cstringclass

2.10 检验字符串的比较大小

1) 任意输入两个字符串

2) 将输入的字符串转换成String对象

3) 给出比较大小的结果

#include"iostream.h"
#include"string.h"
#include"conio.h"
#include"stdio.h"
#include"stdlib.h"
class String
{
private:
  char* str;
  int size;
  void Error(int errorType, int badIndex = 0) const; 
public:
  String(char* s);
  String(const String & s); 
  ~String(void);
  String & operator= (const String & s); 
  String & operator= (char * s);
  friend int operator== (char * str, const String & s);
  int operator< (const String & s) const; 
  int operator< (char * str) const;
  friend int operator< (char * str, const String & s);
  int operator> (const String & s) const; 
  int operator> (char * str) const;
  friend int operator> (char * str, const String & s);
  String operator+ (const String & s) const;
  String operator+ (char * str) const;
  friend int operator+ (char * str, const String & s);
  operator char* (void) const;
  friend ostream& operator << (ostream& ostr, const String & s);
  int Length(void) const;
}; 
String & String::operator = (const String &s)
{
        str = s.str;
        size = s.size;
        return *this;
}
String & String::operator =(char *s)
{
        str = s;
        size = strlen(s);
        return *this;
}
int operator == (char *str,const String &s)
{
        if(strcmp(str,s.str))
                return 0;
        else
                return 1;
}
int String::operator < (const String &s)const
{
        if(strcmp(this->str,s.str)<0)
                return 1;
        else
                return 0;
}
int String::operator <(char * str)const
{
        if(strcmp(this->str,str)<0)
                return 1;
        else
                return 0;
}
int operator <(char * str,const String&s)
{
        if(strcmp(str,s.str)<0)
                return 1;
        else
                return 0;
}
int String::operator >(const String &s)const
{
        if(strcmp(this->str,s.str))
                return 1;
        else
                return 0;
}
int String::operator >(char * str)const
{
        if(strcmp(this->str,str))
                return 1;
        else
                return 0;
}
int operator >(char* str,const String &s)
{
        if(strcmp(str,s.str))
                return 1;
        else
                return 0;
}
String String::operator +(const String &s)const
{        
        return (strcat(this->str,s.str));
}
String String::operator +(char * str)const
{
        return (strcat(this->str,str));
}
String operator +(char * str,const String &s)
{
        String sum;
        sum.size = strlen(str) + s.size;
        sum.str = new char[sum.size];
        sum = strcat(str,s.str);
        return(sum);
}
void String::Error(int errorType,int badIndex = 0)const
{
        cout<<"aError!"<<endl;
}
//ostream & operator <<(ostream& ostr,const Strin & s)
//{




String::String(char *s)
{
        size = strlen(s) + 1;
        str = new char[size];
        if(str == NULL){
                exit(1);}
                strcpy(str,s);
        cout<<"构造函数被调用"<<endl<<str<<endl;
}
String::String(const String & s)
{
        size = s.size;
        str = new char[size];
        if(str == NULL)exit(1);
        for(int i=0;i<size;i++) str[i]=s.str[i];
        cout<<"复制函数被调用"<<endl<<str<<endl;
}
String::~String(void)
{
        delete []str;
        cout<<"析构函数被调用"<<endl;
}
int main()
{
        String s1("欢迎");
        String s2(s1);
        return 0;
}

[C++]学习String类的定义和使用（重载）

猜你喜欢