一、多态的概念？
通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态
二、多态的条件？
三、什么是重写？
派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数
条件：
1.基类的成员函数必须是虚函数
2.子类的成员函数可以不加virtual关键字，但一般建议加上
3.基类和子类的虚函数原型必须一致，（返回值类型，函数名字，参数列表），有两个例外，返回值为类型指针或引用时可以，第二个是析构函数。
4，重写与访问权限无关。
class Base
{
public:
virtual void f1()
{
cout << "Base::f1()" << endl;
}
virtual void f2()
{
cout << "Base::f2()" << endl;
}
void f3()
{
cout << "Base::f3()" << endl;
}
virtual void f4()
{
cout << "Base::f4()" << endl;
}
virtual void f5()
{
cout << "Base::f5()" << endl;
}
//virtual void f6()
//{
// cout << "Base::f6()" << endl;
//}
};
class Derived : public Base
{
public:
// 与基类f1原型完全相同
virtual void f1()
{
cout << "Derived::f1()" << endl;
}
// 与基类f2不同，缺少virtual关键
void f2()
{
cout << "Derived::f2()" << endl;
}
// 与基类中f3不同--->原型一致，但是基类f3不是虚函数
virtual void f3()
{
cout << "Derived::f3()" << endl;
}
// 与基类虚函数参数列表不同
virtual void f4(int a)
{
cout << "Derived::f4(int)" << endl;
}
// 与基类虚函数f6的返回值类型不同
//virtual int f6()
//{
// cout << "Derived::f6()" << endl;
// return 0;
//}
protected:
// 与基类f5虚函数的访问权限不同
virtual void f5()
{
cout << "Derived::f5()" << endl;
}
};
// pb指向一个子类的对象
// 如果重写成功了，调用的一定是子类的方法
void TestVirtual(Base* pb)
{
pb->f1();
pb->f2();
pb->f3();
pb->f4();
pb->f5();
//pb->f6();
}
int main()
{
Derived d;
TestVirtual(&d);
return 0;
}
两种成员函数不同仍旧构成重载的情况？
1.协变：
// 基类虚函数返回基类的指针或者引用
// 子类虚函数返回子类的指针或者引用
// 注意："基类"虚函数 返回"基类"指针或者引用
// 这两个基类可以不是同一个继承体系
/ 协变：
// 基类虚函数返回基类的指针或者引用
// 子类虚函数返回子类的指针或者引用
// 注意："基类"虚函数 返回"基类"指针或者引用
// 这两个基类可以不是同一个继承体系
class A
{};
class B : public A
{};
class Base
{
public:
virtual A* f1()
{
cout << "Base::f1()" << endl;
return nullptr;
}
};
class Derived : public Base
{
public:
virtual B* f1()
{
cout << "Derived::f1()" << endl;
return nullptr;
}
};
void TestVirtual(Base& b)
{
b.f1();
}
int main()
{
Base b;
Derived d;
TestVirtual(b);
TestVirtual(d);
2.析构函数
class Base
{
public:
Base()
{
cout << "Base::Base()" << endl;
}
// 基类的析构函数如果设置为虚函数
// 子类的析构函数只要显式给出，子类的析构函数就会将基类的析构函数重写
virtual ~Base()
{
cout << "Base::~Base()" << endl;
}
protected:
};
class Derived : public Base
{
public:
Derived()
: Base()
, _d(0)
{
p = new int[10];
cout << "Derived::Derived()" << endl;
}
~Derived()
{
delete[] p;
cout << "Derived::~Derived()" << endl;
}
protected:
int _d;
int* p;
};
int main()
{
Base* pb = new Derived;
/*
delete pb;
1. 调用析构函数
子类已经将基类的析构函数重写了，因此调用那个类的析构函数
就需要看pb实际指向的是那个类的对象
2. 调用operator delete(void* p)释放对象的空间
*/
delete pb;
return 0;
}
为什么在继承体系下，一般建议将基类析构函数设置为虚函数？ ****
若基类的析构函数不为virtual修饰的话，若子类对象涉及到资源管理的话，此时将子类对象赋值给基类对象，此时若函数调用完成的话，只会调用基类的析构函数，而不会去调用子类的析构函数，这就会造成内存泄露的问题。
四、C++11中的override和final
override：单词含义 重写
作用：在编译阶段，检测子类虚函数是否对基类那个虚函数进行重写了
如果被override修饰的子类虚函数重写了基类的某个虚函数，编译通过
否则编译失败
override：只能修饰子类的虚函数
final：
// 1. 修饰虚函数—表明该虚函数不能被其子类重写了
// final一般用来修饰子类的虚函数，也可以修饰基类，不过没什么意义
// 2. 修饰类—>表明该类不能被继承了
// 需求：C类中的fun1这个虚函数不想被C的子类再重写了
class B
{
public:
virtual void fun1()final
{
cout << "B::fun1()" << endl;
}
};
class C : public B
{
public:
//virtual void fun1()//error
//{
// cout << "C::fun1()" << endl;
//}
virtual void fun2()
{
cout << "C::fun2()" << endl;
}
};
// 需求：D类要求：我不能再被继承
class D final : public C
{
public:
//virtual void fun1()
//{
// cout << "D::fun1()" << endl;
//}
virtual void fun2()
{
cout << "D::fun2()" << endl;
}
};
class E : public D//error
{};
五、重载、覆盖(重写)、隐藏(重定义)的对比 ******
六、抽象类 **
包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。 （因为无法确定给多大的空间）派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象纯虚函数规范了派生类必须重写，另外 纯虚函数更体现出了接口继承
class Shape
{
public:
// 纯虚函数
virtual double CalcCircle() = 0;
// virtual double CaclArea() = 0;
};
// 三角形
class Triangle : public Shape
{
public:
Triangle(double a, double b, double c)
{
this->a = a;
this->b = b;
this->c = c;
}
// 获取周长
virtual double CalcCircle()
{
return a + b + c;
}
private:
double a;
double b;
double c;
};
// 矩形
class Rectangle : public Shape
{
public:
Rectangle(double l, double w)
: length(l)
, width(w)
{}
virtual double CalcCircle()
{
return 2 * (length + width);
}
private:
double length;
double width;
};
// 子类必须重写抽象类中所有的纯虚函数，如果有一个纯虚函数没有重写
// 则子类也是抽象类
class Circle : public Shape
{
public:
Circle(double r)
{
this->r = r;
}
virtual double CalcCircle()
{
return 3.14 * r * r;
}
private:
double r;
};
void TestShape(Shape& s)
{
s.CalcCircle();
}
int main()
{
// Shape s;
Triangle t(3, 4, 5);
Rectangle r(2, 3);
Circle c(2);
TestShape(t); //
TestShape(r);
TestShape(c);
return 0;
}
接口继承与实现继承：
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。
虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。
七、多态原理
7.1什么情况下肯定会生成构造函数？
// 多态的实现原理
// 1. 包含有虚函数的类与不包含虚函数的类有什么区别？
// >> 带有虚函数的类会多4个字节
// >> 如果没有显式定义构造函数时，编译器一定会给带有虚函数的类合成构造函数
// >> 在构造函数中，编译器会给对象的前4个字节赋值
class B
{
public:
void f()
{
cout << "B::f()" << endl;
}
int _b;
};
// 多的4个字节是什么作用?
class D
{
public:
virtual void f1()
{
cout << "D::f1()" << endl;
}
virtual void f2()
{
cout << "D::f2()" << endl;
}
virtual void f3()
{
cout << "D::f3()" << endl;
}
int _d;
};
int main()
{
cout << sizeof(B) << endl;
cout << sizeof(D) << endl;
B b;
b._b = 10;
D d;
d._d = 10;
return 0;
}
class B1
{
public:
virtual void f1()
{
cout << "B1::f1()" << endl;
}
virtual void f2()
{
cout << "B1::f2()" << endl;
}
int _b1;
};
class B2
{
public:
virtual void f3()
{
cout << "B2::f3()" << endl;
}
virtual void f4()
{
cout << "B2::f4()" << endl;
}
int _b2;
};
class D : public B1, public B2
{
public:
virtual void f1()
{
cout << "D::f1()" << endl;
}
virtual void f4()
{
cout << "D::f4()" << endl;
}
virtual void f5()
{
cout << "D::f5()" << endl;
}
int _d;
};
typedef void(*PVFT)();
void PrintVFT1(B1& b, const string& s)
{
cout << s << endl;
PVFT* pvft = (PVFT*)*(int*)&b;
while (*pvft)
{
(*pvft)();
++pvft;
}
cout << endl;
}
void PrintVFT2(B2& b, const string& s)
{
cout << s << endl;
PVFT* pvft = (PVFT*)*(int*)&b;
while (*pvft)
{
(*pvft)();
++pvft;
}
cout << endl;
}
int main()
{
cout << sizeof(D) << endl;
D d;
d._b1 = 1;
d._b2 = 2;
d._d = 3;
PrintVFT1(d, "D->B1->VFT:");
PrintVFT2(d, "D->B1->VFT:");
return 0;
}
八、总结
706
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
