【C++友元函数】深入探索C++友元函数：从基础到应用

最新推荐文章于 2024-05-20 16:38:18 发布

泡沫o0

最新推荐文章于 2024-05-20 16:38:18 发布

阅读量63

点赞数

分类专栏： C/C++ 编程世界: 探索C/C++的奥妙 # C/C++ 函数和过程文章标签： arm开发嵌入式 arm 开发语言 c++ qt linux

本文链接：https://blog.csdn.net/qq_21438461/article/details/132365070

版权

C/C++ 编程世界: 探索C/C++的奥妙同时被 2 个专栏收录

521 篇文章 247 订阅

订阅专栏

C/C++ 函数和过程

52 篇文章 11 订阅

订阅专栏

1. 引言

在编程的世界中，我们经常会遇到各种复杂的概念和技术。为了更好地理解这些概念，我们需要从不同的角度来看待它们。正如心理学家经常说的：“人的行为和思维方式是由其内在的心理结构和外部环境共同决定的。”（Sigmund Freud）在编程中，我们也可以从这个角度来看待问题。

1.1 C++的封装特性与友元的关系

C++是一种面向对象的编程语言，它的核心思想之一是封装（Encapsulation）。封装是指将数据（属性）和操作数据的方法（函数）捆绑在一起，形成一个独立的实体或对象。这样做的好处是可以隐藏内部实现细节，只暴露必要的接口给外部。

但是，有时我们希望某些外部函数或类能够访问某个类的私有或保护成员，这时就需要用到友元（Friend）。

从心理学的角度看，友元就像是我们的亲密朋友。正如我们可能会与亲密的朋友分享一些私人的事情，但不会与外人分享。在C++中，友元函数或友元类就是那些被允许访问私有或保护成员的“亲密朋友”。

1.2 为什么需要友元？

想象一下，你有一个秘密，你不想告诉任何人，但你的最好的朋友是个例外。在C++中，这个“秘密”就是类的私有成员，而那个特殊的朋友就是友元。

使用友元的原因有很多，以下是一些常见的情况：

紧密协作：有时，两个类需要紧密协作，一个类需要访问另一个类的内部成员。
性能优化：在某些情况下，直接访问成员比通过公共接口更快。
特定的设计模式：例如，单例模式可能需要使用友元。

使用场景	是否需要友元	为什么
类的紧密协作	是	直接访问另一个类的内部成员
性能优化	是	避免函数调用的开销
单例模式	是	控制实例的创建

但是，使用友元也有其缺点。过度使用友元可能会破坏类的封装性，使代码更难维护。因此，我们应该谨慎使用友元，确保它真的是必要的。

“在设计中，简单性和清晰性是至关重要的。” — Bjarne Stroustrup（C++之父）

在接下来的章节中，我们将深入探讨友元函数的各种细节和应用，帮助你更好地理解这个强大的C++特性。

2. 友元函数的基本概念

在深入探讨友元函数之前，我们首先需要理解它的基本概念。正如心理学家Carl Rogers所说：“为了理解一个人，你必须先走进他的鞋子，看世界从他的视角。”同样，为了理解友元函数，我们需要从它的定义和特点开始。

2.1 定义与特点

友元函数（Friend Function）不是类的成员函数，但它可以访问类的所有私有（private）和保护（protected）成员。这是因为它被声明为该类的“友元”。

以下是友元函数的主要特点：

它不是类的成员函数。
它不能直接访问类的成员，需要通过对象来访问。
它可以是全局函数或其他类的成员函数。

class Box {
private:
    double width;

public:
    friend void printWidth(Box box);
};

void printWidth(Box box) {
    // 因为printWidth是Box的友元，它可以直接访问Box的私有成员
    std::cout << "Width of box: " << box.width << std::endl;
}

2.2 与普通函数和成员函数的区别

从心理学的角度看，我们可以将友元函数、普通函数和成员函数比作三种不同类型的人际关系：

普通函数：就像是你的普通朋友，他们不知道你的私人事务。
成员函数：就像是你的家庭成员，他们知道你的一切。
友元函数：就像是你的亲密朋友，你信任他们并与他们分享你的秘密。

函数类型	是否可以访问私有成员	是否需要对象来访问非静态成员
普通函数	否	是
成员函数	是	否
友元函数	是	是

从上表中，我们可以清楚地看到友元函数与其他函数的主要区别。

