友元运算符重载函数

目录

1.定义友元运算符重载函数的语法形式

2.双目运算符重载

3.单目运算符重载

1.定义友元运算符重载函数的语法形式

        （1）在类的内部，定义友元运算符重载函数的格式如下：

friend 函数类型 operator 运算符（形参表）
{
    函数体
}

        （2） 在类中，声明友元运算符重载函数原型的格式如下：

class X
{
    ...
    firend 函数类型 operator 运算符（形参表）；
    ...
};

        （3） 在类外，定义友元运算符重载函数的格式如下：

函数类型 operator 运算符（形参表）
{
    函数体
}

        若友元运算符重载函数重载的是双目运算符，则参数表中有两个操作数；若重载的是单目运算符，则参数表中只有一个操作数。下面予以介绍。

2.双目运算符重载

        双目运算符有两个操作数，通常在运算符的左右两侧，例如3 + 5,24 > 12 等。下面是用友元运算符重载函数进行复数运算的例子。

#include <iostream>

using namespace std;

class Complex
{
public:
    Complex(double r = 0, double i = 0);
    void print();
    friend Complex operator+(Complex& a, Complex& b); // 声明运算符 + 重载函数
    friend Complex operator-(Complex& a, Complex& b); // 声明运算符 - 重载函数
    friend Complex operator*(Complex& a, Complex& b); // 声明运算符 * 重载函数
    friend Complex operator/(Complex& a, Complex& b); // 声明运算符 / 重载函数
private:
    double real; // 复数实部
    double imag; // 复数虚部
};

Complex::Complex(double r, double i) // 构造函数
{
    real = r;
    imag = i;
}

Complex operator+(Complex& a, Complex& b)
{
    Complex temp;
    temp.real = a.real + b.real;
    temp.imag = a.imag + b.imag;
    return temp;
}

Complex operator-(Complex& a, Complex& b)
{
    Complex temp;
    temp.real = a.real - b.real;
    temp.imag = a.imag - b.imag;
    return temp;
}

Complex operator*(Complex& a, Complex& b)
{
    Complex temp;
    temp.real = a.real * b.real - a.imag * b.imag;
    temp.imag = a.real * b.imag + a.imag * b.real;
    return temp;
}

Complex operator/(Complex& a, Complex& b)
{
    Complex temp;
    double t;
    t = 1 / (b.real * b.real + b.imag * b.imag);
    temp.real = (a.real * b.real + a.imag * b.imag) * t;
    temp.imag = (b.real * a.imag - a.real * b.imag) * t;
    return temp;
}

void Complex::print()
{
    cout << real;
    if (imag > 0)
        cout << "+";
    if (imag != 0)
        cout << imag << 'i' << endl;
}

int main()
{
    Complex A1(2.3, 4.6), A2(3.6, 2.8), A3, A4, A5, A6; // 定义6个Complex类的对象
    A3 = A1 + A2; // 复数相加
    A4 = A1 - A2; // 复数相减
    A5 = A1 * A2; // 复数相乘
    A6 = A1 / A2; // 复数相除

    A1.print(); // 输出复数A1
    A2.print(); // 输出复数A2
    A3.print(); // 输出复数相加结果A3
    A4.print(); // 输出复数相减结果A4
    A5.print(); // 输出复数相乘结果A5
    A6.print(); // 输出复数相除结果A6

    return 0;
}

        程序运行结果如下：

3.单目运算符重载

        单目运算符只有一个操作数，如-a, &b, !c, ++p等。

        以下是用友元函数重载单目运算符“-”。

#include <iostream>

using namespace std;

class Coord
{
public:
    Coord(int x1 = 0, int y1 = 0)
    {
        x = x1;
        y = y1;
    }
    friend Coord operator-(Coord &obj); // 声明单目运算符 - 重载函数
    void print();
private:
    int x, y;
};

Coord operator-(Coord &obj) // 定义单目运算符 - 重载函数
{
    obj.x = -obj.x;
    obj.y = -obj.y;
    return obj;
}

void Coord::print()
{
    cout << "x = " << x << ", y = " << y << endl;
}

int main()
{
    Coord ob1(50, 60), ob2;
    ob1.print();
    ob2 = - ob1;
    ob2.print();
    return 0;
}

        程序结果如下：

        用友元函数重载单目运算符“++”。

#include <iostream>

using namespace std;

class Coord
{
public:
    Coord(int i = 0, int j = 0)
    {
        x = i;
        y = j;
    }
    friend Coord operator++(Coord &op) // 定义单目运算符 ++ 重载函数
    {                                  // 采用对象引用作为函数参数
        ++op.x;
        ++op.y;
        return op;
    }
    void print()
    {
        cout << "x = " << x << ", y = " << y << endl;
    }
private:
    int x, y;
};


int main()
{
    Coord ob(10, 20);
    ob.print();
    ++ob;
    ob.print();
    return 0;
}

        程序结果如下：