c++中的友元函数

已于 2022-08-20 21:36:43 修改
阅读量433 收藏 4
点赞数 1
分类专栏： C++学习 文章标签： const成员函数 mutable 友元 封装 C++
于 2022-08-19 17:23:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DUANJIAWEIDUANJIAWEI/article/details/126428321
版权

知识点1【const修饰成员函数】

用const修饰成员函数时，const修饰this指针指向的内存区域，成员函数体内不可以修改本类中的任何普通成员变量，当成员变量类型符前用mutable修饰时例外。

int myFun()const//const修饰的是成员函数
{}//函数内部不能修改，普通成员变量mutable修饰时例外

#include <iostream>

using namespace std;

class Data{
private:
    int data;

    mutable int num;
public:
    //遍历 成员的函数 不会去修改成员的值
    //如果函数不会更改成员数据 就让编译器知道 这是一个const函数
    void myPrintData(void) const{
        //data =10000;//err const修饰函数 函数不能操作普通成员变量
        cout << this->data << endl;
        //cout<<data<<endl;

        //mutable修饰的成员变量 可以修改
        num = 200;
    }

    Data(){
        cout<<"无参构造"<<endl;
    }

    Data(int data){
        this->data =data;
        cout<<"有参构造"<<endl;
       }

    Data(const Data &ob){
        this->data = ob.data;
        cout<<"拷贝构造"<<endl;
    }
    ~Data(){
        cout<<"析构函数"<<endl;
    }
};

void test02(){
    Data ob1(100);
    ob1.myPrintData();
}

int main(int argc, char *argv[])
{
    test02();
    return 0;
}

2、const修饰对象，叫做常对象

#include <iostream>

using namespace std;

class Data{
private:
    int data;

    mutable int num;
public:
    //遍历 成员的函数 不会去修改成员的值
    //如果函数不会更改成员数据 就让编译器知道 这是一个const函数
    void myPrintData(void) const{
        //data =10000;//err const修饰函数 函数不能操作普通成员变量
        cout << this->data << endl;
        //cout<<data<<endl;

        //mutable修饰的成员变量 可以修改
        num = 200;
    }

    //对于普通成员函数，编译器认为存在修改成员变量的可能
    void setData(int data) const{

    }

    Data(){
        cout<<"无参构造"<<endl;
    }

    Data(int data){
        this->data =data;
        cout<<"有参构造"<<endl;
       }

    Data(const Data &ob){
        this->data = ob.data;
        cout<<"拷贝构造"<<endl;
    }
    ~Data(){
        cout<<"析构函数"<<endl;
    }
};

void test03(){
    //常对象
    const Data ob1(100);

    //常对象只能调用const修饰的函数，遍历成员数据
    ob1.myPrintData();
}

int main(int argc, char *argv[])
{
    test03();
    return 0;
}

知识点2【友元】

c++允许友元访问私有数据
友元的语法：
friend关键字只出现在声明处，其他类、类成员函数、全局函数都可以声明为友元，友元函数不是类的成员，不带this指针，友元函数可访问对象任意成员属性，包括私有属性。

1、普通全局函数作为类的友元

#include <iostream>

using namespace std;

class Room{
    //将goodGayVisit作为类的友元函数
    //goodGayVisit访问类中的所有数据，但它不是类的成员
    friend void goodGayVisit(Room &room);
private:
    string bedRoom;
public:
    string sittingRoom;
    Room(){
        this->bedRoom = "卧室";
        this->sittingRoom = "客厅";
    }

};

//普通全局函数作为类的友元
//好基友访问我的房间
void goodGayVisit(Room &room){
    cout << "好基友访问了你的" << room.sittingRoom << endl;
    cout << "好基友访问了你的" << room.bedRoom << endl;
}
int main(int argc, char *argv[])
{
    Room myRoom;
    goodGayVisit(myRoom);
    return 0;
}

运行结果：
在这里插入图片描述

2、类的某个成员作为另一个类的友元

问题1：
在这里插入图片描述
问题2：
在这里插入图片描述
问题3：
在这里插入图片描述
终极代码：

#include <iostream>

using namespace std;
class Room;

class goodGay{
public:
    void goodGayVisit(Room &room);
};

class Room{
    //如果将goodGayVisit函数作为Room类的友元，那么就可以访问Room类的私有数据。
    //一定要记得加类作用域
    friend void goodGay::goodGayVisit(Room &room);
private:
    string bedRoom;
public:
    string sittingRoom;
    Room(){
        this->bedRoom = "卧室";
        this->sittingRoom = "客厅";
    }

};

