博客

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解

  • Post category:other

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解的完整攻略

在C++中，运算符重载是一种强大的特性，它允许我们重新定义运算符的行为。C++中有三种形式的运算符重载：成员函数、友元函数和普通函数。以下是这三种形式的详细攻略。

成员函数

成员函数是定义在类中的函数，它们可以访问类的私有成员。成员函数的一种形式是运算符重载。以下是成员函数运算符重载的步骤：

  1. 在类中声明运算符函数。运算符函数的名称是运算符符号，例如“+”、“-”、“*”、“/”等。

  2. 在类外部定义运算符函数。运算符函数必须是类的成员函数。

  3. 在运算符函数中实现运算符的重载。

以下是一个示例，展示如何使用成员函数重载运算符“+”：

class Complex {
public:
    Complex operator+(const Complex& other) const {
        Complex result;
        result.real = real + other.real;
        result.imag = imag + other.imag;
        return result;
    }
private:
    double real;
    double imag;
};

在这个示例中，我们定义了一个名为“operator+”的成员函数，它接受一个类型为“Complex”的参数，并返回一个类型为“Complex”的值。在函数中，我们将两个复数的实部和虚部相加，并返回一个新的复数。

友元函数

友元函数是定义在类外部的函数，它们可以访问类的私有成员。友元函数的一种形式是运算符重载。以下是友元函数运算符重载的步骤：

  1. 在类中声明运算符函数。运算符函数的名称是运算符符号，例如“+”、“-”、“*”、“/”等。

  2. 在类外部定义运算符函数。运算符函数必须是友元函数。

  3. 在运算符函数中实现运算符的重载。

以下是一个示例，展示如何使用友元函数重载运算符“+”：

class Complex {
public:
    friend Complex operator+(const Complex& a, const Complex& b) {
        Complex result;
        result.real = a.real + b.real;
        result.imag = a.imag + b.imag;
        return result;
    }
private:
    double real;
    double imag;
};

在这个示例中，我们定义了一个名为“operator+”的友元函数，它接受两个类型为“Complex”的参数，并返回一个类型为“Complex”的值。在函数中，我们将两个复数的实部和虚部相加，并返回一个新的复数。

普通函数

普通函数是定义在类外部的函数，它们不能访问类的私有成员。普通函数的一种形式是运算符重载。以下是普通函数运算符重载的步骤：

  1. 在类外部声明运算符函数。运算符函数的名称是运算符符号，例如“+”、“-”、“*”、“/”等。

  2. 在类外部定义运算符函数。

  3. 在运算符函数中实现运算符的重载。

以下是一个示例，展示如何使用普通函数重载运算符“+”：

class Complex {
public:
    double real;
    double imag;
};

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

在这个示例中，我们定义了一个名为“operator+”的普通函数，它接受两个类型为“Complex”的参数，并返回一个类型为“Complex”的值。在函数中，我们将两个复数的实部和虚部相加，并返回一个新的复数。

示例说明

以下是两个示例，展示如何使用运算符重载：

示例1：使用成员函数重载运算符“+”

#include <iostream>

class Complex {
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
    Complex operator+(const Complex& other) const {
        Complex result;
        result.real = real + other.real;
        result.imag = imag + other.imag;
        return result;
    }
    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
private:
    double real;
    double imag;
};

int main() {
    Complex a(1.0, 2.0);
    Complex b(3.0, 4.0);
    Complex c = a + b;
    c.print();
    return 0;
}

在这个示例中，我们定义了一个名为“Complex”的类，它有一个成员函数“operator+”，用于重载运算符“+”。我们创建了两个复数a和b，并将它们相加，然后将结果存储在c中。最后，我们调用c的print函数，以显示结果。

示例2：使用友元函数重载运算符“+”

#include <iostream>

class Complex {
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
    friend Complex operator+(const Complex& a, const Complex& b) {
        Complex result;
        result.real = a.real + b.real;
        result.imag = a.imag + b.imag;
        return result;
    }
    void print() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
private:
    double real;
    double imag;
};

int main() {
    Complex a(1.0, 2.0);
    Complex b(3.0, 4.0);
    Complex c = a + b;
    c.print();
    return 0;
}

在这个示例中，我们定义了一个名为“Complex”的类，它有一个友元函数“operator+”，用于重载运算符“+”。我们创建了两个复数a和b，并将它们相加，然后将结果存储在c中。最后，我们调用c的print函数，以显示结果。

结论

C++中的运算符重载是一种强大的特性，它允许我们重新定义运算符的行为。C++中有三种形式的运算符重载：成员函数、友元函数和普通函数。在使用运算符重载时，请确保您了解每种形式的用法，并正确实现运算符的重载。

Tags: