学习笔记(19):c++入门到精通教程 c++11/14/17-友元函数、友元类、友元成员函数

立即学习:https://edu.csdn.net/course/play/9186/191703?utm_source=blogtoedu

#include <iostream>
#include "Human.h"
#include "men.h"
#include "Women.h"
#include"func.h"
#include "A.h"
#include "C.h"

using namespace std;

//void func(const Men &tmpmen)
//{
//    tmpmen.funcmen();
//}
//class C;  //类C声明
//class A
//{
//
//private:
//    int data;
//    friend class C;
//};
//class C
//{
//public:
//    void callCAF(int x, A &a)
//    {
//        a.data = x;
//        cout << a.data << endl;
//    }
//    void callCAF2(A& a)
//    {
//        a.data;
//    }
//
//};
//

 

int main()
{
//    std::cout << "Hello World!\n";
//
//    二:  派生类对象定义时调用构造函数的顺序
//      当定义子类对象时  是要调用父类和子类的构造函数的 而且 父类的构造函数的函数体先执行
//
//
//    三 public 、protected ,private
//    总结 : 三种访问权限
//    men.m_Age = 12;
//    men.m_prol = 14;
//   
//
//    四:函数 遮蔽
//    Men men;
//    men.funcpub();
//    men.funcpub;
//    也就是子类中 如果有了一个同名函数 那么父类中  不管有几个同名函数 子类中都无法访问。
//    如果我们确实是想调用父类中的同名函数  怎么办?
//    (1)  在子类的成员函数中调用 父类名::函数名
//    men.samenamefunc(12);
//
//    (2) using :
//
//    c++11: 让父类同名函数在子类中可见。
//    通过using这个关键字 让父类的同名函数 在子类可见
//
//    men.samenamefunc();
//    men.samenamefunc(12);
//
//    说明这种using 、、、 只能指定函数名  则凡是基类中的public 在子类中都可见
//    引入的主要目的 是用来实现在子类对象中调用父类的重载版本.  该函数在父类的参数和子类中不一样
//
//

        //一:基类指针  派生类
   /* Human* phuman = new Human();
    Men* pmen = new Men;*/

    //新玩法; 父类指针可以new'一个子类对象;  父类指针很强大
    //Human* phuman = new Men;  //这个是可以的;
    //Men* pmen = new Human;
     //phuman->funcHumen();


     //二 :虚函数

    //phuman->eat();  //调用的父类的eat函数 。 因为phuman是父类指针

     // 那如何调用Men和Women中的eat函数。
    //Men* pmen = new Men;
    //pmen->eat();

    //Women* pwomen = new Women;
    //pwomen->eat();

    //Human* phuman2 = new Human;
    //phuman2->eat();
    //一旦某个函数(在基类)
  //  Human* phuman = new Men;
    phuman->eat();  //调用的是父类的
  //  phuman->eat();
  //  phuman->Human::eat();
  //  delete phuman;


  //  phuman = new Women;
  //  phuman->eat();
  //  delete phuman;

  //  phuman = new Human;
  //  phuman->eat();
  //  delete phuman;

    //为了避免你在子类中写错虚函数 ,在C++11里  你可以在函数声明中加上 override关键字
            // 这个关键字用在 “子类”中 而且是虚函数专用
    //override就是用来说明派生类的虚函数  你用这个关键字之后  编译器就会默认你覆盖了 父类的参数


    //final final 也是虚函数专用  用在“父类中” 如果我们在父类的函数声明中 家里final的话  那么任何尝试 覆盖该函数的操作的话 都会出错

    //动态绑定: 运行的时候才决定你的phuman 对象绑定到哪个eat()函数上运行;
            
    //三:多态性


    //四:纯虚函数

    //一旦类里 有纯虚函数了 那么你就不能生成类的对象了
   // Human human;
    //Human *phuman = new Human ; 不合法
    //抽象类的主要目的 是用来统一调用子类对象
    //所以大家记住两点
    //函数纯虚函数的类 叫抽象类 不能用来生成;类对象  主要用于当成基类来生成子类用的
    //
    //Human* phuman = new Men;
    //phuman->eat2();
    
    // Human* phuman = new Women;


//五: 基类的析构函数 一般写成虚函数
//Men men;
//Men* pmen = new Men;
//delete pmen;

//Human* phuman = new Men;
//delete phuman;//没有执行子类的析构函数 坏事

 


//friend
//一 : 友元函数
//public protected,private;
//只要让函数func称为类Men的友元函数  ,那么func这个函数
//Men men;
//func(men); //显示了text

//总结了一下 : 友元函数func(。。。) :是个函数  通过声明为某个类men的友元函数


//二:友元类   类可以把其他的类定义成友元类  如果你是我的友元类  那么你就可以访问我的所有成员

//A a;
//C c;
//c.callCAF(3, a);  //3

//注意每个类都负责自己的友元函数和友元类
// 友元关系不能被继承
//友元关系是单向的  比如上边的类C是类A的友元类
//友元关系是没有传递性的  比如类B是类A的友元类  类C


//三: 友元成员函数
   
A a;
C c;
c.callCAF(3,a);

 

 

//c.h

// day14.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#ifndef __C__
#define __C__

class A;
class C
{

public:
    void callCAF(int x, A &a);
    void callCAF2(int x, A& a);

};

 

 


#endif //~


a.h

// day14.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#ifndef __A__
#define __A__

#include<iostream>

#include"C.h"
class A
{
    friend void C::callCAF(int x, A& a);
    friend void C::callCAF2(int x, A& a);

private:
    int data;

 

};


#endif

 

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页