基类与派生类

一

/*
 1.基类和派生类中都没虚函数
  1.派生类的内存布局
  2.Show()同名的函数关系
   overload  重载
    1.相同作用域
   overhide  隐藏 同名函数
   override  覆盖 同名而且参数列表也相同
  3.Show的调用时一个动态的绑定
 Base::
  ma
 mb
 静态的绑定  
 2.基类中有虚函数   派生类中没有虚函数
  1.
  Base::       RTTI class Derive   
   vfptr        0
   ma       &Derive
  vfptr
  mb
  2.
  3.
 3.基类中没有虚函数  派生类中有虚函数
  1.
      vfptr
   Base::
     ma
   mb
  2.隐藏
  3.
*/

构造基类A，BC继承A，D继承BC

#include<iostream>
#include<string>
using namespace std;

class A
{
public:
	int ma;
};
class B : public A
{
public:
	int mb;
};
class C : public A
{
public:
	int mc;
};
class D : public B, public C
{
public:
	int md;
};
int main()
{
	D d;
	d.C::ma;
	return 0;
}

class Base
{
public:
	Base(int data = 0) :ma(data)
	{
		cout << "Base::Base()" << endl;
		Show(); //动态绑定？静态的绑定
		//clear();//vfptr = 0x00000000

	} 
	void clear()
	{
		memcpy(this,0,sizeof(*this));
	}
	virtual ~Base()
	{
		Show();//静态绑定
		cout << "Base::~Base()" << endl;
	}
	void Show()
	{
		cout << "Base::Show()" << endl;
	}
	void Show(int data)
	{
		cout << "Base::Show(int)" << endl;
		//对象是完整
		this->Show();
	}
private:
	int ma;
};
class Derive : public Base
{
public:
	Derive(int data) : mb(data)
	{
		cout << "Derive::Derive()" << endl;
	}
	~Derive()
	{
		cout << "Derive::~Derive()" << endl;
	}
	virtual void Show()
	{
		cout << "Derive::Show()" << endl;
	}
	//virtual void Show(int data)
	//{
	//	cout << "Derive::Show(int)" << endl;
	//}
private:
	int mb;
};
/*
	基类中没有任何的虚函数
	派生类中有一个Show函数是虚函数

	基类的指针指向派生类内存
	派生类内存在堆内存上开辟   基类中用虚析构函数
*/
int main()
{
	Base* pb = new Derive(10);
	/*
		vfptr    new     0x100   0x100  12
		Base::  
		  ma     delete  0x104 
		mb

		Base::
			vfptr
			ma
		mb
	*/
	delete pb;
	return 0;
} 

Base::Base()
Base::Show()
Derive::Derive()
Derive::~Derive()
Base::Show()
Base::~Base()

设置基类animal规定狗和猫的叫声

class Animal
{
public:
	Animal(string name = "") :mname(name){}
	virtual void bark() = 0;//纯虚函数
protected:
	string mname;
};
class Dog : public Animal
{
public:
	Dog(string name) :Animal(name){}
	void bark()
	{
		cout << mname <<":WANG WANG WANG!" << endl;
	} 
};
class Cat : public Animal
{
public:
	Cat(string name) :Animal(name){}
	void bark()
	{
		cout << mname << ":MIAO MIAO MIAO!" << endl;
	}
}; 

/*
	通过传入的对象
	打印对象的叫声
*/
void PrintBark(Animal* animal)
{
	animal->bark();
} 
int main()
{
	Dog* dog = new Dog("dog");
	Cat* cat = new Cat("cat");
	/*                             vftable
		vfptr          vfptr       class Cat
		mname          mname           0
		                           bark();
	*/
/*	int *p1 = (int*)dog;
	int *p2 = (int*)cat;
	int tmp = p1[0];
	p1[0] = p2[0];
	p2[0] = tmp;*/ 

	dog->bark();//动态
	cat->bark();//动态 

	cout << "dog::" << typeid(*dog).name() << endl;
	cout << "cat::" << typeid(*cat).name() << endl;

	PrintBark(dog);
	PrintBark(cat);
	delete dog;
	delete cat;
	return 0;
}

打印结果为

dog:WANG WANG WANG!
cat:MIAO MIAO MIAO!
dog::class Dog
cat::class Cat
dog:WANG WANG WANG!
cat:MIAO MIAO MIAO!

建立bird类让企鹅和鹰来继承

