C与面向对象Word格式文档下载.docx

C与面向对象Word格式文档下载.docx

《C与面向对象Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《C与面向对象Word格式文档下载.docx（14页珍藏版）》请在冰豆网上搜索。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：

编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。

如，有两个同名函数：

functionfunc（p:

integer）:

integer;

和functionfunc（p:

string）:

。

那么编译器做过修饰后的函数名称可能是这样的：

int_func、str_func。

对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：

是静态）。

也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和面向对象编程无关！

真正相关的是“覆盖”。

当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：

是动态！

）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。

因此，这样的函数地址是在运行期绑定的（晚邦定）。

结论就是：

重载只是一种语言特性，与多态无关，与面向对象也无关！

引用一句BruceEckel的话：

“不要犯傻，如果它不是晚邦定，它就不是多态。

”

那么，多态的作用是什么呢？

我们知道，封装可以隐藏实现细节，使得代码模块化；

继承可以扩展已存在的代码模块（类）；

它们的目的都是为了——代码重用。

而多态则是为了实现另一个目的——接口重用！

多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

1.4几个概念

泛化（Generalization）

泛化

在上图中，空心的三角表示继承关系（类继承），在UML的术语中，这种关系被称为泛化（Generalization）。

Person（人）是基类，Teacher（教师）、Student（学生）、Guest（来宾）是子类。

若在逻辑上B是A的“一种”，并且A的所有功能和属性对B而言都有意义，则允许B继承A的功能和属性。

例如，教师是人，Teacher是Person的“一种”（akindof）。

那么类Teacher可以从类Person派生（继承）。

如果A是基类，B是A的派生类，那么B将继承A的数据和函数。

如果类A和类B毫不相关，不可以为了使B的功能更多些而让B继承A的功能和属性。

若在逻辑上B是A的“一种”（akindof），则允许B继承A的功能和属性。

聚合（组合）

组合

若在逻辑上A是B的“一部分”（apartof），则不允许B从A派生，而是要用A和其它东西组合出B。

例如，眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head应该由类Eye、Nose、Mouth、Ear组合而成，不是派生（继承）而成。

聚合的类型分为无、共享（聚合）、复合（组合）三类。

聚合（aggregation）

共享

上面图中，有一个菱形（空心）表示聚合（aggregation）（聚合类型为共享），聚合的意义表示has-a关系。

聚合是一种相对松散的关系，聚合类B不需要对被聚合的类A负责。

组合（composition）

复合

这幅图与上面的唯一区别是菱形为实心的，它代表了一种更为坚固的关系——组合（composition）（聚合类型为复合）。

组合表示的关系也是has-a，不过在这里，A的生命期受B控制。

即A会随着B的创建而创建，随B的消亡而消亡。

依赖（Dependency）

依赖

这里B与A的关系只是一种依赖（Dependency）关系，这种关系表明，如果类A被修改，那么类B会受到影响。

2C实现继承—Linux内核链表

从前面我们已经知道，继承的本意，是为了进行代码重用。

对于c++等OO语言而言，class本身就提供了这样的机制，但是也必须付出代价：

你必须非常仔细地设计你的类族谱，要有前瞻性，要有可扩展性，要决定分多少个层次....这些都不是容易做到的事。

但是对于C语言，这个结构化的语音而言，只有一个struct可用，那么C语言能不能做到代码重用呢？

事实上，以C这么强大的功能，当然是可以做到的，下面我们来学习Linux内核的链表实现，堪称经典。

2.1节点数据结构

Linux链表是双向循环链表，因为这样的链表具有最好的灵活性，下面是其节点的数据结构定义（内核也提供了带头结点的链表hlist_head/hlist_node）：

structlist_head{

structlist_head*prev;

structlist_head*next;

}

从这个结构体的命名就可以发现，内核实际上并没有为链表固定表头，每一个节点都可以看做表头，事实上是一个双向循环的结构。

当然，单独一个这样的结构并没有什么意义，我们需要把它放到我们自己的结构体中：

structmy_struct{

structlist_headlist;

intcat;

void*dog;

2.2链表初始化

使用之前，需要进行初始化:

Structmy_struct*p=malloc·

·

p->

cat=·

p->

dog=·

INIT_LIST_HEAD（&

list）

初始化用到的相关宏如下：

#defineINIT_LIST_HEAD（ptr）do{\

（ptr）->

next=（ptr）;

prev=（ptr）;

\

}while（0）

另外，内核也提供了另外的初始化宏：

#defineLIST_HEAD_INIT（name）{&

（name）,&

（name）}

