使用C语言实现面向对象编程

5星 · 超过95%的资源需积分: 50 63 浏览量更新于2024-07-30 收藏 1.2MB PDF 举报

"用C实现面向对象.pdf" 在计算机编程领域，面向对象编程（Object-Oriented Programming，简称OOP）是一种广泛采用的编程范式，它强调将数据和操作数据的方法封装在一起，形成对象，以此来提高代码的重用性和可维护性。尽管C++、Eiffel、Oberon-2和Smalltalk等语言是为支持OOP而设计的，但本资料《用C实现面向对象》探讨的是如何在传统的C语言中实现OOP的概念。 C语言本身并不直接支持面向对象特性，如类、继承、多态和封装等，但它提供了足够的底层控制，允许程序员通过结构体和函数指针等机制模拟这些特性。书中的内容可能包括以下几个方面： 1. **结构体与数据封装**：C语言中的结构体可以用来表示一个对象，将相关的数据成员组合在一起。通过定义结构体类型，我们可以创建具有特定属性的实例。同时，通过指向结构体的指针，可以实现对对象的引用和操作。 2. **函数指针与方法**：在C中，函数指针可以用于模拟面向对象中的方法调用。将函数指针作为结构体的成员，可以将操作绑定到数据上，类似于对象的方法。 3. **模拟类和对象**：通过定义一个结构体来表示类，并使用函数指针实现类的方法。创建结构体实例相当于创建对象，初始化时可以将方法指针绑定到相应的函数。 4. **动态内存分配与对象实例化**：在C中，对象通常通过`malloc()`或`calloc()`动态分配内存，这样可以在运行时创建对象，提高代码的灵活性。 5. **模拟继承**：通过结构体嵌套或继承结构体，可以实现类似继承的效果。子结构体可以包含父结构体，从而继承其属性和方法。 6. **多态性**：虽然C语言没有内置的多态机制，但可以通过函数指针或回调函数实现多态行为。不同的对象可以关联不同的函数指针，使得同一接口可以有不同的实现。 7. **动态绑定和虚函数表**：虽然C不支持虚函数，但可以通过自定义虚函数表来模拟这个功能。每个对象维护一个函数指针数组，用于在运行时确定调用哪个方法。 8. **封装与访问控制**：C语言没有内置的访问修饰符，但可以通过命名约定（如前缀下划线`_`表示私有）来实现类似的效果，限制对数据成员的直接访问。 9. **代码重用与库**：通过编写可重用的函数库，以及提供一组公共接口，可以实现跨项目代码重用，这在C语言中是非常常见的实践。《用C实现面向对象》这本书旨在揭示面向对象编程的原理，并展示如何在C语言这一非面向对象的语言中实现这些概念，帮助读者理解OOP的核心思想，并能够在实际项目中应用这些技巧。通过学习，开发者不仅可以深化对C语言的理解，还能掌握如何在有限的工具集内实现强大的软件设计原则。

___________________________________________________________________________

1 Abstract Data Types

— Information Hiding

apply() calls action() for each element in set and passes the rest of the argument

list. action() must not change set but it may return zero to terminate apply() early.

apply() returns true if all elements were processed.

___________________________________________________________________________

Dynamic Linkage

Generic Functions

2.1 Constructors and Destructors

Let us implement a simple string data type which we will later include into a set.

For a new string we allocate a dynamic buffer to hold the text. When the string is

deleted, we will have to reclaim the buffer.

new() is responsible for creating an object and delete() must reclaim the

resources it owns. new() knows what kind of object it is creating, because it has

the description of the object as a first parameter. Based on the parameter, we

could use a chain of if statements to handle each creation individually. The draw-

back is that new() would explicitly contain code for each data type which we sup-

port.

delete(), however, has a bigger problem. It, too, must behave differently based

on the type of the object being deleted: for a string the text buffer must be freed;

for an object as used in chapter 1 only the object itself has to be reclaimed; and a

set may have acquired various chunks of memory to store references to its ele-

ments.

We could give delete() another parameter: either our type descriptor or the

function to do the cleaning up, but this approach is clumsy and error-prone. There

is a much more general and elegant way: each object must know how to destroy

its own resources. Part of each and every object will be a pointer with which we

can locate a clean-up function. We call such a function a destructor for the object.

Now new() has a problem. It is responsible for creating objects and returning

pointers that can be passed to delete(), i.e., new() must install the destructor infor-

mation in each object. The obvious approach is to make a pointer to the destructor

part of the type descriptor which is passed to new(). So far we need something like

the following declarations:

struct type {

size_t size; /* size of an object */

void (* dtor) (void *); /* destructor */

};

struct String {

char * text; /* dynamic string */

const void * destroy; /* locate destructor */

};

struct Set {

... information ...

const void * destroy; /* locate destructor */

};

___________________________________________________________________________

2 Dynamic Linkage — Generic Functions

It looks like we have another problem: somebody needs to copy the destructor

pointer dtor from the type description to destroy in the new object and the copy

may have to be placed into a different position in each class of objects.

Initialization is part of the job of

new() and different types require different work

— new() may even require different arguments for different types:

new(Set); /* make a set */

new(String, "text"); /* make a string */

For initialization we use another type-specific function which we will call a

construc-

tor. Since constructor and destructor are type-specific and do not change, we pass

both to new() as part of the type description.

Note that constructor and destructor are not responsible for acquiring and

releasing the memory for an object itself — this is the job of new() and delete().

The constructor is called by new() and is only responsible for initializing the memory

area allocated by new(). For a string, this does involve acquiring another piece of

