c语言-实现多态

综述

多态性是面向对象程序设计的一个重要特征,利用多态性可以设计和实现一个易于扩展的系统。 顾名思义,多态的意思是多种形态,在C++程序设计中,多态指的是:具有不同功能的函数可以用同一个函数名,这样可以用一个函数名调用不同内容的函数。 C++的多态分两种:静态多态性和动态多态性。 1. C++中的函数重载和运算符重载实现的多态性就属于静态多态,在程序编译时系统就能决定调用的是哪个函数,因此静态多态性又称为编译时多态性。静态多态性是通过函数重载实现的(运算符重载实质上也是函数重载)。 2.动态多态实在程序运行过程中才动态确定操作指针指向的对象。它又被称为运行时多态。动态多态是通过虚函数实现的。 C语言虽然不是面向对象的语言,但是C语言同样可以实现多态性,在Linux 内核中就大量存在利用C语言实现多态性的代码。

C语言实现编译时多态性

C语言可以通过宏实现编译时多态,下面是一个例子:

1
2
3
4
5
6
7
8
9
10
#define ADD(A, B) (A) + (B);
int main(){
int a =1;
int b =2;
cout<<ADD(a,b);//输出3
string c = “asd”;
string d = “fff”;
cout<<ADD(c,d);//输出 asdfff
return 0;
}

对于不同的类型的A和B,带参数的宏 ADD 会根据传入的是 int类型或是string 类型而采取不同的 +的策略。

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <stdio.h>
#include <stdlib.h>
//虚函数表结构
struct base_vtbl
{
void(*dance)(void *);
void(*jump)(void *);
};
//基类
struct base
{
/*virtual table*/
struct base_vtbl *vptr;
};
void base_dance(void *this)
{
printf(“base dance\n”);
}
void base_jump(void *this)
{
printf(“base jump\n”);
}
/* global vtable for base /
struct base_vtbl base_table =
{
base_dance,
base_jump
};
//基类的构造函数
struct base * new_base()
{
struct base *temp = (struct base \)malloc(sizeof(struct base));
temp->vptr = &base_table;
return temp;
}
//派生类
struct derived1
{
struct base super;
/*derived members */
int high;
};
void derived1_dance(void * this)
{
/*implementation of derived1’s dance function */
printf(“derived1 dance\n”);
}
void derived1_jump(void * this)
{
/*implementation of derived1’s jump function */
struct derived1* temp = (struct derived1 )this;
printf(“derived1 jump:%d\n”, temp->high);
}
/*global vtable for derived1 \/
struct base_vtbl derived1_table =
{
(void()(void *))&derived1_dance,
(void()(void *))&derived1_jump
};
//派生类的构造函数
struct derived1 * new_derived1(int h)
{
struct derived1 * temp= (struct derived1 *)malloc(sizeof(struct derived1));
temp->super.vptr = &derived1_table;
temp->high = h;
return temp;
}
int main(void)
{
struct base * bas = new_base();
//这里调用的是基类的成员函数
bas->vptr->dance((void *)bas);
bas->vptr->jump((void *)bas);
struct derived1 * child = new_derived1(100);
//基类指针指向派生类
bas = (struct base *)child;
//这里调用的其实是派生类的成员函数
bas->vptr->dance((void *)bas);
bas->vptr->jump((void *)bas);
return 0;
}

上面代码不仅实现了多态的性质,其实也在模拟C++中的类的继承。主函数中基类指针 bas 一开始指向的是基类对象,因此调用 dance 和jump是基类的dance jump 。下面把bas 指向派生类的对象,再调用dance 和jump 的时候就不是基类的dance 和jump了,而转化成了派生类的dance 和jump.

  • 版权声明: 本博客所有文章,未经许可,任何单位及个人不得做营利性使用!转载请标明出处!如有侵权请联系作者。
  • Copyrights © 2015-2020 翟天野

请我喝杯咖啡吧~