| blob | 8d3b6907e672f0f3f2f1fe928f68395f7c4beff3 |
2 <!-- This collection of hypertext pages is Copyright 1995-7 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>
18 </p><p>The last preprocessor directive we're going to look at is
20 If you have the sequence
21 <pre>
24 #else
26 #endif
27 </pre>
28 in your program,
29 the code that gets compiled depends on whether a preprocessor macro by that
31 If it is
35 then
38 If the macro is not defined,
42 but it behaves completely differently:
44 program are executed at run time,
46 get compiled.
55 depending on whether a compile-time expression is true or false.
57 are somewhat restricted,
58 however, so we won't talk much
61 </p><p>Conditional compilation is useful in two general classes of
62 situations:
63 <UL><li>You are trying to write a portable program,
64 but the way you do something is different depending on what
65 compiler, operating system, or computer you're using.
66 You place different versions of your code,
67 one for each situation,
69 and when you compile the progam in a particular environment,
70 you arrange to have the macro names defined which select the variants you
71 need in that environment.
72 (For this reason, compilers usually have ways of letting you
73 define macros from the invocation command line or in a
74 configuration file,
75 and many also predefine certain macro names related to
76 the operating system, processor, or compiler in use.
77 That way, you don't have to change the code to change the
79 environment.)
80 <br>
81 <br>
83 On older Unix systems, however, the function was called
86 file you want to delete,
87 and if you want to be able to compile the program under these
88 older Unix systems, you might write
89 <pre>
90 #ifdef unix
91 unlink(filename);
92 #else
93 remove(filename);
94 #endif
95 </pre>
96 Then, you could place the line
97 <pre>
98 #define unix
99 </pre>
100 at the top of the file when compiling under an old Unix system.
103 you don't need to give it any replacement text at all.
105 even if the replacement text is empty,
107 <br>
108 <br>
109 (In fact, in this example,
111 because C compilers on old Unix systems tend to predefine it for you,
112 precisely so you can make tests like these.)
113 <li>You want to compile several different versions of your program,
114 with different features present in the different versions.
116 directives,
117 and (as for the previous case)
118 arrange to have the right macros defined or not to build the
119 version you want to build
120 at any given time.
121 This way, you can build the several different versions from the
122 same source code.
123 (One common example is whether you turn debugging statements on
124 or off.
125 You can bracket each debugging printout with
127 and then turn on debugging only when you need it.)
128 <br>
129 <br>
130 For example, you might use lines like this:
131 <pre>
132 #ifdef DEBUG
133 printf("x is %d\n", x);
134 #endif
135 </pre>
137 your program to see if it's what you expect.
138 To enable debugging printouts, you insert the line
139 <pre>
140 #define DEBUG
141 </pre>
142 at the top of the file,
143 and to turn them off, you delete that line,
144 but the debugging printouts quietly remain in your code,
145 temporarily deactivated,
146 but ready to reactivate if you find yourself needing them again later.
150 line.)
151 </UL>Conditional compilation can be very handy, but it can also get
152 out of hand.
153 When large chunks of the program are completely different depending on,
154 say, what operating system the program is being compiled for,
155 it's often better to place the different versions in separate
156 source files,
157 and then only use one of the files
158 (corresponding to one of the versions)
159 to build the program on any given system.
160 Also, if you are using an ANSI Standard compiler and you are
161 writing ANSI-compatible code,
162 you usually won't need so much conditional compilation,
163 because the Standard specifies exactly how the compiler must do certain things,
164 and exactly which library functions it much provide,
165 so you don't have to work so hard to accommodate the old
166 variations among compilers and libraries.
167 </p><hr>
168 <p>
169 Read sequentially:
174 </p>
175 <p>
179 </p>
180 </body>
181 </html>