void goodGay::goodGayVisit(Room &room){
    cout << "好基友访问了你的" << room.sittingRoom << endl;
    cout << "好基友访问了你的" << room.bedRoom << endl;
}

int main(int argc, char *argv[])
{
    Room myRoom;
    goodGay goodGay;
    goodGay.goodGayVisit(myRoom);
    return 0;
}

3、一个类的整体作为另一个类的友元

一个类的所有成员函数，访问另一个类的私有数据

#include <iostream>

using namespace std;
class Room;
class goodGay;

class goodGay{
public:
    void goodGayVisit1(Room &room);
    void goodGayVisit2(Room &room);
};

class Room{
    //如果将goodGayVisit函数作为Room类的友元，那么就可以访问Room类的私有数据。
    //一定要记得加类作用域
    friend class goodGay;
    string bedRoom;
public:
    string sittingRoom;
    Room(){
        this->bedRoom = "卧室";
        this->sittingRoom = "客厅";
    }

};

void goodGay::goodGayVisit1(Room &room){
    cout << "好基友访问了你的" << room.sittingRoom << endl;
    cout << "好基友访问了你的" << room.bedRoom << endl;
}

void goodGay::goodGayVisit2(Room &room){
    cout << "好基友访问了你的" << room.sittingRoom << endl;
    cout << "好基友访问了你的" << room.bedRoom << endl;
}

int main(int argc, char *argv[])
{
    Room myRoom;
    goodGay goodGay;
    goodGay.goodGayVisit1(myRoom);
    goodGay.goodGayVisit2(myRoom);
    return 0;
}

知识点3【封装电视机和遥控器的类】

1、封装电视机的类

class TV{
   enum{on,off}; //电视机开关
   enum{minVol,maxVol = 100};//电视机音量，从0到100
   enum{minChannel=1,maxChannel = 255};//频道从0到255
private:
   int mState;//电视机状态
   int mVolume;//电视机音量
   int mChannel;//电视机频道
public:
   TV(){
       this->mState = off;
       this->mVolume = minVol;
       this->mChannel = minChannel;
   }

   void onOroff(){
       this->mState = (this->mState == on? off:on);
   }
   //加大音量
   void volumeUp(){
       if(this->mVolume < maxVol){
           mVolume++;
       }
   }

   //减小音量
   void volumeDown(){
       if(this->mVolume > minVol){
           mVolume--;
       }
   }

   //增加频道
   void channelUp(){
       if(this->mChannel < maxChannel){
            mChannel++;
       }
   }

   //减小频道
   void channelDown(){
       if(this->mChannel > minChannel){
            mChannel--;
       }
   }

   //显示电视机状态
   void showTV(){
       cout << "电视的状态为" << (this->mState == on? "开机":"关机")<<endl;
       cout << "电视机的音量为" << this->mVolume <<endl;
       cout << "电视机的频道为" << this->mChannel <<endl;
   }
};

int main(int argc, char *argv[])
{
    TV tv = TV();
    tv.onOroff();
    tv.volumeUp();//调四次音量
    tv.volumeUp();
    tv.volumeUp();
    tv.volumeUp();

    tv.channelUp();//调两次频道
    tv.channelUp();
    tv.showTV();
    return 0;
}

运行结果：
在这里插入图片描述

2、设置遥控器的类

class TV{
   friend class Remote;

   enum{on,off}; //电视机开关
   enum{minVol,maxVol = 100};//电视机音量，从0到100
   enum{minChannel=1,maxChannel = 255};//频道从0到255
private:
   int mState;//电视机状态
   int mVolume;//电视机音量
   int mChannel;//电视机频道
public:
   TV(){
       this->mState = off;
       this->mVolume = minVol;
       this->mChannel = minChannel;
   }

   void onOroff(){
       this->mState = (this->mState == on? off:on);
   }
   //加大音量
   void volumeUp(){
       if(this->mVolume < maxVol){
           mVolume++;
       }
   }

   //减小音量
   void volumeDown(){
       if(this->mVolume > minVol){
           mVolume--;
       }
   }

   //增加频道
   void channelUp(){
       if(this->mChannel < maxChannel){
            mChannel++;
       }
   }

   //减小频道
   void channelDown(){
       if(this->mChannel > minChannel){
            mChannel--;
       }
   }

   //显示电视机状态
   void showTV(){
       cout << "电视的状态为" << (this->mState == on? "开机":"关机")<<endl;
       cout << "电视机的音量为" << this->mVolume <<endl;
       cout << "电视机的频道为" << this->mChannel <<endl;
   }
};


