面向对象编程练习题（C++）

编写一个程序，定义长方形类，构造函数、拷贝构造、赋值构造、获取面积、获取IOU面积、获取交集面积、并集面积、面积大小比较、是否为同一长方形比较、自定义cout << 打印函数。

代码：

#include 
using namespace std;

class Rectangular
{
public:
    Rectangular(double l=0, double t=0, double w=0, double h=0)
    {
        if (w < 0 || h < 0)
        {
            cout << "width or height cannot be negative" << endl;
        }
        else
        {
            left = l;
            top = t;
            width = w;
            height = h;
            area = width*height;
        }
    }

    // 拷贝构造
    Rectangular(const Rectangular& r)
    {
        left = r.left;
        top = r.top;
        width = r.width;
        height = r.height;
        area = r.area;
    }

    // 赋值构造
    Rectangular operator = (Rectangular r)
    {
        this->left = r.left;
        this->top = r.top;
        this->width = r.width;
        this->height = r.height;
        this->area = r.area;
    }

    double get_area()
    {
        return area;
    }

    double get_iou_area(Rectangular r)
    {
        double iou_left = max(left, r.left);
        double iou_top = max(top, r.top);
        double iou_right = min(left + width, r.left + r.width);
        double iou_bottom = min(top + height, r.top + r.height);

        if (iou_left >= iou_right || iou_top >= iou_bottom)
        {
            return 0;
        }
        else
        {
            return (iou_right - iou_left) * (iou_bottom - iou_top);
        }
    }

    double operator + (Rectangular r)
    {
        double iou_area = this->get_iou_area(r);
        return this->area + r.area - iou_area;
    }

    double operator - (Rectangular r)
    {
        double iou_area = this->get_iou_area(r);
        return this->area - iou_area;
    }

    bool operator > (Rectangular r)
    {
        return this->area > r.area;
    }

    bool operator < (Rectangular r)
    {
        return this->area < r.area;
    }

    bool operator == (Rectangular r)
    {
        return this->left == r.left &&
               this->top == r.top &&
               this->width == r.width &&
               this->height == r.height;
    }

    // how about "<=" when there is no defination:  error no match for operator<=
    bool operator <= (Rectangular r)
    {
        return this->operator <(r) or this->area == r.area;
    }

    bool operator >= (Rectangular r)
    {
        return this->operator >(r) or this->area == r.area;
    }

private:
    double left;
    double top;
    double width;
    double height;
    double area;

    // 二元运算符重载，左运算数不为该类型，需要定义friend友元函数，并在类外定义函数
    friend ostream& operator << (ostream& obj, const Rectangular& r);
};

ostream& operator << (ostream& obj, const Rectangular& r)
{
    return obj << "left = " << r.left << endl
               << "top = " << r.top << endl
               << "width = " << r.width << endl
               << "height = " << r.height << endl
               << "area = " << r.area << endl;
}


int main(int argc, char *argv[])
{
    Rectangular a(0, 0, 10, 20);
    Rectangular b(0, 0, 20, 10);
    Rectangular c(0, 0, 20, 11);

    Rectangular b2(b);

    cout << "a information: " << endl;
    cout << a << endl;

    cout << "b information: " << endl;
    cout << b << endl;

    cout << "b2 information: " << endl;
    cout << b2 << endl;

    cout << "c information: " << endl;
    cout << c << endl;

    cout << "a == b : " << (a == b) << endl;
    cout << "b == b2 : " << (b == b2) << endl;

    cout << "b > b2 : " << (b > b2) << endl;
    cout << "b >= b2 : " << (b >= b2) << endl;
    cout << "a < c : " << (a < c) << endl;

    cout << "a - b : " << a - b << endl;
    cout << "a - c : " << a - c << endl;

    cout << "a + b : " << a + b << endl;
    cout << "a + c : " << a + c << endl;

    return 0;
}

 

运行结果

 

 

为什么operator<< 运算符重载一定要为友元函数

如果是重载双目操作符（即为类的成员函数），就只要设置一个参数作为右侧运算量，而左侧运算量就是对象本身。。。。。。

而 >>  或<< 左侧运算量是 cin或cout 而不是对象本身，所以不满足后面一点。。。。。。。。就只能申明为友元函数了。。。

如果一定要声明为成员函数，只能成为如下的形式：

ostream & operator<<(ostream &output)

{

　　return output;

}

所以在运用这个<<运算符时就变为这种形式了：data<

不合符人的习惯。

友元函数

友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend。

友元类

友元除了前面讲过的函数以外，友元还可以是类，即一个类可以作另一个类的友元。当一个类作为另一个类的友元时，这就意味着这个类的所有成员函数都是另一个类的友元函数。

例如，以下语句说明类B是类A的友元类：

class A

{

…

public:

friend class B;

…

};

经过以上说明后，类B的所有成员函数都是类A的友元函数，能存取类A的私有成员和保护成员。

使用友元类时注意：

(1) 友元关系不能被继承。

(2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。

(3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明