多态基本概念
多态也就是多种形态
对于不同对象实现相同的方法，但产生的结果是不一样的
例如，我们前边所介绍继承的例子：
class Animal {
public:
Animal(const string& name, const string& gender, const int& age) :_name(name), _gender(gender), _age(age)
{}
void Sleep()
{
cout << _name << "在睡觉！！！" << endl;
}
void Eat()
{
cout << _name << "在吃饭····" << endl;
}
public:
string _name;
string _gender;
int _age;
};
class Dog :public Animal
{
public:
Dog(const string& name, const string& gender, const int& age, const string& color)
:Animal(name, gender, age), _color(color)
{}
protected:
string _color;
};
class Cat :public Animal
{
public:
Cat(const string& name, const string& gender, const int& age, const string& temper)
:Animal(name, gender, age), _temper(temper)
{}
private:
string _temper;
};
对于动物狗、动物猫，两种动物具有共同的特性：名称、性别、年龄，也具有类似的生活习性：睡觉、吃饭，因此我们为了避免重复的代码过多而引入了继承的概念：
将猫与狗的共有特性提取出来，形成一个动物类来实现它们共同的特征：
但是我们会发现一个问题，猫与狗类的对象都会调用基类中继承而来的方法来实现我们的需求，但是现实生活中，我们想要通过调用同一种方法来实现不同的效果，比如说狗类吃饭是啃骨头，猫类吃鱼，那要怎样才能实现这种想法？？
引入了多态的概念：
多态：在不同继承关系的类对象中，调用同一个函数产生不同的行为
那么针对上边的例子，我们来看看效果：
这就要谈到我们上次说到的 virtual 关键字
class Animal { //基类
public:
Animal(const string& name, const string& gender, const int& age) :_name(name), _gender(gender), _age(age)
{}
virtual void Sleep()
{
cout << _name << "在睡觉！！！" << endl;
}
virtual void Eat()
{
cout << _name << "在吃饭····" << endl;
}
public:
string _name;
string _gender;
int _age;
};
class Dog :public Animal
{
public:
Dog(const string& name, const string& gender, const int& age, const string& color)
:Animal(name, gender, age), _color(color)
{}
virtual void Sleep()
{
cout << _name << "睡觉打呼噜inging~~" << endl;
}
virtual void Eat()
{
cout << _name << "啃骨头inging~~" << endl;
}
protected:
string _color;
};
class Cat :public Animal
{
public:
Cat(const string& name, const string& gender, const int& age, const string& temper)
:Animal(name, gender, age), _temper(temper)
{}
virtual void Sleep()
{
cout << _name << "安安静静睡觉inging~~" << endl;
}
virtual void Eat()
{
cout << _name << "逮老鼠inginging~~" << endl;
}
private:
string _temper;
};
//测试代码
//基类对象的指针/引用 可以指向/引用 子类对象
void test0(Animal& animal)
{
animal.Sleep();
animal.Eat();
}
int main()
{
Dog dog("金毛", "公", 3, "金黄色");
test0(dog);
Cat cat("咪咪", "母", 1, "温柔");
test0(cat);
return 0;
}
在继承模块中，我们谈到，子类与基类中若存在相同的成员变量或是成员函数，则会在调用时候产生同名隐藏 添加链接描述（继承中作用域板块）但若我们在同名的成员函数前加上 virtual 关键字，则可以实现多态
多态实现条件
1、在继承体系中，多态必须通过基类指针或引用调用虚函数（基类指针/引用可以指向/引用派生类的对象）
2、被调用的函数必须是虚函数（被 virtual 所修饰的成员函数），且派生类必须对基类的虚函数进行重写
多态是在程序运行时，根据基类指针或引用指向不同类的对象，选择对应的虚函数进行调用
再来看一个多态实现的栗子：
class Shape { //基类：形状类
public:
//virtual 修饰的成员函数称为虚函数
virtual void Draw()
{
cout << "位置图形，无法进行绘制！" << endl;
}
virtual double GetGrith()
{
cout << "图形未知，无法获取周长！！" << endl;
return NULL;
}
};
class Circle :public Shape //圆形
{
public:
Circle(const double& r):_r(r) {}
virtual void Draw()
{ //子类必须重写基类的虚函数
cout << "圆形" << endl;
}
virtual double GetGrith() //求周长----------实现与基类中同名函数的重写
{
return 2 * _r*3.1415926 ;
}
private:
double _r;
};
class Rect :public Shape //矩形
{
public:
Rect(const double& length,const double& width) :_length(length),_width(width) {}
virtual void Draw()
{ //子类必须重写基类的虚函数
cout << "矩形" << endl;
}
virtual double GetGrith()
{
return 2 * (_length + _width) ;
}
private:
double _length;
double _width;
};
class Trangle :public Shape //三角形
{
public:
Trangle(const double& a, const double& b,const double& c) :_a(a), _b(b),_c(c) {}
virtual void Draw()
{
cout << "三角形" << endl;
}
virtual double GetGrith()
{
return _a + _b + _c;
}
private:
double _a;
double _b;
double _c;
};
void Test(Shape& s)
{
s.Draw();
cout << s.GetGrith() << endl;;
}
int main()
{
Circle c(2);
Test(c);
Rect L(2, 4);
Test(L);
Trangle t(3, 4, 5);
Test(t);
return 0;
}
虚函数重写
虚函数重写定义
虚函数重写：
（1）派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型，参数列表，函数名字完全相同），称子类的虚函数重写了基类的虚函数
（2）派生类虚函数前不加 virtual 也可以构成重写，但写法不规范，建议添加 virtual
（3）派生类虚函数与基类虚函数的访问权限可以不同
虚函数重写的两个例外
析构函数重写
（基类与派生类析构函数名称不同）
（一般情况下在继承体系中建议将基类的析构函数设置为虚函数）
若基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加 virtual 关键字，都与基类的析构函数构成重写，虽然基类与子类析构函数名不同，看起来违背了重写规则，但可以看作是编译器对析构函数名称做了特殊处理
class A {
public:
virtual ~A()
{
cout << "~A()" << endl;
}
};
class B :public A
{
private:
virtual ~B() //与基类中析构函数构成重写
{
cout << "~B()" << endl;
}
};
协变
（基类与派生类虚函数的返回值类型不同）
派生类重写基类虚函数时，与基类虚函数的返回值类型不同。
即基类虚函数返回基类对象的指针或引用，派生类虚函数返回派生类对象的指针或引用，称为协变。
//测试代码一：
class A {
public:
virtual A* GetObj() //返回基类虚函数的指针
{
return this;
}
};
class B :public A
{
private:
virtual B* GetObj() //返回子类虚函数的指针
{
return this;
}
};
void GetObj(A* pa) //基类指针可以指向子类对象
{
if (pa) {
pa->GetObj();
}
}
int main()
{
A a;
GetObj(&a);
B b;
GetObj(&b);
return 0;
}
//测试代码二：
class AA {}; //基类
class BB :public AA {}; //子类
//创建不同类的对象
AA aa;
BB bb;
class A {
public:
virtual AA& GetObj()
{
return aa; //基类 A 中返回 基类 AA 对象的引用
}
};
class B :public A
{
private:
virtual BB& GetObj() //与基类中同名函数引用形成重写
{
return bb; //子类 B 中返回子类 BB 对象的引用
}
};
void GetObj(A& pa) //基类引用可以引用子类对象
{
pa.GetObj();
}
int main()
{
A pa;
GetObj(pa);
B pb;
GetObj(pb);
return 0;
}
注意区别 同名隐藏、函数重载、虚函数重写
override 修饰子类虚函数
override 只能用来修饰子类的虚函数
作用：让编译器在编译代码时，帮助检测是否重写了基类中某个函数，若重写则编译通过，否则编译失败
class B {
public:
virtual void Func1()
{
cout << "B::Func1()" << endl;
}
};
class D :public B
{
public:
virtual void Func1()override //override 只能用来修饰子类的虚函数-----检测是否构成重写
{
cout << "D::Func1()" << endl;
}
};
final 关键字
1、final 修饰类：表明该类不能被继承
2、final 修饰虚函数：表明该虚函数不想被继承
（final 只能修饰子类虚函数）
抽象类
在虚函数后面加上 “=0” ，则这个函数称为纯虚函数。
包含纯虚函数的类称为抽象类或接口类（不能创建实例化对象的类）
举个栗子来理解一下吧：
对于我们前边所介绍的 图形类 Shape ，由于图形可能是 圆形、正方形、长发形、三角形…，所以 Shape 并不具体，我们不能实例化一个图形对象：
class Shape {
public:
virtual void Draw()
{
cout << "图形不具体，不能够进行绘制！" << endl;
}
virtual double GetPer()
{
return 0;
}
};
int main()
{
Shape a; //创建一个图形类的对象
a.Draw();
a.GetPer(); //显然是不成立的，图形未知是不能计算它的周长的
return 0;
}
显然，上述例子是不合理的，我们无法创建一个未知图形的对象，更不能计算出未知图形的周长信息
由此可见，当前的 Shape 类是不能够实例化出对象的，因此称之为抽象类
抽象类：包含纯虚函数的类
不能创建实例化对象
//抽象类
class Shape {
public:
virtual void Draw() = 0; // =0 纯虚函数
//纯虚函数不能被调用------因此可以不实现其方法体
virtual double GetPer() = 0; // =0 纯虚函数
};
抽象类一定要被继承，并在子类中一定要对抽象类中的纯虚函数进行重写，否则该子类也是抽象类
即：子类一定要对抽象类中的纯虚函数 全部 进行重写，否则子类也是抽象类
//抽象类
class Shape {
public:
virtual void Draw() = 0; // =0 纯虚函数
virtual double GetPer() = 0; // =0 纯虚函数
};
class Circle:public Shape
{
public:
Circle(const double r = 1) :_r(r) //重写
{}
virtual void Draw()
{
cout << "圆形" << endl;
}
virtual double GetPer() //重写
{
return 2 * 3.1415 * _r;
}
private:
double _r;
};
抽象类不能创建实例化对象，但是可以创建其指针 / 引用
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现
虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
