第三弹：C++ 中的友元机制与运算符重载详解

于 2024-10-03 09:43:13 发布
阅读量593 收藏 10
点赞数 14
分类专栏： C++ 文章标签： c++ 开发语言 友元 运算符重载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65477256/article/details/142689164
版权

文章目录

C++ 中的友元机制与运算符重载详解

C++ 是一种强大的面向对象编程语言，具备封装、继承和多态等特性。而友元机制和运算符重载作为 C++ 的两个重要特性，为开发者提供了更灵活和高效的编程方式。本文将深入探讨 C++ 中友元机制与运算符重载的概念、实现及其特性，并结合代码示例帮助读者理解这些机制的实际应用。

知识点1：C++ 友元机制

1.1 友元的概念与意义

在 C++ 中，封装性体现在类的成员变量和成员函数的访问控制上。通过访问权限修饰符（public、protected、private）控制类的成员访问权限，以确保类的私有数据不被外部直接访问。然而，某些情况下，可能需要外部的某些函数或类能够访问类的私有成员，C++ 提供了友元机制来解决这一需求。

友元机制允许类的外部函数或其他类访问其私有成员。通过在类中使用 friend 关键字声明友元，打破了类的封装性，从而为复杂场景中的灵活操作提供了可能性。

1.2 友元的实现

C++ 中的友元机制可以通过以下几种方式实现：

  1. 友元函数：非类成员函数可以通过友元机制访问类的私有成员。
  2. 友元类：某个类的所有成员函数都可以通过友元机制访问另一个类的私有成员。
  3. 友元成员函数：某个特定的成员函数通过友元机制访问其他类的私有成员。
1.2.1 友元函数

友元函数是非类成员的普通函数。通过在类中声明为友元函数，它可以访问类的私有成员。这种机制常用于全局函数对类的操作，例如对类的输入输出操作。

示例代码：

#include <iostream>
using namespace std;

class Demo {
private:
    int val;  // 私有成员变量

public:
    // 公共成员函数，用于设置值
    void setVal(int myval) {
        val = myval;
    }

    // 声明友元函数，允许访问私有成员
    friend int getVal(const Demo& obj);
};

// 友元函数定义，可以访问私有成员 val
int getVal(const Demo& obj) {
    return obj.val;
}

int main() {
    Demo obj;
    obj.setVal(5);  // 设置值
    cout << "The value is: " << getVal(obj) << endl;  // 通过友元函数访问私有成员
    return 0;
}
1.2.2 友元类

友元类是指某个类的所有成员函数都可以访问另一个类的私有和保护成员。这种机制用于两个类之间的紧密合作场景，例如一个类封装数据，另一个类专门处理这些数据。

示例代码：

#include <iostream>
using namespace std;

class DemoA;  // 前向声明

class DemoB {
public:
    // 友元类成员函数可以访问 DemoA 的私有成员
    void modifyVal(DemoA& obj, int newVal);
};

class DemoA {
private:
    int val;  // 私有成员

    // 声明 DemoB 为友元类，允许其访问私有成员
    friend class DemoB;

public:
    DemoA(int v) : val(v) {}

    void showVal() const {
        cout << "Value: " << val << endl;
    }
};

// 友元类 DemoB 中的成员函数可以修改 DemoA 的私有成员
void DemoB::modifyVal(DemoA& obj, int newVal) {
    obj.val = newVal;
}

int main() {
    DemoA objA(10);
    DemoB objB;

    objA.showVal();  // 输出：Value: 10
    objB.modifyVal(objA, 20);  // 通过友元类修改私有成员
    objA.showVal();  // 输出：Value: 20

    return 0;
}
1.2.3 友元成员函数

当我们只希望另一个类的特定成员函数访问某个类的私有成员时，可以使用友元成员函数。这种方式可以更精细地控制访问权限。

示例代码：

#include <iostream>
using namespace std;

class DemoB;  // 前向声明

class DemoA {
private:
    int val;  // 私有成员

public:
    DemoA(int v) : val(v) {}

    // 友元成员函数，允许访问私有成员
    friend int DemoB::getVal(const DemoA& obj);
};

class DemoB {
public:
    // 访问 DemoA 的私有成员
    int getVal(const DemoA& obj) {
        return obj.val;
    }
};

int main() {
    DemoA objA(100);
    DemoB objB;
    
    cout << "The value is: " << objB.getVal(objA) << endl;  // 输出私有成员

    return 0;
}
1.3 友元的单向性和非传递性

友元关系具有以下特性：

  • 单向性：如果类A声明类B为友元，类B可以访问类A的私有成员，但类A不能访问类B的私有成员，除非类B也声明类A为友元。
  • 非传递性：如果类A是类B的友元，类B是类C的友元，类A不能自动成为类C的友元。