#defineLIST_HEAD（name）\//即将前驱与后继都指向了自己

structlist_headname=LIST_HEAD_INIT（name）

这种初始化，一般用于编译时静态声明与初始化链表：

structmy_structmine{

.list=LIST_HEAD（mine.list）;

.cat=0;

.dog=NULL;

2.3操作链表

内核提供操作链表的函数，一般是staticinline类型的函数

值得注意的是，从链表中删除节点，只是将节点摘除，内存需要另外用代码进行释放

2.4遍历链表

操作链表虽然重要，但是也要能够找到待操作的节点才可以，因此链表的遍历才是关键之处。

不仅要遍历链表节点，并且还要取出该节点对应的自己的用户数据。

下面的代码是典型的遍历方法：

structlist_head*p;

structmy_structmy;

list_for_each（p,&

my->

list）{

my=list_entry（p,structmy_struct,list）;

·

其中用到的宏定义如下：

#definelist_for_each（pos,head）\

for（pos=（head）->

next;

prefetch（pos->

next）,pos!

=（head）;

\

pos=pos->

next）

#definelist_entry（ptr,type,member）\

container_of（ptr,type,member）

#definecontainer_of（ptr,type,member）（{\

consttypeof（（（type*）0）->

member）*__mptr=（ptr）;

（type*）（（char*）__mptr-offsetof（type,member））;

}）

2.5小结

上面的例子，实际上是一个可重用性很强的，用C实现继承的例子。

我们可以发现，在代码重用方面，C虽然没有提供专门的机制，但我们还是能够实现这一点的，只不过需要我们更好的设计数据结构，以及抽象、封装我们的代码

3C实现多态

同样从第一节我们可以知道，多态的目的就是要进行接口复用，C语言同样有能力实现多态。

在c++中，多态一般通过重载、覆盖、模板等等，那么C语言该如何实现？

3.1重载

前面提到过，c++在编译的时候，就能够结合函数名、返回值、参数等在编译器中生成唯一的符号，即对于同一个可执行文件而言，其内部的符号还是唯一的。

C的编译器不提供这样的功能，那么该如何进行模拟？

3.1.1方法一：

用可变参数

这个的思路就是通过va_arg（）、va_start（）、va_end（）等宏，结合va_list结构体进行函数的设计。

这样就可以向函数传入不定个数的参数

但是这个方法有一个问题，那就是对于0个参数的情况，可变参数不能支持

3.1.2方法二：

用void*

这里的处理思路也很简单，通过void*这个万能指针传递不同类型的变量，只要在处理函数内部进行强制转换即可

当然这个方法也是有代价的，必须仔细进行设计，因为如何在各种指针类型之间进行转换，有时候实在是一个麻烦的事情。

另外对于参数个数也会有限制

举例1：

voidHandleMsg（unsingedintid,void*p）

{

Msg1*p1;

Msg2*p2;

switch（id）

{

casekey1:

p1=（Msg1*）p;

//dosomething

break;

casekey2:

p2=（Msg2*）p;

default:

}

举例2：

void*memcpy（void*dest,constvoid*src,size_tlen）

3.1.3方法三：

综合

这里可以考虑入参传入一个结构体：

unsignednumArg;

//参数个数

struct*st_Arg;

//参数链表，每个节点再分别定义参数类型，与取值

3.2覆盖

一般而言，覆盖的实现，主要是通过函数指针，通过记录操作符的方式。

最经典的例子，莫过于Linux中的VFS层的实现了，下面简单介绍一下

3.2.1LinuxVFS的原理与层次图

VFS在底层的各种文件系统之上，建立了一层抽象层，对上屏蔽了各种文件系统的差异。

这么一来，使得Linux能够支持多种文件系统，即使不同的文件系统在功能和行为上有很大的差异。

VFS实际上是提供了一个模型，该模型定义了各种文件系统实际上应该支持的各种功能，比如“打开文件”、“文件读写”等等。

与此同时，各种文件系统也必须按照VFS的规定，来实现各种接口所对应的功能，提供VFS所期望的接口与数据结构，这样VFS就能够毫不费力的进行文件系统的管理了

3.2.2LinuxVFS的面向对象设计

VFS主要有四个对象类型：

超级快对象：

代表一个已经安装的文件系统；

索引节点对象：

代表一个文件；

目录项对象：

路径的一个组成部分；

文件对象：

代表有进程打开的文件。

每个对象不仅定义了自己的属性，关键的是，都会有一个操作符结构体，里面定义了不同的对象需要具备的方法：

这些方法由不同的文件系统对其进行赋值，即不同的文件系统负责给其提供具体的实现。

下图是inode对象的操作符，在里面可以看到我们很多熟悉的操作：

3.2.3小结

从上面可以看出，文件系统的操作符的实现，实际上就是函数指针的运用，不同的对象向上层的抽象管理层提供各自的处理函数，使得抽象层能够屏蔽掉下面的实现细节

这样处理的实质，就是接口复用

3.3模板

一般而言，覆盖的C实现，主要是运用好预处理中的##符号，通过该符号，将name作为宏的参数传入，即可在编译阶段生成新的类，并具有各自的处理函数。

当然类型也需要传入

具体细节可以参见后面的示例

4例子

4.1运行时多态

#ifndefC_Class

#defineC_Classstruct

#endif

C_ClassA{

C_ClassA*A_this;

void（*Foo）（C_ClassA*A_this）;

inta;

intb;

};

C_ClassB{//B继承了A

C_ClassB*B_this;

//顺序很重要

void（*Foo）（C_ClassB*Bthis）;

//虚函数

intc;

voidB_F2（C_ClassB*Bthis）

{

printf（"

ItisB_Fun\n"

）;

voidA_Foo（C_ClassA*Athis）

ItisA.a=%d\n"

Athis->

a）;

//或者这里

voidB_Foo（C_ClassB*Bthis）

ItisB.c=%d\n"

Bthis->

c）;

voidA_Creat（structA*p）

Foo=A_Foo;

a=1;

b=2;

A_this=p;

}

voidB_Creat（structB*p）

Foo=B_Foo;

a=11;

b=12;

c=13;

B_this=p;

intmain（intargc,char*argv[]）

C_ClassA*ma,a;

C_ClassB*mb,b;

A_Creat（&

//实例化

B_Creat（&

b）;

mb=&

b;

ma=&

a;

ma=（C_ClassA*）mb;

//引入多态指针

%d\n"

ma->

//可惜的就是函数变量没有private

ma->

Foo（ma）;

//多态

a.Foo（&

//不是多态了

B_F2（&

//成员函数，因为效率问题不使用函数指针

return0;

4.2纯虚类

//------------------结构体中的函数指针类似于声明子类中必须实现的虚函数-------------

typedefstruct

void（*Foo1）（）;

char（*Foo2）（）;

char*（*Foo3）（char*st）;

}MyVirtualInterface;

//------------------类似于纯虚类的定义---------------------------------------------

MyVirtualInterface*m_pInterface;

DoMyAct_SetInterface（MyVirtualInterface*pInterface）

{

m_pInterface=pInterface;

voidDoMyAct_Do（）

if（m_pInterface==NULL）return;

m_pInterface->

Foo1（）;

c=m_pInterface->

Foo2（）;

//--------------------------子类一------------------------------------------

MyVirtualInterfacest[MAX];

//接着定义一些需要实现的函数Act1_Foo1，Act1_Foo2，Act1_Foo3

MyVirtualInterface*Act1_CreatInterface（）

index=FindValid（）//对象池或者使用Malloc！

应该留在外面申请，实例化

if（index==-1）returnNULL;

st[index].Foo1=Act1_Foo1;

//Act1_Foo1要在下面具体实现

st[index].Foo2=Act1_Foo2;

st[index].Foo3=Act1_Foo3;

Return&

st[index];

//--------------------------主函数-----------------------------------------

if（（p=Act1_CreatInterface（））!

=NULL）

List_AddObject（&

List,p）;

//AddAll

While（p=List_GetObject（））

DoMyAct_SetInterface（p）;

//使用Interface代替了原来大篇幅的SwitchCase

DoMyAct_Do（）;

//不要理会具体的什么样的动作，justdoit

4.3模板

#defineHASH_FUNCTIONS（name,bufarg,type,hashtype,ref,deref,hasher）\

voidname##_hash_add（hashtype*table,\

bufargbuf,unsignedlen,type*ptr,\

constchar*file,intline）\

{\

add_hash（（structhash_table*）table,buf,\

len,（hashed_object_t*）ptr,file,line）;

}\

voidname##_hash_delete（hashtype*table,bufargbuf,unsignedlen,\

delete_hash_entry（（structhash_table*）table,buf,len,\

file,line）;

intname##_new_hash（hashtype**tp,unsignedc,constchar*file,intline）\

returnnew_hash（（structhash_table**）tp,\

（hash_reference）ref,（hash_dereference）deref,c,\

hasher,file,line）;

voidname##_free_hash_table（hashtype**table,constchar*file,intline）\

free_hash_table（（structhash_table**）table,file,line）;