c++ 多态

#include <iostream>
using namespace std;
//赋值兼容性原则（把子类对象赋给父类指针或引用）
//函数重写 
//这就是面向对象的新需求
//如果传来子类对象，那么执行子类函数
//多态  c++ 编译器提供的多态方案是虚函数
class Parent
{
public:
	Parent(int a=0)
	{
		this->a=a;
	}
	virtual	void print()
	{
	   cout<<"a"<<a<<endl;
	}
private :
	int a;
};
class Child: public Parent
{
public:
	Child(int b=0)
	{
	  this->b=b;

	}
	void print()
	{
	   cout<<"b"<<b<<endl;
	}
private:
	int b;
};
//c++ 是默认是静态编译语言，根据类型，去执行响应的函数 Parent
//言外之意;:c++ 根据指针类型，去决定到具体的类里面，执行相应操作
//如果基类中加上virtual 关键字 c++ 编译器会动手脚==》动态链接编译
//c++ 编译器会来一个迟绑定 
void howtoPrint(Parent *base)
{
	base->print();
}

void howtoPrint2(Parent & base)
{
	base.print();
}
void main()
{
	Parent p1;
	Child c1;
	/*p1.print();
	c1.print();*/
	
	Parent * base=NULL;
	base=&p1;
	base->print();//打印父类的

	base=&c1;
	base->print();//打印父类的
	//p2 是c1 的别名，是c1本身
	Parent & p2=c1;
	p2.print();//打印父类的
	howtoPrint(&p1);
	howtoPrint(&c1);

	howtoPrint2(p1);
	howtoPrint2(c1);
	//以上打印父类的
	system("pause");
}

</pre><pre name="code" class="cpp">

多态实例：

#include <iostream>
using namespace std;
class HeroFighter
{
public:
	virtual int Atack()
	{
	   return 10;
	}
protected:
private:
};
class EmenyFighter
{
public :
	int DesoryPower()
	{
	    return 15;
	}
};
class HeroAd2Fighter:public HeroFighter
{
public:
	 int Atack()
	{
	   return 20;
	}
protected:
private:
};

void ObjFighter(HeroFighter * pbase,EmenyFighter * emeny )
{
    if(pbase->Atack()>emeny->DesoryPower())
	{
		printf("主角win\n");
	}else{
		printf("主角挂了\n");
	}
}
void main2()
{
	HeroFighter h1;
	EmenyFighter e1;
	HeroAd2Fighter hadv;
	if(h1.Atack()>e1.DesoryPower())
	{
		printf("主角win\n");
	}else{
		printf("主角挂了\n");
	}

	if(hadv.Atack()>e1.DesoryPower())
	{
		printf("主角win\n");
	}else{
		printf("主角挂了\n");
	}
	system("pause");
};
void main()
{
	HeroFighter h1;
	EmenyFighter e1;
	HeroAd2Fighter hadv;
	ObjFighter(&h1,&e1);
	ObjFighter(&hadv,&e1);
};

virtual 实现多态，c++ 编译器应该动什么手脚。

第一个需要动手脚的地方  起码这个函数print 我应该动什么手脚

我怎么知道是父类对象还是子类对象?

区分是父类对象还是子类对象0

 当类中声明虚函数时，编译器会在类中生成一个虚函数表。

虚函数表是一个存储类成员函数指针的数据结构

虚函数表是由编译器放入虚函数表中

存入虚函数时，每个对象中都有一个指向虚函数表的指针（vptr 指针）

#include "iostream"

using namespace std;

class AA
{
public:
	AA(int a= 0)
	{
		this->a = a;
		print(); //在构造函数里面能实现多态吗？
	}

	//分析一下要想实现多态，c++编译器应该动什么手脚
	//第一个需要动手脚的地方  起码这个函数print 我应该特殊处理
	virtual void print()
	{
		cout<<"父类的"<<"a"<<a<<endl;
	}
protected:
	int a ;
};

class BB : public AA
{
public:
	BB(int a= 0, int b = 0)
	{
		this->a = a;
		this->b = b;
	
	}
	virtual void print()
	{
		cout<<"子类的"<<"a"<<a<<"b"<<b<<endl;
	}
private:
	int b ;
};


void howToPrintf(AA *pBase)
{
	//pBase 我怎么知道是父类对象还是子类对象
	//动手脚2：:区分是父类对象还是子类对象，提前布局
	pBase->print();  //
}
void main()
{
	//AA a1;
	BB b1;
	//howToPrintf(&a1);
	howToPrintf(&b1);
	system("pause");
}

#include "iostream"
using namespace std;

//指针也是一种数据类型，指针数据的数据类型是指，它所指的内存空间的数据类型
//最后一点引申 指针的步长 。。。c++

class Parent01
{
protected:
	int i;
	int		j;
public:
	virtual void f()
	{
		cout<<"Parent01::f"<<endl;
	}
};


class Child01 : public Parent01
{	
public:
	int k;
public:
	Child01(int i, int j)
	{
		printf("Child01:...do\n");
	}

	virtual void f()
	{
		printf("Child01::f()...do\n");
	}
};

void howToF(Parent01 *pBase)
{
	pBase->f();
}

//指针的步长 在c++领域仍然有效，父类指针的步长和子类指针的步长不一样
//多态是靠迟绑定实现的（vptr+函数指针实现）
int main06()
{
	int i = 0;
	Parent01* p = NULL;
	Child01* c = NULL;

	//不要把父类对象还有子类对象同事放在一个数组里面
	Child01 ca[3] = {Child01(1, 2), Child01(3, 4), Child01(5, 6)};

	//不要用父类指针做赋值指针变量，去遍历一个子类的数组。

	p = ca;
	c = ca;

	p->f();
	c->f(); //有多态发生

// 	p++;
// 	c++;
// 
// 	p->f();//有多态发生
// 	c->f();

	for (i=0; i<3; i++)
	{
		howToF(&(ca[i]));
	}

	
	system("pause");
	return 0;
}