实验4 运算符重载

1、实验目的和要求

（1）掌握运算符重载的语法要点，理解成员函数与友元函数重载运算符的区别。

（2）掌握各种运算符的重载方法，理解引用形式作为参数和返回值的特点。

2、实验内容

（1）定义描述平面点类Point，重载减号运算符计算两个点的距离，分别用成员函数与友元函数实现。重载运算符<<输出点的坐标[x,y]，给出类以及相关函数的定义。

#include 
#include 
using namespace std;
class Point
{
public:
    Point(int a= 0, int b = 0):x(a),y(b) {}
    void setPoint(int a, int b)
    {
        x=a;
        y=b;
    }
    double operator -(const Point& p);
    friend double operator -(Point& p1,Point& p2);
    friend ostream& operator <<(ostream& out,const Point& p);// "<<"只能重载为友元函数
private:
    int x, y;	// 平面坐标
};
double Point::operator -(const Point& p)
{
    return sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));
}
double operator -(Point& p1,Point& p2)
{
    return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
}
ostream& operator <<(ostream& out,const Point& p)
{
    cout<<"["<"<[0,0]=2.23
    return 0;
}

（2） 描述有理数的Rational类如下，请补充类的其他成员使其能够执行各种运算。

Class Rational

{

   long  numerator ; // 分子

   long  denominator ; // 分母

........

};

1）重载算术运算符“＋”、“-”、“*”、“/”，使之能够适用于有理数的四则运算。

2）重载比较运算符“>”、“ <=” 和“==”，使之能够比较两个有理数。

3）重载运算符“<<”，使其能以规范的方式输出分数，如1/2，-1/3，分母不能为0。

