【c++】继承

C++面向对象的三大特性:封装/继承/多态
继承(是):产生了一个新类,新类不仅具有父类的特性,还具有属于自己的特性;

1.继承的定义:
　class 子类名 : 派生权限1 父类名1,派生权限2 父类名2…
　{
　　 访问权限:
　 　成员;
　};
　
2.父类成员被子类继承后在子类中的访问权限:
父类成员访问权限: public　 　protected　 private
派生权限:
public　　　　　　public 　　protected　不可访问
protected　　　　protected　protected　不可访问
private　　　　　　private 　private　　 不可访问

3.子类的内存:父类的内存 + 独有的内存

4.构造函数调用顺序:父类 - 子类
　 析构函数调用顺序:子类 - 父类
　 调用父类的带参构造函数:成员初始化列表
　 构造函数():父类名(实参表);
　
5.父类与子类赋值关系:
　 1.子类对象可以给父类对象赋值,父类对象不可以给子类对象赋值;
　 2.父类指针可以指向子类的对象,子类指针不可以指向父类的对象;
　
6.二义性:当子类中出现和父类中同名的成员时;
　 调用某一个类的方法:　类名::

	//构造函数:Animal无参-Cat的无参
	//析构函数:Cat析构-Animal析构
	Cat cat;
	//构造函数:Animal无参-Cat的无参-animal拷贝构造-animal析构-cat析构-Animal析构
	Animal animal =cat;
	

	//构造:Animal无参 - Cat无参
	//析构:Animal析构(只会调用父类的析构函数)
	Animal* pAnimal = new Cat;//父类指针指向子类对象
	pAnimal->callMe();//看指针类型 I'm Animal
	delete pAnimal;//看指针类型
	pAnimal = nullptr;

	//父类无参-子类无参-i am cat - i am animal
	Cat* pCat = new Cat;
	pCat->callMe();//看指针类型 I'm Cat
	pCat->Animal::callMe();//显式调用父类的方法
	

animal.h
#pragma once
enum Sexy
{
	MALE,//公
	FEMALE//母
};
//动物类
class Animal
{
public:
	Animal();
	Animal(Sexy s);//带参构造
	Animal(const Animal& ref);//拷贝构造函数
	Animal& operator=(const Animal& other);//赋值函数
	~Animal();
public:
	void callMe();
public:
	Sexy sex;//动物的性别
};
--------------------------------------------------------------
cat.h
#pragma once
#include "Animal.h"
enum Hair
{
	LOW,
	HIGH
};
//Cat类继承自Animal类
//Animal类派生出Cat类
//Cat是Animal的子类,Animal是Cat的父类
//Cat是Animal的派生类,Animal是Cat的基类;
//Cat存在性别的属性(父类) + 毛发多少(独有的属性);
class Cat : public Animal
{
public:
	Cat();
	Cat(Sexy s,Hair h);//带参构造
	Cat(const Cat& ref);//拷贝构造函数
	Cat& operator=(const Cat& other);//赋值函数
	~Cat();
public:
	void callMe();
private:
	//Sexy sex;
	Hair hair;
};
------------------------------------------------------------------
cat.cpp
#include "Cat.h"
#include <iostream>
using namespace std;

Cat::Cat()
//先分配父类的内存,再分配自己的内存
{
	cout << "调用了Cat的无参构造函数" << endl;
}


Cat::Cat(Sexy s, Hair h)
	:hair(h), Animal(s) //调用Animal的带参构造函数
{
	cout << "调用了Cat的带参构造函数" << endl;
}

Cat::Cat(const Cat& ref)
	: hair(ref.hair),Animal(ref) //调用Animal的拷贝构造函数
{
	cout << "调用了Cat的拷贝构造函数" << endl;
}

Cat& Cat::operator=(const Cat& other)
{
	hair = other.hair;
	cout << "调用了Cat的赋值函数" << endl;
	return *this;
}

Cat::~Cat()
{
	cout << "调用了Cat的析构函数" << endl;
}
//先释放独有的成员的内存+父类的内存

void Cat::callMe()
{
	cout << "I'm Cat" << endl;
}
----------------------------------------------------------------------
	
	//构造函数:Animal带参-Cat带参
	//析构函数:Cat析构-Animal析构
	Cat cat1(FEMALE,LOW);
	
	cout << sizeof(Cat) << endl;//8(枚举都是4个字节)