2.3 示例与注释

让我们通过一个简单的例子来进一步理解友元函数的工作原理。

class Circle {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    // 声明友元函数
    friend double calculateArea(Circle c);
};

double calculateArea(Circle c) {
    return 3.14 * c.radius * c.radius;  // 直接访问私有成员radius
}

int main() {
    Circle circle(5);
    std::cout << "Area: " << calculateArea(circle) << std::endl;
    return 0;
}

在上面的例子中，calculateArea函数被声明为Circle类的友元，因此它可以直接访问Circle的私有成员radius。

3. 友元函数的种类

在我们的生活中，友情有很多种形式。有些朋友与我们共事，有些朋友与我们共度时光，还有些朋友与我们共享秘密。同样，在C++中，友元也有多种形式。让我们从心理学的角度深入探讨这些不同的友元函数。

3.1 全局友元函数

全局友元函数是在类外部定义的，但由于它被声明为类的友元，它可以访问类的所有私有和保护成员。

class Rectangle {
private:
    double length, width;

public:
    Rectangle(double l, double w) : length(l), width(w) {}

    // 声明全局函数为友元
    friend double calculatePerimeter(Rectangle rect);
};

double calculatePerimeter(Rectangle rect) {
    return 2 * (rect.length + rect.width);  // 直接访问私有成员
}

正如心理学家Abraham Maslow所说：“人与人之间的关系是多种多样的。”全局友元函数就像是那些与我们没有直接关系，但我们仍然信任他们的人。

3.2 其他类的成员函数作为友元

有时，我们可能希望一个类的成员函数能够访问另一个类的私有或保护成员。在这种情况下，我们可以将这个成员函数声明为另一个类的友元。

class Triangle;

class Square {
private:
    double side;

public:
    Square(double s) : side(s) {}

    // 声明Triangle的成员函数为友元
    friend double Triangle::areaDifference(const Square& sq);
};

class Triangle {
private:
    double base, height;

public:
    Triangle(double b, double h) : base(b), height(h) {}

    double areaDifference(const Square& sq) {
        double triangleArea = 0.5 * base * height;
        double squareArea = sq.side * sq.side;  // 直接访问Square的私有成员
        return triangleArea - squareArea;
    }
};

这种关系就像两个亲密的朋友，其中一个愿意与另一个分享他的秘密。

3.3 示例与注释

考虑以下示例，其中一个类Person有一个友元类Access，该类可以访问Person的私有数据。

class Access;  // 前向声明

class Person {
private:
    std::string secret = "This is a secret!";

public:
    friend class Access;  // 声明Access为友元类
};

class Access {
public:
    void revealSecret(const Person& person) {
        std::cout << "The secret is: " << person.secret << std::endl;  // 直接访问私有成员
    }
};

int main() {
    Person person;
    Access access;
    access.revealSecret(person);
    return 0;
}

在这个例子中，Access类可以直接访问Person类的私有成员secret，因为它被声明为Person的友元类。

4. 友元与单例模式

单例模式是设计模式中的经典之一，它确保一个类只有一个实例，并提供一个全局点来访问这个实例。从心理学的角度看，单例模式就像一个人的独特性格或特质，每个人都是独一无二的。而友元在这里扮演了一个关键的角色，帮助我们更好地实现这一模式。

4.1 单例模式简介

单例模式的主要目的是确保一个类只有一个实例，并提供一个简单的方法来访问它。这通常是通过提供一个静态方法来实现的，该方法返回该类的唯一实例。

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}  // 私有构造函数

