Object-oriented programming with C.英文版

v

___________________________________________________________________________

Preface

No programming technique solves all problems.

No programming language produces only correct results.

No programmer should start each project from scratch.

Object-oriented programming is the current cure-all — although it has been

around for much more then ten years. At the core, there is little more to it then

finally applying the good programming principles which we have been taught for

jects — although the idea of subroutines is as old as computers and good program-

mers always carried their toolkits and libraries with them.

This book is not going to praise object-oriented programming or condemn the

Old Way. We are simply going to use

gramming is done, what its techniques are, why they help us solve bigger prob-

lems, and how we harness generality and program to catch mistakes earlier. Along

the way we encounter all the jargon — classes, inheritance, instances, linkage,

methods, objects, polymorphisms, and more — but we take it out of the realm of

comfortable with structures, pointers, prototypes, and function pointers is a must.

Orwell and Webster a language ‘‘designed to diminish the range of thought’’ — and

I will try to demonstrate how it merely combines all the good programming princi-

ples that you always wanted to employ into a coherent approach. As a result, you

may well become a more proficient

with

grammers use tools. Good programmers make tools to dispose of routine tasks

once and for all. Object-oriented programming with

ANSI-C requires a fair amount

of immutable code — names may change but not the structures. Therefore, in

chapter seven we build a small preprocessor to create the boilerplate required. It

looks like yet another new object-oriented dialect language (yanoodl perhaps?) but

it should not be viewed as such — it gets the dull parts out of the way and lets us

concentrate on the creative aspects of problem solving with better techniques. ooc

vi

___________________________________________________________________________

Preface

automatic initialization to prevent another class of bugs. Chapter ten introduces

delegates and shows how classes and callback functions cooperate to simplify, for

example, the constant chore of producing standard main programs. More chapters

are concerned with plugging memory leaks by using class methods, storing and

loading structured data with a coherent strategy, and disciplined error recovery

through a system of nested exception handlers.

Finally, in the last chapter we leave the confines of

ANSI-C and implement the

obligatory mouse-operated calculator, first for

curses and then for the X Window

building the techniques from scratch, I have refrained from making and using a

massive class library, even though some examples could have benefited from it. If

you want to understand object-oriented programming, it is more important to first

master the techniques and consider your options in code design; dependence on

somebody else’s library for your developments should come a bit later.

An important part of this book is the enclosed source floppy — it has a

DOS file

system containing a single shell script to create all the sources arranged by chapter.

There is a ReadMe file — consult it before you say make. It is also quite instructive

shown this to a number of people in courses and workshops and others have used

the methods to get their jobs done. It would have stopped there as my footnote to

a fad, if Brian Kernighan and my publishers, Hans-Joachim Niclas and John Wait,

had not encouraged me to publish the notes (and in due course to reinvent it all

once more). My thanks go to them and to all those who helped with and suffered

through the evolution of this book. Last not least I thank my family — and no,

Hollage, October 1993

___________________________________________________________________________

1.3 An Example — Set ...................

1.5 Object .......................

1.7 An Implementation —

2 Dynamic Linkage — Generic Functions

2.1 Constructors and Destructors .............. 11

2.2 Methods, Messages, Classes and Objects ......... 12

2.5 An Implementation — String ............... 17

2.6 Another Implementation — Atom ............. 18

2.7 Summary ...................... 20

2.8 Exercises ...................... 20

3.6 Dynamic Linkage ................... 25

3.7 A Postfix Writer .................... 26

3.8 Arithmetic ...................... 28

3.9 Infix Output ..................... 28

3.10 Summary ...................... 29

4 Inheritance — Code Reuse and Refinement ........... 31

4.2 Superclass Implementation — Point ............ 32