1.4 友元的谨慎使用

尽管友元机制提供了访问私有成员的灵活性，但它也破坏了类的封装性。如果滥用友元，可能会导致代码的耦合度增加，数据的安全性降低。因此，友元应仅在必要时使用，避免破坏类的封装原则。

知识点2：C++ 运算符重载

2.1 运算符重载的概念

运算符重载是 C++ 提供的一种功能，它允许我们为自定义类型赋予运算符的新含义。通过重载运算符，我们可以像对待内置数据类型一样对自定义类进行运算操作。运算符重载的本质是函数重载，其中运算符被视为函数，操作数是函数的参数。

2.2 运算符重载的实现方式

运算符重载可以通过两种方式实现：友元函数和成员函数。

2.2.1 友元函数实现运算符重载

友元函数可以访问类的私有成员，因此在运算符需要访问私有成员时，可以通过友元函数进行重载。

示例代码：

#include <iostream>
using namespace std;

class Demo {
private:
    int val;  // 私有成员变量

public:
    Demo(int v = 0) : val(v) {}

    // 友元函数重载 + 运算符
    friend Demo operator+(const Demo& obj1, const Demo& obj2);

    // 获取值
    int getVal() const {
        return val;
    }
};

// 重载 + 运算符，返回两个对象相加后的结果
Demo operator+(const Demo& obj1, const Demo& obj2) {
    return Demo(obj1.val + obj2.val);
}

int main() {
    Demo obj1(10), obj2(20);
    Demo obj3 = obj1 + obj2;  // 使用重载的 + 运算符
    cout << "Result of addition: " << obj3.getVal() << endl;  // 输出结果

    return 0;
}
2.2.2 成员函数实现运算符重载

成员函数重载运算符时，左操作数隐式为调用该成员函数的对象，因此参数个数比友元函数少一个。

示例代码：

#include <iostream>
using namespace std;

class Demo {
private:
    int val;  // 私有成员变量

public:
    Demo(int v = 0) : val(v) {}

    // 成员函数重载 + 运算符
    Demo operator+(const Demo& obj) const {
        return Demo(this->val + obj.val);
    }

    // 获取值
    int getVal() const {
        return val;
    }
};

int main() {
    Demo obj1(10), obj2(20);
    Demo obj3 = obj1 + obj2;  // 使用重载的 + 运算符
    cout << "Result of addition: " << obj3.getVal() << endl;  // 输出结果

    return 0;
}
2.3 运算符重载的特性
  1. **运算符重载不会改变运

算符的优先级**：例如重载 + 运算符后，它的优先级仍然和原始 + 运算符一致。
2. 不能改变运算符的参数个数：例如，重载二元运算符 + 时，必须有两个操作数。
3. 某些运算符必须以成员函数的方式重载：如 =、[]、() 和 -> 这些运算符只能通过成员函数重载。

2.4 不可重载的运算符

C++ 中有少数运算符是不能被重载的，这些运算符包括：

  • .（成员访问运算符）
  • ::（作用域解析运算符）
  • .*（成员指针访问运算符）
  • ?:（三元条件运算符）
  • sizeof（计算大小运算符）
  • typeid（类型识别运算符）

这些运算符的语法和行为在 C++ 中是固定的，无法被修改或重载。

2.5 自增自减运算符的前置与后置区别

自增 (++) 和自减 (--) 运算符既可以作为前置运算符，也可以作为后置运算符使用，二者的区别在于运算的顺序：

  • 前置运算符：先自增/自减，再返回值。
  • 后置运算符：先返回值，再自增/自减。

示例代码：

#include <iostream>
using namespace std;

class Demo {
private:
    int val;

public:
    Demo(int v = 0) : val(v) {}

    // 前置自增运算符重载
    Demo& operator++() {
        ++val;
        return *this;
    }

    // 后置自增运算符重载
    Demo operator++(int) {
        Demo temp = *this;
        val++;
        return temp;
    }

    int getVal() const {
        return val;
    }
};

int main() {
    Demo obj(5);

    cout << "Initial value: " << obj.getVal() << endl;  // 输出 5

    ++obj;  // 前置自增
    cout << "After prefix ++: " << obj.getVal() << endl;  // 输出 6

    obj++;  // 后置自增
    cout << "After postfix ++: " << obj.getVal() << endl;  // 输出 7

    return 0;
}
2.6 运算符重载的成员函数 vs. 友元函数
  • 成员函数重载：适用于当运算符左边的操作数是当前类对象的情况。例如，赋值运算符 = 和下标运算符 [] 通常通过成员函数重载。
  • 友元函数重载：用于当运算符左操作数不是类对象，或需要访问类的私有成员时。例如，输入输出运算符 << 和 >> 通常通过友元函数重载。