class Remote{
private:
    TV *pTV;
public:
    Remote(TV *pTV){
        this->pTV = pTV;
    }
    //音量的加减
    void volumeUp(void){
        this->pTV->volumeUp();
    }

    void volumeDown(void){
        this->pTV->volumeDown();
    }

    //频道的加减
    void channelUp(void){
        this->pTV->channelUp();
    }

    void channelDown(void){
        this->pTV->channelDown();
    }

    //电视开关
    void onOrOff(void){
        this->pTV->onOroff();
    }

    //遥控器频道的设置
    void setChannel(int num){
        //判断频道是否有效
        if(num <= TV::maxChannel && num >= TV::minChannel){
            this->pTV->mChannel = num;
        }
    }

    //遥控器音量的设置
    void setVolume(int num){
        if(num <= TV::maxVol && num >= TV::minVol){
            this->pTV->mVolume = num;
        }
    }

    void showTV(void){
        this->pTV->showTV();
    }

};



int main(int argc, char *argv[])
{
    TV tv = TV();
    tv.onOroff();
    tv.volumeUp();//调四次音量
    tv.volumeUp();
    tv.volumeUp();
    tv.volumeUp();

    tv.channelUp();//调两次频道
    tv.channelUp();
    tv.showTV();

    Remote remote = Remote(&tv);
    remote.volumeUp();
    remote.channelUp();
    remote.showTV();

    remote.setChannel(10);
    remote.setVolume(15);

    remote.showTV();

    return 0;
}

运行结果：
在这里插入图片描述

知识点4【强化类的封装】

myarray.h

#ifndef MYARRAY_H
#define MYARRAY_H


class MyArray
{
private:
    int capacity;//数组总共存放的元素的个数
    int size;//数组实际存放的元素个数
    int *addr;//数组首元素地址
public:
    MyArray();
    MyArray(int capacity);
    ~MyArray();

    //往数组的尾部插入数据
    void pushBack(int data);
    //获得指定位置的数据
    int getData(int pos);
    //修改指定位置的值
    void setData(int pos,int data);
    //获取数组的容量（能存放的最大元素个数）
    int getCapacity(void);
    //获取数组的实际大小(实际元素的个数)
    int getSize(void);
    //打印数组
    void printMyArray(void);
};

#endif // MYARRAY_H

myarray.cpp

#include <iostream>
#include "myarray.h"

using namespace std;

MyArray::MyArray()
{
    this->capacity = 15;//数组总共存放的元素的个数
    this->size = 0;//数组实际存放的元素个数
    addr = new int[this->capacity];//数组首元素地址
}

MyArray::MyArray(int capacity)
{
    this->capacity = capacity;//数组总共存放的元素的个数
    this->size = 0;//数组实际存放的元素个数
    addr = new int[this->capacity];//数组首元素地址
}

MyArray::~MyArray()
{
	if(this‐>addr != NULL){
		delete [] this‐>addr;
		this‐>addr = NULL;
	}
}

void MyArray::pushBack(int data){
    if(this->size >= this->capacity){
        cout<<"数组已满"<<endl;
        return;
     }
     addr[this->size] = data;
     this->size++;

}

int MyArray::getData(int pos){
    if(pos >= this->size) {
        cout <<"位置无效" << endl;
        return -1;
    }

    return addr[pos];
}

void MyArray::setData(int pos, int data){
    if(pos >= this->size) {
        cout <<"位置无效" << endl;
        return;
    }
addr[pos] = data;
}

int MyArray::getCapacity(){
    return this->capacity;
}

int MyArray::getSize(){
    return this->size;
}

void MyArray::printMyArray(){
    int i=0;
    for(i=0;i<this->size; i++){
        cout<<this->addr[i]<<" ";
    }
    cout<<endl;
}

main.cpp

#include <iostream>
#include "myarray.h"

using namespace std;

int main(int argc, char *argv[])
{
    MyArray arr1;
    cout<<"容量:"<<arr1.getCapacity()<<endl;
    cout<<"大小:"<<arr1.getSize()<<endl;

    MyArray arr2(50);
    cout<<"容量:"<<arr2.getCapacity()<<endl;
    cout<<"大小:"<<arr2.getSize()<<endl;

    //往数组中插入20个数据
    int i=0;
    for(i=0;i<20;i++){
        arr2.pushBack(i);
    }
    cout<<"容量:"<<arr2.getCapacity()<<endl;
    cout<<"大小:"<<arr2.getSize()<<endl;
    //遍历数组
    arr2.printMyArray();

    //更改pos=9的值 2000
    arr2.setData(9,2000);
    arr2.printMyArray();

    //得到下标为9的值
    cout<<arr2.getData(9)<<endl;//
    return 0;
}

