C++友元函数：解放私有成员的访问限制

一、友元函数的概念

在C++中，一个类可以将其一些私有成员赋予其它的类或者函数访问权限，称为友元函数。

class A {
private:
    int x;
    void sayHi() {
        std::cout << "Hi, I'm A." << std::endl;
    }
    friend void B::print(A a);
};

class B {
public:
    void print(A a) {
        std::cout << a.x << std::endl; // a.x可以访问，因为B是A的友元类
        a.sayHi(); // a.sayHi()可以访问，因为B是A::sayHi()的友元函数
    }
};

在上面的代码中，A将print函数声明为友元函数，使其可以访问A的私有成员x和sayHi函数。在B的print函数中，也可以调用A的sayHi函数。

二、友元函数的作用

友元函数可以解决某些场景下的访问限制问题。

三、友元函数与运算符重载

另一个常见的友元函数使用场景是运算符重载。在运算符重载中，为了让函数能够访问类的私有数据成员，需要将这个函数声明为类的友元函数。

class Rational {
public:
    Rational(int a = 0, int b = 1) : num(a), den(b) {}
    friend Rational operator+(Rational r1, Rational r2) {
        return Rational(r1.num * r2.den + r2.num * r1.den, r1.den * r2.den);
    }
private:
    int num;
    int den;
};

在上面的代码中，将operator+函数声明为Rational的友元函数，使其可以访问Rational的私有成员num和den。这样，+运算符才能正确地计算两个有理数的和。

四、友元类

除了友元函数，C++还有另一个友元概念：友元类。友元类是指在类中声明另一个类为友元，使其能够访问当前类的私有成员。

class A {
friend class B;
private:
    int x;
};
class B {
public:
    void print(A a) {
        std::cout << a.x << std::endl; // 可以访问A的私有成员x
    }
};

在上面的代码中，A将B声明为友元类，使其能够访问A的私有成员x。

五、友元函数的缺点

尽管友元函数有一些好处，但过度使用友元函数会破坏类的封装性，使类中的私有成员变得透明，降低代码的可维护性和可复用性。

六、友元类与继承

当类B是类A的友元类时，B可以访问A的私有成员。如果类C继承类A，且将B声明为其友元类，那么B也可以访问C的私有成员。

class A {
friend class B;
private:
    int x;
};
class C : public A {
friend class B;
private:
    int y;
};
class B {
public:
    void print(A a) {
        std::cout << a.x << std::endl; // 可以访问A的私有成员x
    }
    void print(C c) {
        std::cout << c.x << " " << c.y << std::endl; // 可以访问C的私有成员x和y
    }
};

七、友元函数的例子：矩阵乘法

友元函数的另一个常见使用场景是在矩阵类中实现矩阵乘法。在矩阵乘法中，需要访问另一个矩阵的私有成员，因此需要将矩阵乘法函数声明为矩阵类的友元函数。

class Matrix {
public:
    Matrix(int r = 0, int c = 0) : rows(r), cols(c) {
        data = new int[rows * cols];
    }
    Matrix(const Matrix& m) : rows(m.rows), cols(m.cols) {
        data = new int[rows * cols];
        std::copy(m.data, m.data + rows * cols, data);
    }
    ~Matrix() {
        delete[] data;
    }
    friend Matrix operator*(const Matrix& m1, const Matrix& m2) {
        assert(m1.cols == m2.rows);
        Matrix res(m1.rows, m2.cols);
        for (int i = 0; i < m1.rows; ++i) {
            for (int j = 0; j < m2.cols; ++j) {
                int sum = 0;
                for (int k = 0; k < m1.cols; ++k) {
                    sum += m1.data[i * m1.cols + k] * m2.data[k * m2.cols + j];
                }
                res.data[i * res.cols + j] = sum;
            }
        }
        return res;
    }
private:
    int rows;
    int cols;
    int* data;
};

在上面的代码中，将operator*函数声明为Matrix的友元函数，使其可以访问另一个矩阵的私有成员。