跳到主要内容

C++ 友元函数

什么是友元函数？​

在C++面向对象编程中，我们通常会使用访问修饰符（如public、private和protected）来限制对类成员的访问。然而，有时我们需要让某些特定的外部函数访问类的私有成员，这时就可以使用友元函数。

友元函数是定义在类外部，但有权访问类的所有成员（包括私有成员和保护成员）的非成员函数。简单来说，友元函数是一个类授予特殊访问权限的外部函数。

备注

友元关系不是相互的：如果类A声明类B是它的友元，类B不会自动成为类A的友元。

为什么需要友元函数？​

你可能会问，为什么我们需要友元函数，而不是简单地将私有成员设为公有？主要原因如下：

  1. 数据封装和安全性 - 仅向特定函数开放访问权限，而不是完全公开
  2. 提高代码灵活性 - 允许非成员函数访问私有数据，同时保持封装性
  3. 运算符重载 - 常用于需要访问类私有成员的运算符重载函数

友元函数的声明与定义​

基本语法​

cpp
class ClassName {
    // 声明友元函数
    friend returnType functionName(parameters);
    
private:
    // 私有成员
};

// 友元函数的定义（在类外部）
returnType functionName(parameters) {
    // 可以访问ClassName的私有成员
}

简单示例​

让我们通过一个简单的例子来理解友元函数：

cpp
#include <iostream>
using namespace std;

class Box {
private:
    int length;
    int width;
    int height;
    
public:
    // 构造函数
    Box(int l = 0, int w = 0, int h = 0) {
        length = l;
        width = w;
        height = h;
    }
    
    // 声明友元函数
    friend int getBoxVolume(Box box);
};

// 友元函数定义
int getBoxVolume(Box box) {
    // 可以直接访问私有成员
    return box.length * box.width * box.height;
}

int main() {
    Box myBox(3, 4, 5);
    
    // 调用友元函数
    cout << "盒子的体积是: " << getBoxVolume(myBox) << endl;
    
    return 0;
}

输出结果：

盒子的体积是: 60

在上面的例子中，getBoxVolume()是Box类的友元函数，尽管它不是类的成员函数，但它可以访问类的私有数据成员length、width和height。

友元函数的特点​

  1. 友元函数不是类的成员函数
  2. 友元函数可以在类的任何部分声明（public、private或protected区域）
  3. 友元函数不能使用类对象的成员选择运算符（.或->）直接访问对象的成员
  4. 友元函数没有this指针
  5. 友元关系不能被继承

不同类型的友元​

全局友元函数​

上面例子中的getBoxVolume()就是一个全局友元函数。

另一个类的成员函数作为友元​

cpp
#include <iostream>
using namespace std;

// 前向声明
class ClassB;

class ClassA {
public:
    void display(ClassB& b);
};

class ClassB {
private:
    int value;
    
public:
    ClassB() : value(5) {}
    
    // 声明ClassA的成员函数为友元
    friend void ClassA::display(ClassB& b);
};

void ClassA::display(ClassB& b) {
    cout << "ClassB的值是: " << b.value << endl;
}

int main() {
    ClassA a;
    ClassB b;
    
    a.display(b);
    
    return 0;
}

输出结果：

ClassB的值是: 5

整个类作为友元​

cpp
#include <iostream>
using namespace std;

class ClassA {
private:
    int valueA;
    
public:
    ClassA() : valueA(10) {}
    
    friend class ClassB; // 声明整个ClassB为友元
};

class ClassB {
public:
    void display(ClassA& a) {
        // 可以访问ClassA的私有成员
        cout << "ClassA的值是: " << a.valueA << endl;
    }
};

int main() {
    ClassA a;
    ClassB b;
    
    b.display(a);
    
    return 0;
}

输出结果：

ClassA的值是: 10

友元函数与运算符重载​

友元函数在运算符重载中特别有用，尤其是当需要访问运算符两侧对象的私有成员时。

以下是一个使用友元函数重载+运算符的例子：

cpp
#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 display() const {
        cout << real << " + " << imag << "i" << endl;
    }
    
    // 声明运算符重载为友元函数
    friend Complex operator+(const Complex& c1, const Complex& c2);
};

// 运算符重载定义
Complex operator+(const Complex& c1, const Complex& c2) {
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}

int main() {
    Complex c1(3, 4);
    Complex c2(5, 6);
    
    Complex c3 = c1 + c2; // 使用重载的+运算符
    
    cout << "c1 = ";
    c1.display();
    
    cout << "c2 = ";
    c2.display();
    
    cout << "c1 + c2 = ";
    c3.display();
    
    return 0;
}

输出结果：

c1 = 3 + 4i
c2 = 5 + 6i
c1 + c2 = 8 + 10i

