C++多态

C++的多态意味着调用成员函数时,会根据调用的对象的类型来执行不同的函数

编译时的多态,编译时就确定了具体的操作过程。
运行时的多态,程序运行过程中才确定的操作过程。
操作的过程即称为联编,也称为绑定。

  • 静态联编(早绑定),在编译和连接时确认的。比如函数重载,函数模板。效率高
  • 动态联编(后期绑定),运行的时候才能确定是哪块代码段。灵活

静态联编

函数调用在程序执行前就准备好了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include<iostream>
#define PI 3.1415926
using namespace std;

class Point
{
private:
int x;
int y;
public:
Point(int x=0,int y=0)
{
this->x=x;
this->y=y;
}
double area()
{
return 0.0;
}
};

class Circle: public Point
{
private:
int r;
public:
Circle(int x,int y,int R):Point(x,y)//基基类中有带参数的构造函数,派生类中的构造函数需要自定义
{
this->r=R;
}
double area()
{
return r*r*PI;
}
};

int main()
{
Point A(3,3);//一个点
Circle B(3,3,3); //一个圆

cout<<A.area()<<endl;
cout<<B.area()<<endl;

Point *ptr; //Point类型的指针
ptr = &B; //指向了Circle类型
cout<<ptr->area()<<endl;//输出结果不理想

return 0;
}


第三个cout输出0的原因:编译器在编译时就依据ptr的类型来执行那个are,指针ptr虽然指向了Circle类型的B,但是指针ptr为Point类型,所以执行Point类里的are方法。这里实行的即为静态编译。此时编译器看的是指针的类型而非内容。

动态编译

使用虚函数进行动态联编。程序在任意点可以根据所调用的对象类型来选择调用的函数,这种操作即为动态联编,也成为后期绑定。

虚函数

在基类中使用virtual关键字进行声明的函数。

virtual 函数返回值 函数名(形参)
{
    函数体
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include<iostream>
#define PI 3.1415926
using namespace std;

class Point
{
private:
int x;
int y;
public:
Point(int x=0,int y=0)
{
this->x=x;
this->y=y;
}
virtual double area()
{
return 0.0;
}
};

class Circle: public Point
{
private:
int r;
public:
Circle(int x,int y,int R):Point(x,y)//基基类中有带参数的构造函数,派生类中的构造函数需要自定义
{
this->r=R;
}
double area()
{
return r*r*PI;
}
};

int main()
{
Point A(3,3);//一个点
Circle B(3,3,3); //一个圆

cout<<A.area()<<endl;
cout<<B.area()<<endl;

Point *ptr; //Point类型的指针
ptr = &B;
cout<<ptr->area()<<endl;
cout<<(*ptr).area()<<endl;
return 0;
}

纯虚函数

在基类中不能对虚函数给出有意义的实现,这时侯就使用到了纯虚函数。包含纯虚函数的类是抽象类。抽象类至少包含一个纯虚函数。

定义方式:

virtual 返回值 函数名(形参)  = 0;

虚析构函数

在C++中,不能把构造函数定义为虚构造函数,因为在实例化一个对象时才会调用构造函数,而且虚函数的实现,其实际本质是通过一个虚函数表指针来调用的,还没有对象更没有没内存空间当然无法调用,故没有实例化一个对象之前的构造函数没有意义也不能实现。
析构函数可以为虚函数,而且大多数时候都声明为虚析构函数。这样就可以在基类的指针指向派生类的对象在释放时,可以根据所指向的对象类型动态联编调用子类的析构函数,实现真正的对象内存释放。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include<iostream>
using namespace std;

class Point
{
private:
int x;
int y;
int *str;
public:
Point(int x=0,int y=0)
{
this->x=x;
this->y=y;
str = new int[100];
}
~Point()
{
delete []str;
cout<<"Called Point's Destructor and Delete str !"<<endl;
}
};

class Circle:public Point
{
private:
int r;
int *str;
public:
Circle(int x,int y,int r):Point(x,y)
{
this->r=r;
str = new int[100];
}
~Circle()
{
delete []str;
cout<<"Called Circle's Destructor and Delete str !"<<endl;
}
};
int main()
{
Point *p;
p = new Circle(10,10,20);
delete p;

return 0;
}

仅调用了基类的析构函数,这样一来派生类中new出来的4*100字节的内存就会残留,造成内存泄漏!


 评论