memory to store the text, but the space for struct String itself is allocated by

new(). This space is later freed by delete(). First, however, delete() calls the des-

tructor which essentially reverses the initialization done by the constructor before

delete() recycles the memory area allocated by new().

2.2 Methods, Messages, Classes and Objects

delete() must be able to locate the destructor without knowing what type of object

it has been given. Therefore, revising the declarations shown in section 2.1, we

must insist that the pointer used to locate the destructor must be at the beginning

of all objects passed to delete(), no matter what type they have.

What should this pointer point to? If all we have is the address of an object,

this pointer gives us access to type-specific information for the object, such as its

destructor function. It seems likely that we will soon invent other type-specific

functions such as a function to display objects, or our comparison function differ(),

or a function clone() to create a complete copy of an object. Therefore we will use

a pointer to a table of function pointers.

Looking closely, we realize that this table must be part of the type description

passed to new(), and the obvious solution is to let an object point to the entire type

description:

struct Class {

size_t size;

void * (* ctor) (void * self, va_list * app);

void * (* dtor) (void * self);

void * (* clone) (const void * self);

int (* differ) (const void * self, const void * b);

};

struct String {

const void * class; /* must be first */

char * text;

};

___________________________________________________________________________

2.3 Selectors, Dynamic Linkage, and Polymorphisms

struct Set {

const void * class; /* must be first */

...

};

Each of our objects starts with a pointer to its own type description, and through

this type description we can locate type-specific information for the object:

.size is

the length that new() allocates for the object; .ctor points to the constructor called

by new() which receives the allocated area and the rest of the argument list passed

to new() originally; .dtor points to the destructor called by delete() which receives

the object to be destroyed; .clone points to a copy function which receives the

object to be copied; and .differ points to a function which compares its object to

something else.

Looking down this list, we notice that every function works for the object

through which it will be selected. Only the constructor may have to cope with a

partially initialized memory area. We call these functions methods for the objects.

Calling a method is termed a message and we have marked the receiving object of

the message with the parameter name self. Since we are using plain C functions,

self need not be the first parameter.

Many objects will share the same type descriptor, i.e., they need the same

amount of memory and the same methods can be applied to them. We call all

objects with the same type descriptor a class; a single object is called an instance

of the class. So far a class, an abstract data type, and a set of possible values

together with operations, i.e., a data type, are pretty much the same.

An object is an instance of a class, i.e., it has a state represented by the

memory allocated by new() and the state is manipulated with the methods of its

class. Conventionally speaking, an object is a value of a particular data type.

2.3 Selectors, Dynamic Linkage, and Polymorphisms

Who does the messaging? The constructor is called by new() for a new memory

area which is mostly uninitialized:

void * new (const void * _class, ...)

{ const struct Class * class = _class;

void * p = calloc(1, class —> size);

assert(p);

* (const struct Class **) p = class;

if (class —> ctor)

{ va_list ap;

va_start(ap, _class);

p = class —> ctor(p, & ap);

va_end(ap);

}

return p;

}

The existence of the struct Class pointer at the beginning of an object is extremely

important. This is why we initialize this pointer already in new():

___________________________________________________________________________

2 Dynamic Linkage

— Generic Functions

•p

object

•

...........

class

size

ctor

dtor

clone

differ

struct Class

The type description class at the right is initialized at compile time. The object is

created at run time and the dashed pointers are then inserted. In the assignment

* (const struct Class **) p = class;

p points to the beginning of the new memory area for the object. We force a

conversion of p which treats the beginning of the object as a pointer to a struct

Class and set the argument class as the value of this pointer.

Next, if a constructor is part of the type description, we call it and return its

result as the result of new(), i.e., as the new object. Section 2.6 illustrates that a

clever constructor can, therefore, decide on its own memory management.

Note that only explicitly visible functions like new() can have a variable parame-

ter list. The list is accessed with a va_list variable ap which is initialized using the

macro va_start() from stdarg.h. new() can only pass the entire list to the construc-

tor; therefore, .ctor is declared with a va_list parameter and not with its own vari-

able parameter list. Since we might later want to share the original parameters

among several functions, we pass the address of ap to the constructor — when it

returns, ap will point to the first argument not consumed by the constructor.

delete() assumes that each object, i.e., each non-null pointer, points to a type

description. This is used to call the destructor if any exists. Here, self plays the

role of p in the previous picture. We force the conversion using a local variable cp

and very carefully thread our way from self to its description:

void delete (void * self)

{ const struct Class ** cp = self;

if (self && * cp && (* cp) —> dtor)

self = (* cp) —> dtor(self);

free(self);

}

The destructor, too, gets a chance to substitute its own pointer to be passed to

free() by delete(). If the constructor decides to cheat, the destructor thus has a

chance to correct things, see section 2.6. If an object does not want to be deleted,

its destructor would return a null pointer.

All other methods stored in the type description are called in a similar fashion.

In each case we have a single receiving object self and we need to route the

method call through its descriptor:

剩余220页未读，继续阅读

boxerxiong

粉丝: 0
资源: 33

使用C语言实现面向对象编程

用C语言实现面向对象编程.pdf

用C-语言实现面向对象编程.pdf

用C语言实现面向对象研究.pdf

c语言面向对象pdf

c++ 面向对象高效编程 pdf

C# C:\Users\Lee\Desktop\6PB0435401GP.pdf取值最后字符.后面的字符串

objc app架构.pdf

《数据结构用面向对象方法与c++描述》pdf第二版

有C语言编写的设计模式的pdf书籍吗

c++对象模型 pdf

最新资源