知识点3：自定义字符串类的封装与运算符重载

为了更好地理解运算符重载的实际应用，接下来我们将通过封装一个自定义的字符串类 String 来展示如何通过运算符重载实现字符串的赋值、拼接和比较操作。

3.1 字符串类的封装

自定义 String 类的核心是动态管理字符数组，并通过重载运算符实现字符串的各种操作。

3.2 深拷贝与浅拷贝

在自定义类中，尤其是涉及动态内存的类，必须正确实现深拷贝，以避免多个对象共享同一块内存区域的问题。浅拷贝只复制指针，可能导致内存管理冲突，而深拷贝则复制内容，确保每个对象拥有独立的内存。

示例代码：

#include <iostream>
#include <cstring>
using namespace std;

class String {
private:
    char* data;

public:
    // 构造函数
    String(const char* str = nullptr) {
        if (str) {
            data = new char[strlen(str) + 1];
            strcpy(data, str);
        } else {
            data = new char[1];
            *data = '\0';
        }
    }

    // 拷贝构造函数（深拷贝）
    String(const String& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }

    // 重载赋值运算符（深拷贝）
    String& operator=(const String& other) {
        if (this != &other) {
            delete[] data;
            data = new char[strlen(other.data) + 1];
            strcpy(data, other.data);
        }
        return *this;
    }

    // 重载加法运算符，用于字符串拼接
    String operator+(const String& other) const {
        String newStr;
        newStr.data = new char[strlen(data) + strlen(other.data) + 1];
        strcpy(newStr.data, data);
        strcat(newStr.data, other.data);
        return newStr;
    }

    // 重载下标运算符，访问字符
    char& operator[](int index) {
        return data[index];
    }

    // 析构函数
    ~String() {
        delete[] data;
    }

    // 输出字符串
    void print() const {
        cout << data << endl;
    }
};

int main() {
    String str1("Hello");
    String str2(" World");

    String str3 = str1 + str2;  // 使用 + 运算符拼接字符串
    str3.print();  // 输出：Hello World

    str1 = "Hi";  // 使用赋值运算符
    str1.print();  // 输出：Hi

    cout << "First character of str1: " << str1[0] << endl;  // 使用下标运算符

    return 0;
}

知识点4：其他重要的运算符重载规则

4.1 = 运算符重载的注意事项

在重载赋值运算符时，必须考虑自我赋值的情况。自我赋值可能会导致数据丢失，因此需要特别检查对象是否为自身。如果是自身，则无需执行赋值操作。

4.2 输入输出运算符重载

<< 和 >> 运算符通常用于输入输出操作。由于 ostream 和 istream 是标准库中的类对象，且不属于用户自定义类，因此它们通常通过友元函数来进行重载。

示例代码：

#include <iostream>
using namespace std;

class Point {
private:
    int x, y;

public:
    Point(int x = 0, int y = 0) : x(x), y(y) {}

    // 友元函数，重载 << 运算符用于输出
    friend ostream& operator<<(ostream& out, const Point& p);

    // 友元函数，重载 >> 运算符用于输入
    friend istream& operator>>(istream& in, Point& p);
};

// 重载 << 运算符
ostream& operator<<(ostream& out, const Point& p) {
    out << "(" << p.x << ", " << p.y << ")";
    return out;
}

// 重载 >> 运算符
istream& operator>>(istream& in, Point& p) {
    in >> p.x >> p.y;
    return in;
}

int main() {
    Point p1(3, 4);
    cout << "Point 1: " << p1 << endl;

    Point p2;
    cout << "Enter coordinates for Point 2: ";
    cin >> p2;
    cout << "Point 2: " << p2 << endl;

    return 0;
}

总结与建议

C++ 的友元机制和运算符重载为开发者提供了强大的编程工具，使得自定义类型的设计更加灵活和高效。然而，这些机制在使用时需要遵循以下原则：

  1. 谨慎使用友元：友元机制打破了类的封装性，应仅在必要时使用，避免增加类之间的耦合性。
  2. 合理运用运算符重载：运算符重载能够增强代码的可读性，但应确保重载后的行为符合用户的直观预期。
  3. 深拷贝的实现：当类涉及动态内存管理时，必须正确实现深拷贝，以避免浅拷贝带来的内存管理问题。

通过对友元和运算符重载的深入理解，开发者可以编写出更加健壮、高效的 C++ 程序，实现更优雅的代码结构和逻辑。

