C与面向对象 严选参考

C与面向对象1 面向对象的基本特性面向对象的三个基本特征是：封装、继承、多态。图1 面向对象基本特性1.1 封装封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。1.2 继承面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”。被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。 继承概念的实现方式有三类：实现继承、接口继承和可视继承。l 实现继承是指使用基类的属性和方法而无需额外编码的能力；l 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；l 可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg类却不能继承 Person 类，因为腿并不是一个人。抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。OO开发范式大致为：划分对象抽象类将类组织成为层次化结构(继承和合成) 用类与实例进行设计和实现几个阶段。1.3 多态多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。实现多态，有二种方式，覆盖，重载。覆盖，是指子类重新定义父类的虚函数的做法。重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和面向对象编程无关！真正相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了代码重用。而多态则是为了实现另一个目的接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。 1.4 几个概念泛化（Generalization）图2 泛化在上图中，空心的三角表示继承关系（类继承），在UML的术语中，这种关系被称为泛化（Generalization）。Person(人)是基类，Teacher(教师)、Student(学生)、Guest(来宾)是子类。若在逻辑上B是A的“一种”，并且A的所有功能和属性对B而言都有意义，则允许B继承A的功能和属性。例如，教师是人，Teacher 是Person的“一种”（a kind of ）。那么类Teacher可以从类Person派生（继承）。如果A是基类，B是A的派生类，那么B将继承A的数据和函数。如果类A和类B毫不相关，不可以为了使B的功能更多些而让B继承A的功能和属性。若在逻辑上B是A的“一种”（a kind of ），则允许B继承A的功能和属性。聚合（组合）图3 组合若在逻辑上A是B的“一部分”（a part of），则不允许B从A派生，而是要用A和其它东西组合出B。例如，眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head应该由类Eye、Nose、Mouth、Ear组合而成，不是派生（继承）而成。聚合的类型分为无、共享(聚合)、复合(组合)三类。 聚合（aggregation） 图4 共享上面图中，有一个菱形（空心）表示聚合（aggregation）（聚合类型为共享），聚合的意义表示has-a关系。聚合是一种相对松散的关系，聚合类B不需要对被聚合的类A负责。 组合（composition）图5 复合这幅图与上面的唯一区别是菱形为实心的，它代表了一种更为坚固的关系组合（composition）（聚合类型为复合）。组合表示的关系也是has-a，不过在这里，A的生命期受B控制。即A会随着B的创建而创建，随B的消亡而消亡。 依赖(Dependency)图6 依赖这里B与A的关系只是一种依赖(Dependency)关系，这种关系表明，如果类A被修改，那么类B会受到影响。 2 C实现继承 Linux 内核链表从前面我们已经知道，继承的本意，是为了进行代码重用。对于c+等OO语言而言，class本身就提供了这样的机制，但是也必须付出代价：你必须非常仔细地设计你的类族谱，要有前瞻性，要有可扩展性，要决定分多少个层次.这些都不是容易做到的事。但是对于C语言，这个结构化的语音而言，只有一个struct可用，那么C语言能不能做到代码重用呢？事实上，以C这么强大的功能，当然是可以做到的，下面我们来学习Linux内核的链表实现，堪称经典。2.1 节点数据结构Linux链表是双向循环链表，因为这样的链表具有最好的灵活性，下面是其节点的数据结构定义（内核也提供了带头结点的链表hlist_head / hlist_node）：struct list_head struct list_head *prev;struct list_head *next;从这个结构体的命名就可以发现，内核实际上并没有为链表固定表头，每一个节点都可以看做表头，事实上是一个双向循环的结构。当然，单独一个这样的结构并没有什么意义，我们需要把它放到我们自己的结构体中：struct my_struct struct list_headlist;int cat;void *dog;2.2 链表初始化使用之前，需要进行初始化:Struct my_struct *p = malloc p-cat = p-dog = INIT_LIST_HEAD(&p-list)初始化用到的相关宏如下：#define INIT_LIST_HEAD(ptr) do (ptr)-next = (ptr); (ptr)-prev = (ptr); while (0)另外，内核也提供了另外的初始化宏：#define LIST_HEAD_INIT(name) &(name), &(name) #define LIST_HEAD(name) /即将前驱与后继都指向了自己struct list_head name = LIST_HEAD_INIT(name)这种初始化，一般用于编译时静态声明与初始化链表：struct my_structmine.list = LIST_HEAD(mine.list);.cat = 0;.dog = NULL;2.3 操作链表内核提供操作链表的函数，一般是static inline 类型的函数值得注意的是，从链表中删除节点，只是将节点摘除，内存需要另外用代码进行释放2.4 遍历链表操作链表虽然重要，但是也要能够找到待操作的节点才可以，因此链表的遍历才是关键之处。不仅要遍历链表节点，并且还要取出该节点对应的自己的用户数据。下面的代码是典型的遍历方法：struct list_head *p;struct my_struct my;list_for_each (p, &my-list)my = list_entry(p, struct my_struct , list);能够通过任何一个节点操作这个链表其中用到的宏定义如下：#define list_for_each(pos, head) for (pos = (head)-next; prefetch(pos-next), pos != (head); pos = pos-next)#define list_entry(ptr, type, member)container_of(ptr, type, member)#define 这个宏十分重要思路就是，取出ptr，并减去其所在结构体中的偏移量，最后将结果强转为my_struct（本宏具有普遍性）当然还有一个简单的法子，就是把链表的list结构放到my_struct结构的开头，则只需强转即可（限制较多，我司貌似是这么干的）container_of(ptr, type, member) ( const typeof( (type *)0)-member ) *_mptr = (ptr); (type *)( (char *)_mptr - offsetof(type,member) );)2.5 小结上面的例子，实际上是一个可重用性很强的，用C实现继承的例子。我们可以发现，在代码重用方面，C虽然没有提供专门的机制，但我们还是能够实现这一点的，只不过需要我们更好的设计数据结构，以及抽象、封装我们的代码3 C实现多态同样从第一节我们可以知道，多态的目的就是要进行接口复用，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：void HandleMsg(unsinged int id, void *p) Msg1 *p1; Msg2 *p2; switch(id) case key1: p1 = (Msg1*)p; /do something break; case key2: p2 = (Msg2*)p; /do something break; default: break; 举例2：void * memcpy(void *dest, const void *src, size_t len)3.1.3 方法三：综合这里可以考虑入参传入一个结构体：struct my_structmineunsigned numArg; /参数个数struct *st_Arg; /参数链表，每个节点再分别定义参数类型，与取值3.2 覆盖一般而言，覆盖的实现，主要是通过函数指针，通过记录操作符的方式。最经典的例子，莫过于Linux中的VFS层的实现了，下面简单介绍一下3.2.1 Linux VFS的原理与层次图VFS在底层的各种文件系统之上，建立了一层抽象层，对上屏蔽了各种文件系统 的差异。这么一来，使得Linux能够支持多种文件系统，即使不同的文件系统在功能和行为上有很大的差异。VFS实际上是提供了一个模型，该模型定义了各种文件系统实际上应该支持的各种功能，比如“打开文件”、“文件读写”等等。与此同时，各种文件系统也必须按照VFS的规定，来实现各种接口所对应的功能，提供VFS所期望的接口与数据结构，这样VFS就能够毫不费力的进行文件系统的管理了3.2.2 Linux VFS的面向对象设计VFS主要有四个对象类型：超级快对象：代表一个已经安装的文件系统；索引节点对象：代表一个文件；目录项对象：路径的一个组成部分；文件对象：代表有进程打开的文件。每个对象不仅定义了自己的属性，关键的是，都会有一个操作符结构体，里面定义了不同的对象需要具备的方法：这些方法由不同的文件系统对其进行赋值，即不同的文件系统负责给其提供具体的实现。下图是inode对象的操作符也就是所谓的 函数列表，在里面可以看到我们很多熟悉的操作：开源的dhcpd，其对universe的处理，事实上也是同样的设计思路3.2.3 小结从上面可以看出，文件系统的操作符的实现，实际上就是函数指针的运用，不同的对象向上层的抽象管理层提供各自的处理函数，使得抽象层能够屏蔽掉下面的实现细节这样处理的实质，就是接口复用3.3 模板一般而言，覆盖的C实现，主要是运用好预处理中的 # 符号，通过该符号，将name作为宏的参数传入，即可在编译阶段生成新的类，并具有各自的处理函数。当然类型也需要传入具体细节可以参见后面的示例4 例子4.1 运行时多态#ifndef C_Class #define C_Class struct定义自己的关键字，亲切 #endifC_Class A C_Class A *A_this; void (*Foo)(C_Class A *A_this); int a; int b; ;C_Class B /B继承了A C_Class B *B_this; /顺序很重要 void (*Foo)(C_Class B *Bthis); /虚函数 int a; int b; int c; ; void B_F2(C_Class B *Bthis) printf(It is B_Funn); void A_Foo(C_Class A *Athis) printf(It is A.a=%dn,Athis-a);/或者这里void B_Foo(C_Class B *Bthis) printf(It is B.c=%dn,Bthis-c); void A_Creat(struct A* p) p-Foo=A_Foo; p-a=1; p-b=2; p-A_this=p; void B_Creat(struct B* p) p-Foo=B_Foo; p-a=11; p-b=12; p-c=13; p-B_this=p;int main(int argc, char* argv) C_Class A *ma,a; C_Class B *mb,b; A_Creat(&a);/实例化 B_Creat(&b); mb=&b; ma=&a; ma=(C_Class A*)mb; /引入多态指针 printf(%dn,ma-a); /可惜的就是 函数变量没有private ma-Foo(ma); /多态 a.Foo(&a); /不是多态了 B_F2(&b); /成员函数，因为效率问题不使用函数指针 return 0; 4.2 纯虚类/-结构体中的函数指针类似于声明子类中必须实现的虚函数- typedef struct void (*Foo1)(); char (*Foo2)(); char* (*Foo3)(char* st); MyVirtualInterface; /-类似于纯虚类的定义- MyVirtualInterface* m_pInterface; DoMyAct_SetInterface(MyVirtualInterface* pInterface) m_pInterface = pInterface; void DoMyAct_Do() if(m_pInterface = NULL) return; m_pInterface-Foo1(); c = m_pInterface-Foo2(); /-子类一-MyVirtualInterface stMAX;/接着定义一些需要实现的函数 Act1_Foo1，Act1_Foo2，Act1_Foo3MyVirtualInterface* Act1_CreatInterface() index = FindValid() /对象池或者使用Malloc！应该留在外面申请，实例化 if(index = -1) return NULL; stindex.Foo1 = Act1_Foo1; / Act1_Foo1要在下面具体实现 stindex.Foo2 = Act1_Foo2; stindex.Foo3 = Act1_Foo3; Return &stindex; /-主函数- if(p = Act1_CreatInterface() != NULL) List_AddObject(&List, p); /Add All While(p = List_GetObject() DoMyAct_SetInterface(p); /使用Inter