qt中如何将 两个类设置成友缘类

在Qt中，要让两个类成为“友元”类（也称为友好访问），你需要在其中一个类的头文件中声明另一个类为友元，然后在需要访问对方私有成员的类中包含那个头文件。以下是步骤：

1. 首先，在想要访问另一个类私有成员的那个类（被称为友元接收者）的头文件中，添加对该类（友元提供者）的`friend`关键字声明。例如：

   // 友元接收者的头文件 (example_receiver.h)
   class ExampleProvider;
   class ExampleReceiver {
   public:
       // ...
   private:
       friend class ExampleProvider; // 声明ExampleProvider为友元
       // ...
   };

2. 然后，在友元提供者的类（即希望访问友元接收者私有成员的类）的头文件中，不需要做任何额外操作。

3. 如果你还想在源文件中访问友元，只需在源文件中包含相应的头文件即可。但是通常来说，友元关系仅限于必要的场景，如为了实现某种特定的操作或在内部库函数中。

注意，过多的友元关系可能导致代码复杂性和潜在的安全风险，因此应谨慎使用。

相关问题

创建一个复数类，通过这个类的友缘函数求解两个复数的和

下面是一个简单的复数类的实现，其中包括一个友元函数来计算两个复数的和：

#include <iostream>
using namespace std;

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
    void print() { cout << real << " + " << imag << "i" << endl; }
    friend Complex add(Complex c1, Complex c2);
};

Complex add(Complex c1, Complex c2) {
    Complex res(c1.real + c2.real, c1.imag + c2.imag);
    return res;
}

int main() {
    Complex c1(1, 2), c2(3, 4);
    Complex sum = add(c1, c2);
    sum.print();
    return 0;
}

在上面的代码中，我们定义了一个Complex类，其中包括一个实部和一个虚部。我们还定义了一个友元函数add，该函数接受两个Complex对象作为参数，并返回它们的和。在main函数中，我们创建两个Complex对象，然后使用add函数计算它们的和，并输出结果。

输出为：

4 + 6i

生成一个分数类并计算 使用函数重载和友缘

以下是一个使用函数重载和友元的分数类的示例：

#include <iostream>

class Fraction {
private:
    int numerator;
    int denominator;

public:
    Fraction(int n = 0, int d = 1) : numerator(n), denominator(d) {}

    friend std::ostream& operator<<(std::ostream& os, const Fraction& f) {
        os << f.numerator << "/" << f.denominator;
        return os;
    }

    friend Fraction operator+(const Fraction& f1, const Fraction& f2) {
        int n = f1.numerator * f2.denominator + f2.numerator * f1.denominator;
        int d = f1.denominator * f2.denominator;
        return Fraction(n, d);
    }

    friend Fraction operator-(const Fraction& f1, const Fraction& f2) {
        int n = f1.numerator * f2.denominator - f2.numerator * f1.denominator;
        int d = f1.denominator * f2.denominator;
        return Fraction(n, d);
    }

    friend Fraction operator*(const Fraction& f1, const Fraction& f2) {
        int n = f1.numerator * f2.numerator;
        int d = f1.denominator * f2.denominator;
        return Fraction(n, d);
    }

    friend Fraction operator/(const Fraction& f1, const Fraction& f2) {
        int n = f1.numerator * f2.denominator;
        int d = f1.denominator * f2.numerator;
        return Fraction(n, d);
    }

    friend bool operator==(const Fraction& f1, const Fraction& f2) {
        return f1.numerator * f2.denominator == f2.numerator * f1.denominator;
    }

    friend bool operator!=(const Fraction& f1, const Fraction& f2) {
        return !(f1 == f2);
    }

    friend bool operator<(const Fraction& f1, const Fraction& f2) {
        return f1.numerator * f2.denominator < f2.numerator * f1.denominator;
    }

    friend bool operator<=(const Fraction& f1, const Fraction& f2) {
        return (f1 < f2) || (f1 == f2);
    }

    friend bool operator>(const Fraction& f1, const Fraction& f2) {
        return !(f1 <= f2);
    }

    friend bool operator>=(const Fraction& f1, const Fraction& f2) {
        return !(f1 < f2);
    }
};

int main() {
    Fraction f1(1, 2);
    Fraction f2(3, 4);

    std::cout << "f1 = " << f1 << std::endl;
    std::cout << "f2 = " << f2 << std::endl;

    Fraction f3 = f1 + f2;
    std::cout << "f1 + f2 = " << f3 << std::endl;

    Fraction f4 = f1 - f2;
    std::cout << "f1 - f2 = " << f4 << std::endl;

    Fraction f5 = f1 * f2;
    std::cout << "f1 * f2 = " << f5 << std::endl;

    Fraction f6 = f1 / f2;
    std::cout << "f1 / f2 = " << f6 << std::endl;

    bool isEqual = f1 == f2;
    std::cout << "f1 == f2 is " << (isEqual ? "true" : "false") << std::endl;

    bool isNotEqual = f1 != f2;
    std::cout << "f1 != f2 is " << (isNotEqual ? "true" : "false") << std::endl;

    bool isLessThan = f1 < f2;
    std::cout << "f1 < f2 is " << (isLessThan ? "true" : "false") << std::endl;

    bool isLessThanOrEqual = f1 <= f2;
    std::cout << "f1 <= f2 is " << (isLessThanOrEqual ? "true" : "false") << std::endl;

    bool isGreaterThan = f1 > f2;
    std::cout << "f1 > f2 is " << (isGreaterThan ? "true" : "false") << std::endl;

    bool isGreaterThanOrEqual = f1 >= f2;
    std::cout << "f1 >= f2 is " << (isGreaterThanOrEqual ? "true" : "false") << std::endl;

    return 0;
}

这个示例中，分数类 `Fraction` 重载了一系列运算符，包括加、减、乘、除、相等、不相等、小于、小于等于、大于和大于等于运算符。所有运算符都是友元函数，它们都使用了 C++ 的函数重载机制。在 `main()` 函数中，我们创建了两个分数对象 `f1` 和 `f2`，并演示了这些运算符的使用。