class Bird
{
public:
	Bird(string name) :mname(name){ cout << "Bird::Bird()" << endl; }
	virtual void fly(int height) = 0;
	~Bird()
	{
		cout << "Bird::~Bird()" << endl;
	}
protected:
	string mname;
};
class Penguin : public Bird
{
public:
	Penguin(string name):Bird(name)
	{
		cout << "Penguin::Penguin()" << endl;
	}
	void fly(int height)
	{
		cout << mname << "can not fly" << endl;
	}
};
class Eagle : public Bird
{
public:
	Eagle(string name) : Bird(name)
	{
		cout << "Eagle::Eagle()" << endl;
	}
	void fly(int height)
	{
		cout << mname << "can fly" << height<<"m"<<endl;
	}
};

void ShowFly(Bird* bird)
{
	/*if (typeid(*brid) == typeid(Penguin))
	{
		cout << "can not fly" << endl;
		cout << "fly 0m" << endl;
	}
	else
	{
		brid->fly(10);
	}*/
	/*
		brid 这个实参所指向的vftable中的RTTI和传入的类型实参进行比较
		如果相同转换
		不同  转换  NULL
	*/
	Penguin* pen = dynamic_cast<Penguin*>(bird);
	if (pen == NULL)
	{
		bird->fly(10);
	}
	else
	{
		cout << "can not fly" << endl;
		cout << "fly 0m" << endl;
	}

}
int main()
{
	Penguin* pen = new Penguin("Penguin");
	Eagle* eagle = new Eagle("Eagle");
	ShowFly(pen);
	ShowFly(eagle);
	return 0;
}
/*
	用于纯虚函数的类 叫做 抽象类
	抽象类能不能实例化一个对象？
		不能  只能做指针或者引用
*/

输出结果为

Bird::Bird()
Penguin::Penguin()
Bird::Bird()
Eagle::Eagle()
can not fly
fly 0m
Eaglecan fly10m

class Base
{
public:
	Base(int data = 0) :ma(data)
	{
		cout << "Base::Base()" << endl;
	}
	virtual ~Base()
	{
		
		cout << "Base::~Base()" << endl;
	}
	virtual void Show()
	{
		cout << "Base::Show()" << endl;
	}
	void Show(int data)
	{
		cout << "Base::Show(int)" << endl;
	}
private:
	int ma;
};
class Derive : public Base
{
public:
	Derive(int data) : mb(data)
	{
		cout << "Derive::Derive()" << endl;
	}
	~Derive()
	{
		cout << "Derive::~Derive()" << endl;
	}
private:
	void Show()
	{
		cout << "Derive::Show()" << endl;
	}
private:
	int mb;
};
int main()
{
	Base* p = new Derive(10);
	p->Show();
	/*
		call eax //编译期间 访问限定符的限制  编译
		eax 运行
	*/
	delete p;
	return 0;
}

输出结果为

Base::Base()
Derive::Derive()
Derive::Show()
Derive::~Derive()
Base::~Base()

二

构造一个基类A

class A
{
public:
 A(int data) :ma(data)
 {
  cout << "A::A(int)" << endl;
 }
 
 ~A()
 {
  cout << "A::~A()" << endl;
 }
protected:
 int ma;
};
构造基类B虚继承类B
class B : virtual public A
{
public:
 B(int data) :mb(data), A(data)
 {
  cout << "B::B(int)" << endl;
 }  
 virtual void Show(){}
 ~B()
 {
  cout << "B::~B()" << endl;
 } 
protected:
 int mb;
};
类c同样虚继承类A
class C : virtual public A
{
public:
 C(int data) :mc(data), A(data)
 {
  cout << "C::C(int)" << endl;
 } 
 ~C()
 {
  cout << "C::~C()" << endl;
 }
protected:
 int mc;
};
构造类E
class E
{
public:
 E(int data) :me(data)
 {
  cout << "E::E(int)" << endl;
 }
 ~E()
 {
  cout << "E::~E()" << endl;
 }
protected:
 int me;
};
构造子类D继承BC虚继承E
class D :public B,public C ,virtual public E
{
public:
 D(int data) : A(data), B(data), C(data), E(data)
 {
  cout << "D::D(int)" << endl;
 }
 void Show()
 {
  cout << ma << endl;
 }
 ~D()
 {
  cout << "D::~D()" << endl;
 }
protected:
 int md;
};
/*
构造顺序：
 A()
 B() 
 A()
 C() 
 D()  
     
*/
int main()
{
 D d1(10);
 d1.Show();
 return 0;
}

内存布局为

D::

 B::

 vbptr -->e合并到这

mb

 C::

vbptr

mc

md

E

me

A

ma

输出结果

A::A(int)
E::E(int)
B::B(int)
C::C(int)
D::D(int)
10
D::~D()
C::~C()
B::~B()
E::~E()
A::~A()