#include<iostream>
using namespace std;
class Parent
{
public:
Parent(int a)
{
this->a = a;
cout << " Parent" << a << endl;
}
public:
virtual void print()//在子类里面可写可不写
{
cout << "Parent" <<a<< endl;
}
protected:
private:
int a;
};
class Child:public Parent
{
public:
Child(int b):Parent(10)
{
this->b = b;
cout << " Child b" << b << endl;
}
public:
void print()
{
cout << "Child" <<b<< endl;
}
protected:
private:
int b;
};
void main()
{
//可以把子类的对象赋值给指针
Parent* base = NULL;
Parent p1(20);
Child c1(30);
base = &p1;
base->print();//父类
base = &c1;
base->print();//执行谁的 ->面向对象新需求
return;
}
多态如何演变：
#include<iostream>
using namespace std;
class HeroFighter
{
public:
virtual int power()
{
return 10;
}
};
class EncmyFighter
{
public:
int attact()
{
return 15;
}
};
class AdvHeroFighter :public HeroFighter
{
public:
virtual int power()
{
return 10;
}
};
//
class AdvAdvHeroFighter :public HeroFighter
{
public:
virtual int power()
{
return 30;
}
};
void play(HeroFighter *hf, EncmyFighter *ef)
{
//多态场景
if (hf->power() > ef->attact())//hf->power() 会有多态发生
{
cout << "hero win" << endl;
}
else
{
cout << "hero faule" << endl;
}
}
void main()
{
HeroFighter hf;
EncmyFighter ef;
AdvHeroFighter advhf;
//
AdvAdvHeroFighter advadvhf;
play(&hf, &ef);
play(&advhf, &ef);
//
play(&advadvhf, &ef);//这个框架能把后来写的代码调用起来
}
//多态框架
//play 给对象搭建舞台 看成一个框架
//封装：突破函数 用类做函数参数时候 可以使用对象的属性和对象的方法
//继承： A B代码复用
//多态：可以使用未来
//实现多态的三个条件：1.要有继承 2.要有函数重写3.父类指针指向子类对象
//void main01()
//{
// HeroFighter hf;
// EncmyFighter ef;
// AdvHeroFighter advhf;
// if (hf.power() > ef.attact())
// {
// cout << "hero win" << endl;
// }
// else
// {
// cout << "hero faule" << endl;
// }
// if (advhf.power() > ef.attact())
// {
// cout << "hero win" << endl;
// }
// else
// {
// cout << "hero faule" << endl;
// }
// return;
//}
虚析构
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class A
{
public:
A()
{
p = new char[20];
strcpy(p, "obja");
cout << "a" << endl;
}
virtual ~A()
{
delete[] p;
cout << "~a" << endl;
}
protected:
private:
char* p;
};
class B :public A
{
public:
B()
{
p = new char[20];
strcpy(p, "obja");
cout << "b" << endl;
}
~B()
{
delete[] p;
cout << "~b" << endl;
}
protected:
private:
char* p;
};
class C :public B
{
public:
C()
{
p = new char[20];
strcpy(p, "obja");
cout << "c" << endl;
}
~C()
{
delete[] p;
cout << " ~`c" << endl;
}
protected:
private:
char* p;
};
//只执行了父类的析构
//通过父类指针把子类的析构函数都执行一遍
//释放所有的子类资源 只能用virtual
void howtodelete(A *base)
{
delete base;//不会表现成多态
}
void main()
{
C* myc = new C;//how delete 匹配 new会自动调用~函数
howtodelete(myc);
return;
}
调用a进去 把a的地址赋值给指针
1.
1.补充：一个函数在不同类中穿梭（动态）
c++提前vptr指针 找到 虚化列表 找到函数指针进行动态绑定
子类和父类步长：
步长问题：
子类跳到下一个单元 父类跳两个元素
子类和父类指针步长不一样
多态时用父类指针指向对象 父类步长加加 是两个概念
#include<iostream>
using namespace std;
//构造函数中调用虚函数能发生多态吗
class Parent
{
public:
Parent(int a = 0)
{
this->a = a;
print();
}
virtual void print()
{
cout << "我是爹" << endl;
}
virtual void print2()
{
cout << "我是爹" << endl;
}
private:
int a;
};
class Child:public Parent
{
public:
/*Child(int a=0,int b = 0):Parent(a)
{
this->b = b;
}*/
Child(int b = 0) :Parent(0)
{
this->b = b;
print();
}
virtual void print()
{
cout << "我是son" << endl;
}
virtual void print2()
{
cout << "我是son" << endl;
}
private:
int b;
};
void HowtoPlay(Parent* base)
{
base->print();//有多态
}
void main()
{
Child c1;//定义一个子类对象 在这个过程中构造函数调用虚函数print 能发生多态吗
Parent* pP = NULL;
Child* pC = NULL;
Child array[] = { Child(1),Child(2),Child(3) };
pP = array;
pC = array;
//访问
pP->print();
pC->print();
pP++;
pC++;
pP->print();
pC->print();
return;
}
没添加 属性和方法子类和父类指针步长一样