实际应用场景​

1. 数据流操作​

友元函数常用于重载流操作符（<<和>>），允许自定义对象的输入输出：

cpp
#include <iostream>
#include <string>
using namespace std;

class Person {
private:
    string name;
    int age;
    
public:
    Person(const string& n = "", int a = 0) : name(n), age(a) {}
    
    // 声明流操作符重载为友元
    friend ostream& operator<<(ostream& os, const Person& p);
    friend istream& operator>>(istream& is, Person& p);
};

// 输出流运算符重载
ostream& operator<<(ostream& os, const Person& p) {
    os << "姓名: " << p.name << ", 年龄: " << p.age;
    return os;
}

// 输入流运算符重载
istream& operator>>(istream& is, Person& p) {
    cout << "请输入姓名: ";
    is >> p.name;
    cout << "请输入年龄: ";
    is >> p.age;
    return is;
}

int main() {
    Person person;
    
    // 使用重载的>>运算符
    cin >> person;
    
    // 使用重载的<<运算符
    cout << "您创建了一个人: " << person << endl;
    
    return 0;
}

2. 比较和转换操作​

当需要比较两个不同类的对象或者在类之间进行转换时，友元函数也非常有用：

cpp
#include <iostream>
using namespace std;

class Celsius; // 前向声明

class Fahrenheit {
private:
    double temperature;
    
public:
    Fahrenheit(double temp = 0) : temperature(temp) {}
    
    // 显示温度
    void display() const {
        cout << temperature << "°F" << endl;
    }
    
    // 声明转换函数为友元
    friend Fahrenheit toCelsius(const Celsius& c);
};

class Celsius {
private:
    double temperature;
    
public:
    Celsius(double temp = 0) : temperature(temp) {}
    
    // 显示温度
    void display() const {
        cout << temperature << "°C" << endl;
    }
    
    // 声明转换函数为友元
    friend Celsius toFahrenheit(const Fahrenheit& f);
    friend Fahrenheit toCelsius(const Celsius& c);
};

// 将摄氏度转换为华氏度
Celsius toFahrenheit(const Fahrenheit& f) {
    double celsius = (f.temperature - 32) * 5 / 9;
    return Celsius(celsius);
}

// 将华氏度转换为摄氏度
Fahrenheit toCelsius(const Celsius& c) {
    double fahrenheit = c.temperature * 9 / 5 + 32;
    return Fahrenheit(fahrenheit);
}

int main() {
    Celsius c(25);
    cout << "摄氏温度: ";
    c.display();
    
    Fahrenheit f = toCelsius(c);
    cout << "对应的华氏温度: ";
    f.display();
    
    Celsius c2 = toFahrenheit(f);
    cout << "转换回摄氏温度: ";
    c2.display();
    
    return 0;
}

输出结果：

摄氏温度: 25°C
对应的华氏温度: 77°F
转换回摄氏温度: 25°C

友元函数的优缺点​

优点​

  1. 提高程序的灵活性，允许特定的非成员函数访问类的私有数据
  2. 在运算符重载中非常有用
  3. 可以让两个或多个类共享私有信息

缺点​

  1. 破坏了类的封装性，可能导致数据安全性问题
  2. 如果过度使用，会使得代码难以维护和理解
  3. 破坏了面向对象设计中的信息隐藏原则
警告

虽然友元提供了灵活性，但应谨慎使用。过度使用友元会降低代码的封装性和安全性。

最佳实践​

  1. 最小化使用 - 只在确实需要时才使用友元
  2. 仔细设计 - 只授予必要的最小访问权限
  3. 友元优先级 - 先考虑成员函数或公共接口，再考虑友元
  4. 明确文档 - 在代码注释中清楚说明为什么需要友元关系

总结​

友元函数是C++中一种特殊的机制，允许指定的函数访问类的私有和保护成员。虽然这在某些情况下很有用（如运算符重载和数据转换），但应谨慎使用，因为它破坏了封装性。

理解友元函数的工作原理和适用场景，将帮助你更好地设计C++类和函数，使你的代码既灵活又安全。

练习题​

  1. 创建一个Rectangle类，包含私有的length和width成员。编写一个友元函数calculateArea，计算并返回矩形的面积。

  2. 创建两个类Student和Course，使Course类能够访问Student类的私有成员，实现学生注册课程的功能。

  3. 重载<<运算符为友元函数，以便能够使用cout直接打印自定义的Date类对象。

  4. 创建两个类Vector2D和Vector3D，实现一个友元函数，可以将2D向量转换为3D向量（第三维设为0）。

  5. 使用友元函数实现两个复数对象的比较运算符（==、!=）。

附加资源​