public:
    static Singleton* getInstance() {
        if (!instance) {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

4.2 如何使用友元函数访问单例类的私有成员

在某些情况下，我们可能希望某些外部函数或类能够访问单例类的私有成员，而不仅仅是其实例。这时，友元就派上了用场。

考虑以下示例，其中一个全局函数需要访问Singleton类的私有构造函数来进行某些操作：

class Singleton;

void specialFunction();

class Singleton {
private:
    static Singleton* instance;
    int secretData;
    Singleton(int data) : secretData(data) {}  // 私有构造函数

    friend void specialFunction();  // 声明友元函数
};

void specialFunction() {
    Singleton s(42);  // 可以直接访问私有构造函数
    std::cout << "Secret data: " << s.secretData << std::endl;  // 直接访问私有成员
}

Singleton* Singleton::instance = nullptr;

在上述示例中，specialFunction可以直接访问Singleton类的私有构造函数和私有数据成员，因为它被声明为该类的友元。

4.3 示例与注释

让我们考虑一个更复杂的例子，其中一个类Logger作为单例存在，而另一个类Application需要访问Logger的私有成员来进行特殊的日志操作。

class Logger;

class Application {
public:
    void performLogging();

    friend class Logger;  // 声明Logger为友元类
};

class Logger {
private:
    static Logger* instance;
    std::string logData;
    Logger() {}

public:
    static Logger* getInstance() {
        if (!instance) {
            instance = new Logger();
        }
        return instance;
    }

    void specialLog(const Application& app) {
        // 可以直接访问Application的成员
        app.performLogging();
    }
};

Logger* Logger::instance = nullptr;

void Application::performLogging() {
    Logger::getInstance()->logData = "Special log data";
    std::cout << "Logging: " << Logger::getInstance()->logData << std::endl;
}

在这个例子中，Logger类可以直接访问Application类的成员，因为它被声明为Application的友元类。

5. 内联与友元函数

在C++编程中，内联函数和友元函数都是非常重要的概念。它们在提高代码效率和提供更大的灵活性方面都起到了关键作用。但是，为了更好地理解它们，我们需要从心理学的角度来看待这些概念。

5.1 内联函数的基本概念

内联函数（Inline Functions）是C++为了提高函数调用效率而引入的一种特殊函数。当函数被声明为内联时，编译器会尝试将其内容直接嵌入到调用点，从而避免函数调用的开销。

从心理学的角度看，人们总是倾向于选择最直接、最简单的方法来完成任务。内联函数正是这种思维的体现。它们尝试通过减少不必要的跳转和调用来简化程序的执行流程。

inline int add(int a, int b) {
    return a + b;
}

在上面的示例中，add函数被声明为内联函数。这意味着当我们在代码中调用这个函数时，编译器可能会直接将return a + b;这行代码嵌入到调用点，而不是生成一个常规的函数调用。

5.2 如何将友元函数声明为内联

友元函数（Friend Functions）可以访问类的私有和保护成员。当我们希望一个友元函数频繁地被调用，并希望它的调用尽可能快时，可以考虑将其声明为内联函数。

class MyClass {
private:
    int value;

public:
    MyClass(int v) : value(v) {}

    // 声明内联友元函数
    friend inline void displayValue(const MyClass& obj);
};

inline void displayValue(const MyClass& obj) {
    std::cout << obj.value << std::endl;
}

在这个示例中，displayValue函数被声明为MyClass的内联友元函数。这意味着当我们在代码中调用这个函数时，编译器可能会尝试直接嵌入其代码，从而提高执行效率。

5.3 优势与考虑因素

内联函数的主要优势是提高了代码的执行效率。但是，它也有一些需要考虑的因素：

优势/考虑因素	描述
代码效率提高	由于避免了函数调用的开销，代码执行更快
代码大小增加	内联函数可能会导致代码膨胀，因为它的代码可能在多个地方被复制
编译时间增加	由于需要处理内联函数的代码替换，编译时间可能会增加
可能的缓存未命中	如果内联函数导致生成的代码过大，可能会影响CPU缓存的效率

从心理学的角度看，我们总是在追求完美和效率。但是，我们也需要认识到每个选择都有其权衡。正如Robert C. Martin在《Clean Code》中所说：“代码是写给人看的，只是恰好可以运行。”我们在编写代码时，不仅要考虑机器的效率，还要考虑人的效率。

5.3.1 内联函数的深入剖析

为了更好地理解内联函数的工作原理，我们可以深入到编译器的底层来看看它是如何处理内联函数的。

当编译器遇到一个内联函数调用时，它会尝试将函数的代码直接嵌入到调用点。这样，程序在运行时就不需要跳转到函数的地址，然后再跳回来。这种直接嵌入的方式可以显著提高代码的执行效率。

但是，这也意味着每次调用内联函数，其代码都会被复制到调用点。这可能会导致生成的机器代码变得非常大，从而影响程序的加载时间和内存使用。

因此，当我们考虑使用内联函数时，需要权衡其带来的效率提升和可能的副作用。

6. 友元与C++标准的演进

随着C++标准的不断演进，语言为开发者提供了更多的功能和工具。然而，友元函数这一古老的概念在这些变化中始终保持其核心价值。让我们从心理学的角度，结合C++的历史演进，深入探讨友元函数在C++11、C++14、C++17和C++20中的地位和变化。

6.1 C++11与友元

C++11被广泛认为是C++的一次重大革新，它引入了许多新特性，如lambda表达式、智能指针、范围for循环等。但在这些变化中，友元函数的基本概念并没有发生太大变化。

然而，C++11引入的一些新特性与友元函数有着紧密的联系：

委托构造函数：这允许一个构造函数调用同类中的另一个构造函数。如果一个构造函数被声明为友元，那么它可以使用委托构造函数的功能。
右值引用与移动语义：这使得我们可以更有效地管理资源。友元函数可以利用这些特性来实现更高效的操作。

6.2 C++14、C++17与友元

C++14和C++17进一步完善了C++11引入的特性，并添加了一些新功能。但对于友元函数，这两个版本并没有带来太大的变化。

然而，这两个版本中的一些新特性，如constexpr、模板变量、结构化绑定等，都可以与友元函数结合使用，为开发者提供更多的灵活性。

6.3 C++20与友元

C++20是近年来最大的一次更新，它引入了许多令人兴奋的新特性，如概念、范围、协程等。在这些新特性中，友元函数仍然保持其核心地位。

例如，使用C++20的概念，我们可以为友元函数定义更加精确的约束，确保它们在特定的上下文中正确地工作。

6.4 从心理学的角度看待友元与C++的演进

从心理学的角度看，人们总是在追求更好、更高效的方法来完成任务。C++的不断演进正是这种追求的体现。而友元函数，作为C++的一个核心概念，始终与时俱进，与新特性和工具紧密结合，为开发者提供了更多的可能性。

正如Carl Gustav Jung所说：“我们不能改变任何东西，除非我们接受它。”为了更好地使用C++和友元函数，我们首先需要理解和接受它们，然后才能充分发挥它们的潜力。

7. 友元在Qt编程中的应用

Qt是一个跨平台的C++图形用户界面应用程序开发框架，广泛用于开发GUI应用程序，但也可以用于开发非GUI程序。在Qt编程中，友元函数和友元类的概念同样重要。从心理学的角度，我们可以将友元看作是一种“信任”的体现，它允许某些外部实体访问类的私有部分。在Qt中，这种“信任”关系在很多地方都有体现。

7.1 Qt中的实际示例

在Qt中，有时我们需要让某些特定的类或函数访问另一个类的私有成员。这通常是为了提高效率或简化代码结构。

例如，QGraphicsView和QGraphicsScene之间就存在这样的关系。QGraphicsView需要直接访问QGraphicsScene的某些私有成员来进行渲染和事件处理，而不必通过公共接口。

class QGraphicsScene {
    ...
private:
    QList<QGraphicsItem*> items;

    friend class QGraphicsView;  // 声明QGraphicsView为友元类
};

在上面的代码中，QGraphicsView被声明为QGraphicsScene的友元类，这意味着它可以直接访问items列表。

7.2 常见的使用场景和注意事项

在Qt编程中，友元最常见的使用场景是当两个类需要紧密协作，而不希望暴露太多的内部细节时。

常见使用场景：

渲染和绘图：如上面的QGraphicsView和QGraphicsScene示例。
事件处理：某些类可能需要直接处理其他类的事件，而不通过公共接口。
优化和性能提升：直接访问私有成员可以避免额外的函数调用开销。

注意事项：

过度使用友元：过度使用友元可能会破坏封装，导致代码难以维护。我们应该在真正需要的时候才使用友元。
代码的可读性：使用友元可能会使代码的逻辑变得复杂，我们需要确保代码的可读性。
版本兼容性：如果在后续的Qt版本中，某个类的内部结构发生了变化，那么依赖于这个类的私有成员的友元类或函数可能会出现问题。

从心理学的角度看，友元就像是我们生活中的亲密伙伴，我们信任他们，允许他们进入我们的私人空间。但同样，我们也需要确保这种信任不会被滥用。正如Stephen R. Covey在《高效能人士的七个习惯》中所说：“信任是知识、技能和态度的组合。”在编程中，我们需要确保我们的“伙伴”（友元）是值得信赖的，而不是滥用这种特权。

8. 友元的优缺点

在C++编程中，友元（Friend）是一个备受争议的特性。它打破了类的封装性，允许外部函数或类访问其私有成员。那么，为什么C++还要引入这样一个特性呢？这背后的原因与人性有关。

8.1 为什么有时被批评？

8.1.1 打破封装性

友元函数或类可以直接访问类的私有和保护成员，这违反了面向对象编程的封装原则。封装（Encapsulation）是面向对象编程的三大特性之一，它要求将数据和操作数据的方法绑定在一起，隐藏不需要公开的细节。

从心理学的角度看，人们喜欢有秩序、有边界的环境。这种边界给人们提供了安全感。同样，封装为程序员提供了一种安全感，确保数据不会被误用。但友元打破了这种边界，这就像一个外人突然进入你的私人空间，可能会引起不适。

8.1.2 增加代码的复杂性

使用友元会增加代码的复杂性，因为它引入了一个非成员函数或类，这些函数或类可以访问类的私有成员。这使得代码的维护和理解变得更加困难。

心理学家经常强调简单性的重要性。当面对复杂的问题时，人们往往会感到困惑和不安。同样，在编程中，简单、清晰的代码更容易被理解和维护。

8.2 正确和高效地使用友元

尽管友元有其缺点，但在某些情况下，它仍然是一个非常有用的工具。关键是要知道何时以及如何使用它。

8.2.1 什么时候使用友元？

当两个类有紧密的协作关系时：例如，两个类需要共享某些数据，但不希望这些数据被其他类访问。
为了提高效率：有时，直接访问私有成员比通过公共接口更有效率。
单例模式：在单例模式中，构造函数是私有的，但需要一个全局函数或其他类来创建和返回唯一的实例。

8.2.2 如何使用友元？

最小权限原则：只给必要的函数或类提供友元权限，不要滥用。
清晰的文档：当使用友元时，确保有清晰的文档说明为什么需要使用友元，以及它是如何工作的。
避免过度使用：不要因为方便而滥用友元。如果可以通过其他方法实现同样的功能，那么最好不要使用友元。

从心理学的角度看，人们喜欢遵循规则和原则。这为我们提供了一种指导，帮助我们做出正确的决策。在编程中，遵循最佳实践和原则可以帮助我们写出更好、更可靠的代码。

8.2.3 技术对比

以下是一个简单的表格，总结了友元与其他技术的对比：

技术	优点	缺点
友元 (Friend)	直接访问私有成员，提高效率	打破封装，增加复杂性
公共接口 (Public Interface)	保持封装，易于维护	可能降低效率
受保护成员 (Protected Member)	在派生类中可访问	打破封装

在选择使用哪种技术时，我们应该根据具体的需求和情境来决定。心理学家强调，每个人都是独特的，每种情境都是独特的。同样，在编程中，每个问题都是独特的，需要根据具体的情境来选择最合适的解决方案。

结语

在我们的编程学习之旅中，理解是我们迈向更高层次的重要一步。然而，掌握新技能、新理念，始终需要时间和坚持。从心理学的角度看，学习往往伴随着不断的试错和调整，这就像是我们的大脑在逐渐优化其解决问题的“算法”。

这就是为什么当我们遇到错误，我们应该将其视为学习和进步的机会，而不仅仅是困扰。通过理解和解决这些问题，我们不仅可以修复当前的代码，更可以提升我们的编程能力，防止在未来的项目中犯相同的错误。

我鼓励大家积极参与进来，不断提升自己的编程技术。无论你是初学者还是有经验的开发者，我希望我的博客能对你的学习之路有所帮助。如果你觉得这篇文章有用，不妨点击收藏，或者留下你的评论分享你的见解和经验，也欢迎你对我博客的内容提出建议和问题。每一次的点赞、评论、分享和关注都是对我的最大支持，也是对我持续分享和创作的动力。

阅读我的CSDN主页,解锁更多精彩内容:泡沫的CSDN主页

泡沫o0

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【C++友元函数】深入探索C++友元函数：从基础到应用

C++是一种面向对象的编程语言，它的核心思想之一是**封装**（Encapsulation）。封装是指将数据（属性）和操作数据的方法（函数）捆绑在一起，形成一个独立的实体或对象。这样做的好处是可以隐藏内部实现细节，只暴露必要的接口给外部。
复制链接

扫一扫