立即学习: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