| blob | e3110dead6affaf9ff18645580434f3ae75d0ecc |
2 <!-- This collection of hypertext pages is Copyright 1995, 1996 by Steve Summit. -->
3 <!-- This material may be freely redistributed and used -->
4 <!-- but may not be republished or sold without permission. -->
5 <html>
6 <head>
13 </head>
14 <body>
17 page 67
18 <p>Deep paragraph:
19 <blockquote>Functions break large computing tasks into smaller ones,
20 and enable people to build on what others have done
21 instead of starting over from scratch.
22 Appropriate functions hide details of operation
23 from parts of the program that don't need to know about them,
24 thus clarifying the whole,
25 and easing the pain of making changes.
26 </blockquote>Functions are probably the most import weapon
27 in our battle against software complexity.
28 You'll want to learn when it's appropriate
29 to break processing out into functions
30 (and also when it's not),
32 to best achieve the qualities mentioned above:
33 reuseability,
34 information hiding,
35 clarity,
36 and
37 maintainability.
38 </p><p>The quoted sentences above
39 show that a function does more than just save typing:
40 a well-defined function can be re-used later,
41 and eases the mental burden of thinking about a complex program
42 by freeing us from having to worry about all of it at once.
43 For a well-designed function,
44 at any one time,
45 we should either have to think about:
46 <OL><li>that function's internal implementation
47 (when we're writing or maintaining it);
48 or
49 <li>a particular call to the function
50 (when we're working with code which uses it).
52 think about the internals when we're calling it,
53 or
54 about the callers when we're implementing the internals.
55 (We should perhaps think about the callers just enough to
56 ensure that the function we're designing will be easy to call,
57 and that
58 we aren't accidentally setting up
59 so that callers will have to think about any internal details.)
60 </p><p>Sometimes,
61 we'll write a function which we only call once,
62 just because breaking it out into a function
63 makes things clearer and easier.
64 </p><p>Deep sentence:
65 <blockquote>C has been designed to make functions efficient and easy to use;
66 C programs generally consist of many small functions
67 rather than a few big ones.
68 </blockquote>Some people worry about ``function call overhead,''
69 that is,
70 the work that a computer has to do to set up and return from a function call,
71 as opposed to simply doing the function's statements in-line.
72 It's a risky thing to worry about,
73 though,
74 because as soon as you start worrying about it,
75 you have a bit of a disincentive to use functions.
76 If you're reluctant to use functions,
77 your programs will probably be
78 bigger and more complicated and harder to maintain
80 </p><p>The authors choose not to get involved with
81 the system-specific aspects of separate compilation,
82 but we'll take a stab at it here.
83 We'll cover two possibilities,
84 depending on whether you're using a traditional command-line compiler
85 or a newer integrated development environment (IDE)
86 or other graphical user interface (GUI) compiler.
87 </p><p>When using a command-line compiler,
88 there are usually two main steps involved
89 in building an executable program
90 from one or more source files.
91 First,
92 each source file is compiled,
94 containing the machine instructions
95 (generated by the compiler)
96 corresponding to the code in that source file.
97 Second,
100 containing code for functions which you did not write
103 to produce a final, executable program.
105 So far, we've been using extremely simple invocations of
107 <pre> cc hello.c
109 This invocation compiles a single source file,
110 links it,
111 and places the executable
112 (somewhat inconveniently)
114 </p><p>Suppose we have a program which we're trying to build
115 from three separate source files,
117 We could compile all three of them,
118 and link them together,
119 all at once,
120 with the command
121 <pre> cc x.c y.c z.c
123 Alternatively,
124 we could compile them separately:
126 but not to link.
127 Instead of building an executable,
128 it merely creates an object file,
130 for each source file compiled.
131 So the three commands
132 <pre> cc -c x.c
133 cc -c y.c
134 cc -c y.c
137 Then, the three object files could be linked together using
138 <pre> cc x.o y.o z.o
140 it knows that it does not have to compile it
141 (it's an object file, already compiled);
142 it just sends it through to the link process.
143 </p><p>Here we begin to see one of the advantages of separate compilation:
145 only it will need recompiling.
147 which keeps track of which parts need recompiling
148 and issues the appropriate commands for you.)
149 </p><p>Above we mentioned that the second,
150 linking step also involves pulling in library functions.
151 Normally, the functions from the Standard C library are linked
152 in automatically.
153 Occasionally, you must request a library manually;
154 one common situation under Unix
155 is that certain math routines are in a separate math library,
158 your program's own object files are linked
159 (so that the linker knows which library functions your program uses),
162 For example,
165 together with the math library,
166 you might use
167 <pre> cc mymath.o -lm
170 for all of your programs,
172 <pre> cc -o hello hello.c
175 Finally,
177 also applies to most other Unix C compilers.
182 (the FSF's GNU C Compiler,
183 which also accepts ANSI C and is free).
184 </p><p>There are command-line compilers for MS-DOS systems which work similarly.
186 (``compile and link'') command,
188 You can compile and link in one step:
189 <pre> cl hello.c
190 </pre>or you can compile only:
191 <pre> cl /c hello.c
194 </p><p>The preceding has all been about command-line compilers.
195 If you're using some kind of integrated development environment,
196 such as Turbo C or the Microsoft Programmer's Workbench or Think C,
197 most of the mechanical details are taken care of for you.
198 (There's also less I can say here about these environments,
199 because they're all different.)
200 Typically there's a way to specify the list of files (modules)
201 which make up your project,
202 and a single ``build'' button which does whatever's required
203 to build (and perhaps even execute) your program.
218 <hr>
219 <p>
220 Read sequentially:
225 </p>
226 <p>
230 </p>
231 </body>
232 </html>