精华内容
下载资源
问答
  • 友元函数、友元类

    2017-03-07 20:13:53
    是一类需要与另一类建立联系,保持调用关系,则也可以设为该类的友元类,友元可以增加代码的灵活性,提高运行效率(类型检查和数据成员和成员函数的安全性检查会消耗时间),但同样破坏了C++的封装性

    由于采用类的机制,实现了数据的封装和隐藏,类的数据成员一般设为私有类型,成员函数则为公有类型,提供与外界连接的接口,但有时需要非类成员函数频频访问类内数据成员,则将其设为该类的友元函数,简称友元,同样还有友元类,是一类需要与另一类建立联系,保持调用关系,则也可以设为该类的友元类,友元可以增加代码的灵活性,提高运行效率(类型检查和数据成员和成员函数的安全性检查会消耗时间),但同样破坏了C++的封装性,使其能够访问该类的私有成员。


    友元可以分为友元函数和友元类,友元函数又可以分为友元全局函数和友元成员函数,友元关系不可传递,单向性。友元其实破坏了C++的封装性,是对封装的补充。

    友元全局函数:

    在主函数前面声明定义时加上friend关键字,在其关联的类的关系运算符前加上此函数的声明,并加上关键字friend

    如:

    friend void display() { }

    class Person

    {

    friend void display();

    public:

    }

    友元成员函数:

    在与之关联成友元的类中要写上 如:friend void Match::printtime(Time &t);

    友元类:

    friend class A 的形式

    展开全文
  • 私有成员,仅类内可见,类成员默认是私有protected :受保护的成员,类内子类可见public :公有成员,对外可见访问修饰符作用范围是到下个访问修饰符或者到类结尾友元函数友元函数(关键字friend)...

    上一篇介绍了一下类中的构造(构造和拷贝构造)和析构函数,这一篇开始介绍一下类中其他的函数

    如有侵权,请联系删除,如有错误,欢迎大家指正,谢谢

    0. 友元函数

    类的访问修饰符

    1. private :私有成员,仅类内可见,类成员默认是私有的
    2. protected :受保护的成员,类内和子类可见
    3. public :公有成员,对外可见
    4. 访问修饰符的作用范围是到下个访问修饰符或者到类的结尾

    友元函数

    • 友元函数(关键字friend)可以访问类的私有成员(private)
    • 在类内声明友元函数(可以是主函数也可以是其他函数),类内的所有成员对友元函数是可见的
    • 还可以在类内声明友元类,类内的所有成员对友元类都是可见的
    #include 

    注意

    1. 类的友元函数不受类的访问修饰符的限制(可以写在 private 的作用范围内,可以写在 protected 的作用范围内,可以写在 public 的作用范围内)
    2. 友元函数和友元类会破坏类的封装性,通常情况下会定义 Get...(); Set...(); 这类接口函数对类的私有成员进行访问
    3. 类外访问私有成员用友元函数,类外访问受保护成员用友元函数或子类

    1. 常函数

    • 常函数可以使用类的数据成员,但不能修改数据成员(这里说的是不能修改类的数据成员,但是常函数可以对在函数体中定义变量和形参进行修改,只是不能修改类的数据成员)
    • 构造函数和析构函数不能是常函数
    • 常函数的 this 指针是 const CStu*
    • 常对象只能调用常函数,不能调用普通函数
    #include 
    • 类中同时含有同一个函数的const和non-const版本,普通对象优先调用non-const版本,常量对象优先调用const版本
    class 

    2. 内联函数

    内联函数和常规函数的区别

    • 常规函数:调用时根据函数地址跳转到函数代码空间,执行指令,执行结束,再跳转到调用位置,频繁的函数调用(跳转和保护现场)给系统带来了一定的开销
    • 内联函数:在函数的声明和定义的位置同时加上 inline ,将函数定义为内联函数,只在声明位置写 inline 是不管用的,在函数编译的时候调用内联函数的位置会被相应的代码替换,运行时就避免了函数调用的跳转和保护现场给系统带来的开销

    如何选择是否用内联函数

    • 内联函数与常规函数相比,它是用了相应的代码来替换掉调用,也就是每一个调用内联函数的位置都会替换为一段代码,内联函数就被复制了多份,相应的代码量也就增加了,会占用更多的程序代码区的空间,与常规函数相比,内联函数是用空间换时间,如果一个函数代码比较少,流程简单,但是调用频繁,可以考虑使用内联函数

    注意

    1. 内联函数和宏函数有些类似,都是在程序编译的时候进行代码段的替换,但内联函数解决了宏函数的一些缺点,内联函数可以调试,而且内联函数可以作为类的成员函数,访问类的私有成员
    2. 即使是将函数定义为内联函数,编译器也不一定会将其作为内联函数进行编译,若函数体比较大,或者有递归之类的复杂结构,编译器一般不会将其编译为内联函数,反而对于一些函数体比较小,结构简单,调用频繁的普通函数,编译器可能将其优化为内联函数
    3. 对于函数体比较大,或者含有递归等复杂结构的函数,一般不能定义为内联函数,即使定义了编译器也不会认的,当做普通函数处理了
    4. 内联函数可以作为类的成员函数,也可以不作为成员函数单独出现
    展开全文
  • 有关c++类:定义一个类,声明一个全局函数(该函数不能为友元或者是成员函数)(程序如下),它没有wrong,实现一个简单功能,但是运行结果不正确,原因到底出在什么地方呢?有哪位大佬帮我看一下,谢谢啦~#...
    

    有关c++类:定义一个类,声明一个全局函数(该函数不能为友元或者是成员函数)(程序如下),它没有wrong,实现一个简单的功能,但是运行结果不正确,原因到底出在什么地方呢?有哪位大佬帮我看一下,谢谢啦~微笑

    #include<iostream>
    using namespace std;
    class words
    {
     public:
      void input();
      char getc()
      {
       for(int i=0;i<30;i++)
       {
        return a[i];
       }
       
      }
     private:
      char a[30];
    };
    void words::input()
    {
     cout<<"请输入这些字母"<<endl;
     for(int i=0;i<30;i++)
     {
      cin>>a[i];
     }
    }
    char output(words &b)
    {
     for(int i=0;i<30;i++)
     {
      if(b.getc()>='a'&&b.getc()<='z')
      {
       cout<<b.getc();                //我感觉问题出在这儿,但是我不太清楚这儿为什么错了
      }
      else
      continue;
     }
    }

    int main()
    {
     words w;
     w.input();
     output(w);
     return 0;
    }



    展开全文
  • 私有成员,仅类内可见,类成员默认是私有protected :受保护的成员,类内子类可见public :公有成员,对外可见访问修饰符作用范围是到下个访问修饰符或者到类结尾友元函数友元函数(关键字friend)...

    上一篇介绍了一下类中的构造(构造和拷贝构造)和析构函数,这一篇开始介绍一下类中其他的函数

    如有侵权,请联系删除,如有错误,欢迎大家指正,谢谢

    0. 友元函数

    类的访问修饰符

    1. private :私有成员,仅类内可见,类成员默认是私有的
    2. protected :受保护的成员,类内和子类可见
    3. public :公有成员,对外可见
    4. 访问修饰符的作用范围是到下个访问修饰符或者到类的结尾

    友元函数

    • 友元函数(关键字friend)可以访问类的私有成员(private)
    • 在类内声明友元函数(可以是主函数也可以是其他函数),类内的所有成员对友元函数是可见的
    • 还可以在类内声明友元类,类内的所有成员对友元类都是可见的
    #include <iostream>
    
    using namespace std;
    
    class Test {
    public:
        Test(int n, double d) :
            n(n),
            d(d)
        { }
    
        friend int main();            // 声明主函数为友元函数,说到底主函数也是函数
        friend int getInt();          // 声明一般函数为友元函数,用法与其他函数一样,只是需要在类内声明一下
        friend double getDou(Test t); // 带有形参的友元函数
        friend class A;               // 类内声明友元类,类内所有成员对友元类都是可见的
    
    protected:
        double d;
    
    private:
        int n;
    };
    
    class A {
    public:
        void show() {
            Test test(2, 5.5);
            cout << "class A: " << test.d << " " << test.n << endl;
        }
    };
    
    int getInt() {
        Test test(10, 3.4);
        return test.n;
    }
    
    double getDou(Test t) {
        return t.d;
    }
    
    int main() {
        Test test(2, 1.2);
        cout << "friend main:" << test.d << " " << test.n << endl;
        cout << "friend getDou: " << getDou(test) << endl;
        cout << "friend getInt: " << getInt() << endl;
        A a;
        a.show();
        system("pause");
        return 0;
    }
    

    注意

    1. 类的友元函数不受类的访问修饰符的限制(可以写在 private 的作用范围内,可以写在 protected 的作用范围内,可以写在 public 的作用范围内)
    2. 友元函数和友元类会破坏类的封装性,通常情况下会定义 Get...(); Set...(); 这类接口函数对类的私有成员进行访问
    3. 类外访问私有成员用友元函数,类外访问受保护成员用友元函数或子类

    1. 常函数

    • 常函数可以使用类的数据成员,但不能修改数据成员(这里说的是不能修改类的数据成员,但是常函数可以对在函数体中定义变量和形参进行修改,只是不能修改类的数据成员)
    • 构造函数和析构函数不能是常函数
    • 常函数的 this 指针是 const CStu*
    • 常对象只能调用常函数,不能调用普通函数
    #include <iostream>
    
    using namespace std;
    
    class Test {
    public:
        Test(int n, double d) :
            n(n),
            d(d)
        { }
    
        void show() {
            cout << "show func:" << ++n << endl;    // 非 常函数可以正常修改类的数据成员
        }
    
        void func1() const {
            int i1 = 0;
            cout << "const func1: " << ++i1 << endl; // 常函数可以修改函数体内定义的变量
            cout << "const func1: " << ++n << endl;  // 报错,不可以修改
        }
    
        void func2() const;
    
    private:
        int n;
        double d;
    };
    
    void Test::func2() const {
        int i2 = 0;
        cout << "const func2: " << ++i2 << endl; // 常函数可以修改函数体内定义的变量
        cout << "const func2: " << n << endl;    // 报错,不可以修改
    }
    
    int main() {
        Test test(10, 3.4);   // 实例化一个普通对象,可以调用常函数和非 常函数
        test.show();
        test.func1();
        test.func2();
    
        const Test t(2, 3.5); // 实例化一个常对象,只能调用常函数
        t.show(); // 报错,不能调用非常函数
        t.func1();
        t.func2();
        system("pause");
        return 0;
    }
    
    • 类中同时含有同一个函数的const和non-const版本,普通对象优先调用non-const版本,常量对象优先调用const版本
    class Test {
    public:
    	Test() : n(2) {
    
    	}
    	void show() {
    		cout << "non-const: " << n << endl;
    	}
    	void show() const {
    		cout << "const: " << n << endl;
    	}
    private:
    	int n;
    };
    
    Test t;
    t.show();
    const Test ct;
    ct.show();
    
    // 运行结果:
    // non-const: 2
    // const: 2
    

    2. 内联函数

    内联函数和常规函数的区别

    • 常规函数:调用时根据函数地址跳转到函数代码空间,执行指令,执行结束,再跳转到调用位置,频繁的函数调用(跳转和保护现场)给系统带来了一定的开销
    • 内联函数:在函数的声明和定义的位置同时加上 inline ,将函数定义为内联函数,只在声明位置写 inline 是不管用的,在函数编译的时候调用内联函数的位置会被相应的代码替换,运行时就避免了函数调用的跳转和保护现场给系统带来的开销

    如何选择是否用内联函数

    • 内联函数与常规函数相比,它是用了相应的代码来替换掉调用,也就是每一个调用内联函数的位置都会替换为一段代码,内联函数就被复制了多份,相应的代码量也就增加了,会占用更多的程序代码区的空间,与常规函数相比,内联函数是用空间换时间,如果一个函数代码比较少,流程简单,但是调用频繁,可以考虑使用内联函数

    注意

    1. 内联函数和宏函数有些类似,都是在程序编译的时候进行代码段的替换,但内联函数解决了宏函数的一些缺点,内联函数可以调试,而且内联函数可以作为类的成员函数,访问类的私有成员
    2. 即使是将函数定义为内联函数,编译器也不一定会将其作为内联函数进行编译,若函数体比较大,或者有递归之类的复杂结构,编译器一般不会将其编译为内联函数,反而对于一些函数体比较小,结构简单,调用频繁的普通函数,编译器可能将其优化为内联函数
    3. 对于函数体比较大,或者含有递归等复杂结构的函数,一般不能定义为内联函数,即使定义了编译器也不会认的,当做普通函数处理了
    4. 内联函数可以作为类的成员函数,也可以不作为成员函数单独出现
    展开全文
  • [C++系列] 28. friend友元

    2019-04-10 08:07:51
    友元分为:友元函数和友元类 友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度(相互之间的联系,高内聚、低耦合。即把强相关的东西打包在一起,把不相关的东西令其各自不要产生影响)其破坏了...
  • 实现运行时多态关键首先是要说明虚函数,另外,必须用类指针调用派生类不同实现版本4:注意点:①:一个虚函数,在派生类层界面相同重载函数都保持虚特性 ②:虚函数必须是类的成员函数 三:不能将友元说明...
  • 对象成员(整理)

    千次阅读 2020-08-03 12:39:53
    一个类的成员函数是另一个类的友元成员 一个类定义在另一个类说明中,即类嵌套 一个类作为另一个类派生类 什么是对象成员? 答:自定义类数据成员是另一个类对象(两个角色) 例如: 类B对象是类A一个...
  •  本文主要介绍类的友元函数、虚函数、静态成员、const对象volatile对象以及指向类成员指针。  一、友元函数  当把类中成员访问权限定义为私有或者保护时,在类外面,只能通过该类的成员函数来...
  • C++ 面试准备【一】

    2019-09-23 19:18:05
    目录 关键字与操作符 ...友元函数和友元类 多态与虚函数 C++多态性实现原理 动态绑定 虚函数表和虚函数指针 纯虚函数 override和final 回避虚函数机制 不能声明为虚函数的成员函数 override和ov...
  • 第五章 C++程序结构 清华大学 郑 莉 本章主要内容 作用域与可见性 对象生存期 数据与函数 静态成员 共享数据保护 友元 编译预处理命令 多文件结构工程 一作用域与可见性 作用域讨论是标识符有效范围可见...
  • 一、类对象1、静态成员变量2、静态成员函数3、单例模式练习1:——主席案例练习2:打印机案例4、C++面向对象模型初探5、this指针6、空指针访问成员函数7、常函数与常对象8、全局函数做友元函数9、整个类做友元类10...
  • C++之多继承

    2017-09-23 17:58:26
    1.基础知识1.1 类之间的关系has-A,uses-A is-Ahas-A 包含关系,用以描述一个类由多个“部件类”构成...通过类之间成员函数的相互联系,定义友元函数友元类或对象参数传递实现。 is-A 机制称为继承。关系具有传递
  • 式定义时,将如何隐式地生成成员函数以及这些成员函数的行为。读者还将通过使用对象指针,了解队列 模拟问题,扩充类方面的知识。 第13章:类继承 在面向对象编程中,继承是功能最强大的特性之一,通过继承,...
  • C++中继承

    2017-01-12 23:58:00
    目录: 继承基本概念 继承中访问控制方式 继承中构造函数和析构函数 类型兼容性原则 ...一,继承基本概念 ...use-A,一个类使用另一个类,通过类之间的成员函数相互联系,定义友元或者...
  • 式定义时,将如何隐式地生成成员函数以及这些成员函数的行为。读者还将通过使用对象指针,了解队列 模拟问题,扩充类方面的知识。 第13章:类继承 在面向对象编程中,继承是功能最强大的特性之一,通过继承,...
  • 式定义时,将如何隐式地生成成员函数以及这些成员函数的行为。读者还将通过使用对象指针,了解队列 模拟问题,扩充类方面的知识。 第13章:类继承 在面向对象编程中,继承是功能最强大的特性之一,通过继承,...
  • C++多继承

    2017-11-23 20:51:29
    多继承1.基础知识1.1 类之间的关系has-A,uses-A is-Ahas-A包含关系,用以描述一个...通过类之间成员函数的相互联系,定义友元函数友元类或对象参数传递实现。is-A机制称为继承。关系具有传递性,不具有对称性。1....
  • 17多继承

    2017-06-01 12:48:58
    多继承多继承 基础知识 派生类的访问控制 继承中的构造析构 多继承 1.基础知识1.1 类之间的关系has-A,uses-A is-Ahas-A 包含关系,用以描述一个类由多个“部件类...通过类之间成员函数的相互联系,定义友元函数
  • 14 - 继承派生

    2019-08-08 10:46:49
    继承概念 面向对象程序设计有四个主要特点:抽象、封装、继承多态。要较好的进行面向对象程序设计,还必须了解面向对象程序设计两...通过类之间成员函数的互相联系,定义友元或者对象参数传递实现。 继承关系,...
  • 继承

    2018-07-01 22:22:43
    这种关系通过类之间成员函数的相互联系,定义友元函数过对象参数传递来实现。is-a表示一种分类方式,描述类的抽象层次关系。is-a机制称为“继承”。由多个类派生一个新的类的方法,称为“多继承”。类的包含类的...
  • use-A,一个类使用另一个类,通过类之间的成员函数相互联系,定义友元或者通过传递参数方式来实现。is-A,即继承关系,关系具有传递性。(2) 继承相关概念万事万物皆有继承这个现象,所谓继承就是一个类继承了...
  • 类学习之进修

    2019-06-24 00:23:42
    在之前对象学习中,对一些概念,如数据抽象、封装、struct、this指针、访问器修改器、友元、static成员、析构构造函数都有相对了解,在这一阶段学习之后,这些概念得到运用并且能够在自己手中得到“升华...
  • 21天学通C++ (中文第五版)

    热门讨论 2010-06-23 16:57:03
    12.3 构造函数和析构函数的继承性 12.4 覆盖基类函数 12.4.1 隐藏基类方法 12.4.2 调用基类方法 12.5 虚方法 12.5.1 虚函数的工作原理 12.5.2 通过基类指针访问派生类的方法 12.5.3 切除 12.5.4 创建虚析构...
  • C++中继承及virtual小结

    千次阅读 2018-04-04 18:01:17
    use-A,一个类使用另一个类,通过类之间的成员函数相互联系,定义友元或者通过传递参数方式来实现。(组合不同)is-A,即继承关系,关系具有传递性。继承特点子类拥有父类所有属性方法(除了...
  • 本片博客是作者在学习c++的过程中的笔记记录,希望各位读者一起学习交流 文章目录继承 继承 继承概念 类之间的关系(has-A、uses-A、is-A) ...通过类之间成员函数的相互联系,定义友元或对象参数传递实现 is-A...
  • c++之继承一

    2019-10-04 20:15:48
    has-A,uses-A is-A  has-A : 包含关系,用以描述一个类由多个“部件类”...通过类之间成员函数的相互联系,定义友元或对象参数传递实现。  is-A : 机制称为“继承”。关系具有传递性,不具有对称性。 ...
  • 3.8.5 使用成员函数的算法 56 3.8.6 标准库算法 56 3.9 数学 57 3.9.1 复数 57 3.9.2 向量算术 57 3.9.3 基本数值支持 58 3.10 标准库功能 58 3.11 忠告 58 第一部分 基本功能 第4章 类型声明 63 4.1 ...

空空如也

空空如也

1 2
收藏数 34
精华内容 13
关键字:

友元函数和成员函数的联系