三玖诶
关注
专栏目录
C++运算符重载 成员函数与友元函数详解
12-31
代码如下:#include<iostream>using namespace std;class A{ int x,y; public: A(int xx,int yy):x(xx),y(yy){} A(){x=0;y=0;} A operator+(const A&b) //不加const限定，也可以 { return A(x+b.x,y+b.y);...
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
C++中不能被重载的运算符介绍
12-25
您可能感兴趣的文章:详解C++编程中的单目运算符重载与双目运算符重载C++运算符重载规则详解简介C++编程中的运算符重载c++ *运算符重载C++重载运算符的规则详解解析C++中不能重载为友元函数的四个运算符C++运算符...
c++运算符重载基础知识详解
09-04
C++运算符重载是编程中一个重要的概念，它允许我们为已有的运算符赋予新的含义，使得在处理自定义数据类型时，代码更加直观和简洁。在C++中，运算符重载并不是创建新的运算符，而是为已有的运算符提供不同的实现方式...
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1024
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 650
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 418
【代码】求n的阶乘的相反数（c语言）
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 390
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
静谧、淡雅
09-29 227
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
最新发布
weixin_45740473的博客
10-02 576
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
AI驱动TDSQL-C Serverless数据库技术实战营--- 操作与电商可视分析
chasemydreamidea的博客
09-27 713
本文将基于腾讯云的高性能应用服务HAI和TDSQL-C MYSQL Serverless版构建AI电商数据分析系统。HAI作为一个面向AI和科学计算的GPU应用服务产品，它具有强大的计算能力，让复杂的AI模型的快速部署和运行的可行性加大，进而支持自然语言处理和图形生成等高级任务。TDSQL-C MYSQL版是一款云原生关系型数据库，其100%的MySQL兼容性，以及极致的弹性、高性能和高可用性，是电商业务中处理海量数据存储和查询的理想选择。本文实践除了使用TDSQL-C MYSQL外，通过python语言和
【C++】stack和queue的使用及注意事项
wangnaisheng的专栏
09-28 648
【C++】stack和queue的使用及注意事项
C/C++语言基础--C++运算符重载以及其重载限制
weixin_74085818的博客
09-27 989
运算符重载，就是赋予运算符新的含义。它是重载系统内部运算符的函数，是实现类静态多态性的方式之一。它本质上是函数重载。// 假设都属于学生类// 想要对比谁的年龄大，试想一下，能不能像正常比较大小那样直接比较呢？答案当然是可以的，这个就是我们这节课要学习的**“运算符重载”**，这样进行重载后，类更像是一种自定义数据类型。实际上，我们已经在不知不觉之中使用了运算符重载。列如：我们习惯使用的对整数，浮点数运用+、-、*、/，其实计算机对整数和浮点数的操作过程是不一样的，这个主要是整数和浮点数的。
第九章---for循环及在STL的应用(vector\map\set\list\for_each)、嵌套while、while 统一输出、do-while
T-ang.的博客
09-29 1187
在C++中，循环语句用于重复执行一段代码，直到指定的条件不再满足。C++ 提供了几种循环机制，下面将详细讲解每种循环语句的用法和特点。
set和map
2302_79795489的博客
09-26 219
在 C++ 中，set和map是两个常用的容器，它们分别在<set>和<map>头文件中定义。
【C语言从不挂科到高绩点】25-C语言中的共用体以及Main函数详解【重点知识】
yueyehuguang的博客
09-30 956
结构体是一种构造类型或者复杂类型，它可以包含多个类型不同的成员。union 共用体名{成员列表;结构体的各个成员会占用不同的内存，相互之间是没有影响的。而共用体的所有成员占用同一段内存，修改了一个成员会影响其余所有的成员结构体占用的内存大于或等于成员所占用的内存的综合。共用体占用的内存等于最长的成员所占用的内存。共用体使用内存覆盖技术，同一时刻只能保存一个成员的值，如果对新的成员赋值，就会把原来成员的值覆盖掉。/**1. 结构体的各个成员会占用不同的内存，相互之间是没有影响的。
【C++笔记】初始模版和STL简介
大白的编程日记.
09-28 1167
哈喽，各位小伙伴大家好！上期我们讲了C++的编译器优化和内存管理。今天我们来讲解C++模版和STL库。话不多说，我们直接进入正题！向大厂冲锋！STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
C++中操作符＜＜重载
zhangdaolong
09-26 361
在 C++ 中，
《重生到现代之从零开始的C语言生活》—— 字符函数和字符串函数
yttandb的博客
09-28 1108
字符函数和字符串函数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值