#include
#include
using namespace std;
class Rational
{
public:
    Rational(int n=1,int d=1);
    Rational operator +(const Rational &a);//重载加减乘除
    Rational operator -(const Rational &a);
    Rational operator *(const Rational &a);
    Rational operator /(const Rational &a);
    bool operator <(const Rational &a)const;
    bool operator >(const Rational &a)const;
    bool operator ==(const Rational &a)const;
    friend ostream& operator << (ostream& out,const Rational &a);
    void simple();//化简函数
private:
    int  numerator ;  // 分子
    int  denominator ; // 分母
};
Rational::Rational(int n,int d):numerator(n),denominator(d) {}
Rational Rational::operator +(const Rational &a)
{
    Rational temp;
    temp.numerator=this->numerator*a.denominator+a.numerator*this->denominator;
    temp.denominator=this->denominator*a.denominator;
    temp.simple();
    return temp;
}
Rational Rational::operator-(const Rational &a)
{
    Rational temp;
    temp.numerator=this->numerator*a.denominator-this->denominator*a.numerator;
    temp.denominator=this->denominator*a.denominator;
    temp.simple();
    return temp;
}
Rational Rational::operator*(const Rational &a)
{
    Rational temp;
    temp.numerator=this->numerator*a.numerator;
    temp.denominator=this->denominator*a.denominator;
    temp.simple();
    return temp;
}
Rational Rational::operator/(const Rational &a)
{
    Rational temp;
    temp.numerator=this->numerator*a.denominator;
    temp.denominator=this->denominator*a.numerator;
    temp.simple();
    return temp;
}
bool Rational::operator <(const Rational &a)const
{
    if(this->numerator*a.denominatordenominator*a.numerator)return true;
    else return false;
}
bool Rational::operator >(const Rational &a)const
{
    if(this->numerator*a.denominator>this->denominator*a.numerator)return true;
    else return false;
}
bool Rational::operator ==(const Rational &a)const
{
    if(this->numerator*a.denominator==this->denominator*a.numerator)return true;
    else return false;
}
ostream& operator<<(ostream& out,const Rational &a)
{
    if(a.denominator!=0)out<b"<

（3）定义一个集合类Set，最多存放100个不重复的整数，实现集合的如下操作：

1）增加某个整型元素时，保证集合中没有重复元素；删除指定的元素，查找该元素在集合中则从集合中删除该元素；

2）重载运算符“+”，实现两个集合对象的合并操作，重载运算符“*”，求两个集合对象的交集；例如Set s, s1, s2; s =s1+s2; s = s1* s2;

3）重载赋值运算符=和复合赋值运算符-= ， 实现两个集合对象的赋值操作与差集操作。例如Set s1，s2；s1 = s2;   s1-=s2; 集合S1中去掉S2中存在的元素。

#include
#include
using namespace std;
class Set
{
public:
    Set(int p_size = 1);
    Set(const Set& p_Set);
    ~Set();
    int getLength()
    {
        return length ;
    }
    void addItem(int p_item);
    void delItem(int p_item);
    Set operator + (Set& p_set);
    Set operator * (Set& p_set);
    Set& operator = (const Set& p_set);
    Set& operator -= (Set& p_set);
    friend ostream& operator << (ostream& x , Set& p_set);
    int operator [](int index) const;
private:
    int size;
    int length;
    int* data;
};
Set::Set(int p_size)
{
    size = (p_size <= 0) ? 1 : ((p_size > 100) ? 100 : p_size);
    data=new int[ size ];
    length=0;
    memset(data,0,sizeof(data));
}
Set::Set(const Set &p_Set)
{
    size = p_Set.size;
    length = p_Set.length;
    data = new int[size];
    for(int i = 0 ; i < length ; i ++)
        data[i] = p_Set[i];
}
Set::~Set()
{
    if(data)
        delete []data;
    size = 0;
    length = 0;
}
int Set::operator [](int index) const
{
    return data[(index < 0) ? 0 : ((index >= length) ? length - 1 : index) ];
}
void Set::addItem(int p_item)
{
    if(size == 100)
    {
        cout << "集合已满！" << endl;
        return;
    }
    if(length == size && size < 100)
    {
        size = ((size + 20) > 100) ? 100 : (size + 20);
        int* temp = new int[size];
        for(int i = 0 ; i < length ; i ++)
            temp[i] = data[i];
        if(data)
            delete []data;
        data = temp;
    }
    for(int i = 0 ; i < length ; i ++)
    {
        if(p_item == data[i])
        {
            cout << "该元素已存在！" << endl;
            return;
        }
    }
    data[ length ] = p_item;
    length ++;
}
;
void Set::delItem(int p_item)
{
    for(int i = 0 ; i < length ; i ++)
    {
        if(p_item == data[i])
        {
            if(i < length - 1)
                for(int j = i ; j < length - 1 ; j ++)
                    data[j] = data[j +1];
            length --;
        }
    }
}
Set Set::operator +(Set &p_set)
{
    Set s(*this);
    int flag ;
    for(int i = 0 ; i < p_set.length ; i ++)
    {
        flag = 1;
        for(int j = 0 ; j < s.length ; j ++)
            if(s[j] == p_set[i])
            {
                flag = 0;
                break;
            }
        if(flag)
            s.addItem(p_set[i]);
    }
    return s;
}
Set Set::operator * (Set &p_set)
{
    Set s(50);
    for(int i = 0 ; i < p_set.length ; i ++)
    {
        for(int j = 0 ; j < length ; j ++)
            if(data[j] == p_set[i])
            {
                s.addItem(data[j]);
            }
    }
    return s;
}
Set& Set::operator = (const Set &p_set)
{
    size = p_set.size;
    length = p_set.length;
    if(data)
        delete []data;
    data = new int[size];
    for(int i = 0 ; i < length ; i ++)
        data[i] = p_set[i];
    return *this;
}
Set& Set::operator -=(Set &p_set)
{
    for(int i = 0 ; i < p_set.length ; i ++)
    {
        for(int j = 0 ; j < length ; j ++)
            if(data[j] == p_set[i])
            {
                this->delItem(data[j]);
            }
    }
    return *this;
}
ostream& operator << (ostream& out , Set &p_set)
{
    for(int i = 0 ; i < p_set.length ; i ++)
        out << p_set[i] << ' ';
    return out;
}

int main()
{
    Set s1(5),s2(4),s3;
    for(int i = 0 ; i < 5 ; i ++)
        s1.addItem(i + 1);
    s1.addItem(5);
    cout << s1 << endl;
    for(int i = 1 ; i <= 4 ; i ++)
        s2.addItem(i * 2);
    cout<

（4）定义描述时间的Time类，包括数据成员小时hour、分钟minute和秒second，定义相关函数实现如下操作：

1）重载运算符“+”与“-”，能够实现时间对象与整数秒的加减操作。

2）重载运算符“<<”输出时间对象，能够按照“小时：分钟：秒”的方式显示时间。

3）重载运算符“++”与“--”，要求能够实现时间的合理自增自减功能(秒数的增减)。

 

（5）设计字符串类String，若有String类对象s1、s2和s3，重载运算符实现如下操作：

1）重载“＋”实现字符串连接功能，使表达式s1= s2+s3成立；

2）重载“<”判断两个字符串的大小，如 if(s1 < s2)cout<

3）重载“<<”与“>>”，实现字符串的输入与输出操作，如cin>>s2;cout<

4）重载运算符“()”，从字符串对象中返回一个子串。如s1(2,4)表示返回从子串，即从s[2](s1第3个字符)开始的子串(包括s1[2]、s1[3]和s1[4]三个字符)。  

（6）【选作】开发多项式类Polynomial，多项式的每一项用数组或结构体表示，每项包含一个系数和一个指数。例如2x⁴的指数为4，系数为2。请开发一个完整的Polynomial类，包括构造函数、析构函数以及get函数和set函数。该类还要提供下述重载的运算符：

1）重载运算符“+”和“-”，将两个多项式相加或相减。

2）重载乘法运算符“*”，将两个多项式相乘。

3）重载赋值运算符“=”，将一个多项式赋给另外一个多项式。