运行结果：
在这里插入图片描述

米兰的小红黑
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++友元函数简析
wjzjj的博客
03-30 497
1.友元函数的基本介绍 (1)友元函数是可以直接访问类的私有成员的非成员函数（只有类的成员函数才能访问类中的私有成员）。 友元函数是定义在类外的普通函数，不属于任何类，但需要在类的定义中加以声明，声明时只需在友元函数的名称前加上关键字friend 。 定义格式：friend+返回类型+函数名+参数列表 例如：friend void Show（inta）; (2)在类外实现时不用类的作用域
C++友元函数
BYR_SYR的专栏
01-28 1893
呵呵，好久没来了，最近在复习一下C++内容，在此分类谈一下C++一些容易迷惑技术人员的问题，今天主要谈一下C++的友元函数。首先，大家肯定会发问，什么是友元函数。友元函数是这样一种函数，它并不是某个类的成员函数。但仍可以访问这个类的对象的私有成员变量。一般我们要声明一个友元函数，我们会将这个友元函数定义在这个类里面。以friend关键字开头，如图Fig1.   操作符的重载就是一个友元函
C++之友元函数
热门推荐
m0_59052131的博客
10-29 2万+
友元函数：友元函数的定义、分类、三种友元函数举例，代码注意点，判断谁是谁的友元函数或类
【C++】友元--最全解析（友元是什么？我们应该如何理解友元？友元可以应用在那些场景？）
最新发布
weixin_45031801的博客
04-22 1441
在C++编程语言中，友元函数（Friend Function）是一种特殊的函数，具有访问类中私有成员和保护成员的权限，尽管它不是类的成员函数。友元函数的存在使得类的设计更加灵活，能够在需要时授予外部函数访问类的私有成员的能力。本文将详细介绍C++中的友元函数，包括其定义、使用场景、优缺点以及示例。
【C++】友元函数 ( 友元函数简介 | 友元函数声明 | 友元函数语法 | 友元函数声明不受访问控制限制 | 友元函数参数要求 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
09-27 7779
一、友元函数简介 二、友元函数声明 1、友元函数语法 2、友元函数声明不受访问控制限制 3、友元函数参数要求 4、友元函数示例 三、完整代码示例 - 友元函数
C++ 详解友元函数
yn_zi的博客
06-24 3478
友元类（Friend Class）是C++中的另一个重要概念，它允许一个类将另一个类声明为自己的友元，从而使得被声明为友元的类可以访问该类的私有成员。比如在只声明B是A友元的情况下，B可以访问A的私有成员，但是A却不可以访问B的私有成员，即A不是B的友元。友元函数提供了一种在需要时访问类的私有成员的机制，但应该慎重使用，因为过多的友元函数可能破坏类的封装性。(1)友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。:如果B是A的友元，C是B的友元，则不能说明C是A的友元。
【C++入门】友元函数详解（定义、实现、优缺点）
weixin_42031299的博客
11-05 1万+
(1)在类中用friend关键字去声明函数/类，则这个函数/类就会变成友元函数/友元类；(2)友元函数/友元类的声明位置没有要求，可以在private、protected、public权限区，效果都是一样的；(3)友元函数/友元类是单向的，A在B类中被声明为友元函数/友元类，表示A是B的友元函数/友元类，但B不是A的友元类函数/友元类；(4)友元函数/友元类具有和类成员一样的权限，可以访问protected和private权限的成员，但不是类的成员；
关于C++中的友元函数的一些总结
09-05
在C++编程语言中，友元函数是一种特殊类型的函数，它可以访问类的私有和保护成员，打破了封装性，但提供了更高的灵活性。以下是对C++中友元函数的详细总结： 1. **友元函数的基本概念** - 友元函数的引入主要是...
C++之友元：友元函数和友元类详解
01-20
二、友元函数友元函数在类作用域外定义，但它需要在类体中进行说明为了与该类的成员函数加以区别，定义的方式是在类中用关键字friend说明该函数，格式如下： friend 类型 友元函数名(参数表);友元的作用在于提高...
C++ 友元函数的函数指针
12-30
　讲友元之前先讲普通的成员函数的函数指针 　<code class=sourceCode>class Std_interface { 　public: 　virtual void suspend() = 0; 　}; 　// define the pointer of function 　typedef void (Std_...
c++友元函数与友元类的深入解析
09-05
C++中的友元机制是为了突破封装的...总结来说，友元函数和友元类是C++中增强代码功能和效率的工具，但需谨慎使用，以防止过度破坏封装原则。在设计类和类的相互关系时，应充分考虑友元带来的影响，以达到良好的平衡。
简要介绍C++编程中的友元函数和友元类
09-03
在C++编程中，友元函数和友元类是两个重要的概念，它们打破了封装的常规规则，允许外部函数或类访问通常被保护的私有和受保护的成员。虽然在实际开发中使用较少，但在某些特定场景下，它们能够提供更加灵活的代码...
关于C++中的友元函数的总结
weixin_33830216的博客
11-22 1469
1.友元函数的简单介绍 1.1为什么要使用友元函数 在实现类之间数据共享时，减少系统开销，提高效率。如果类A中的函数要访问类B中的成员（例如：智能指针类的实现），那么类A中该函数要是类B的友元函数。具体来说：为了 使其他类的成员函数直接访问该类的私有变量。即：允许外面的类或函数去访问类的私有变量和保护变量，从而使两个类共享同一函数。 实际上具体大概有下面两种情况需要使用友元函数：（1）...
C++——友元（友元函数、友元类和友元成员函数详解）
qq_57737603的博客
08-18 3716
友元函数是在一个类中声明的一个非成员函数，但在类的内部声明该函数为友元。这意味着该函数可以访问该类的私有成员，包括私有变量和私有函数。友元函数的声明通常位于类的声明中，但其实现则位于类外部。1、友元函数：通过friend+普通函数友元函数是在一个类中声明的非成员函数，但在类的内部声明该函数为友元。这使得该函数可以访问该类的私有成员。private:public:// 声明友元函数// Getter函数// 友元函数实现
C++中友元【详细讲解】
weixin_45688108的博客
10-12 1167
本篇文章主要讲述了友元的概念及其使用，文章中含有实例代码，希望读者可以自己动手实现一下，有助于理解友元的相关知识。
C++ —— 友元函数
柚咖小窝
03-27 8677
C++ 控制对类对象私有部分的访问。通常，公有类方法提供唯一的访问途径，但是有时候这种限制太严格，以致于不适合特定的编程问题。在这种情况下，C++ 提供了另外一种形式的访问权限：友元。友元有三种形式 —— 友元函数、友元成员函数、友元类。这里只介绍友元函数。 当函数被声明为类的友元函数，可以赋予该函数与类的成员函数相同的访问权限。 为什么需要友元函数 在为类重载二元运算符时常常需要用到友元函数。 例如，为一个时间类 Time 重载乘法运算符，使其可以乘以一个实数，部分代码如下所示： class Time {
C++语言学习（七）——友元
weixin_34395205的博客
07-15 309
C++语言学习（七）——友元 一、友元简介 1、友元简介 面向对象编程的类的设计机制实现了数据的隐藏与封装，类的成员变量一般定义为私有成员，成员函数一般定义为公有的，是类与外部的通信接口。在实践中，类外的某些函数需要频繁地访问类的成员变量，可以将类外的函数定义为类的友元函数。除了友元函数外，还有友元类，两者统称为友元。友元的作用是提高了程序的运行效率（即减少了类型检查和安全性检查等都需要时间开销）...
C++的友元函数代码示例
09-13
以下是一个示例代码，演示如何在C++中定义和使用友元函数： ```cpp #include <iostream> class MyClass { private: int num; public: MyClass(int n) : num(n) {} friend void friendFunc(MyClass obj); // 声明友元函数 }; // 定义友元函数 void friendFunc(MyClass obj) { std::cout << "友元函数访问私有成员 num：" << obj.num << std::endl; } int main() { MyClass obj(42); friendFunc(obj); // 调用友元函数 return 0; } ``` 在这个示例中，我们创建了一个名为`MyClass`的类，它有一个私有成员变量`num`。我们希望能够在类外部访问这个私有成员变量，因此我们声明了一个友元函数`friendFunc`。 在`MyClass`类中，我们使用`friend`关键字声明了`friendFunc`函数为`MyClass`的友元函数。这意味着`friendFunc`可以访问`MyClass`的私有成员。 在`main`函数中，我们创建了一个`MyClass`对象`obj`，然后调用了友元函数`friendFunc(obj)`。友元函数可以直接访问`obj`的私有成员变量`num`并打印出来。 输出结果将是： ``` 友元函数访问私有成员 num：42 ``` 请注意，友元函数不是类的成员函数，但它可以访问类的私有成员。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值