| blob | 9e59805f1ed6426352aff5c7ecfe5bb99bff4815 |
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>
21 found in some other languages.)
22 Defining structures is a two-step process:
23 first you define a ``template'' which describes the new type,
24 then you declare variables having the new type
25 (or functions returning the new type, etc.).
26 </p><p>As a simple example,
27 suppose we wanted to define our own type for representing complex numbers.
28 (If you're blissfully ignorant of these beasts,
29 a complex number consists of
30 a ``real'' and ``imaginary'' part,
31 where the imaginary part is some multiple of the square root of negative 1.
32 You don't have to understand complex numbers to understand this example;
33 you can think of the real and imaginary parts
35 FORTRAN has a built-in complex type, but C does not.
37 How might we add one?
38 Since a complex number consists of a real and imaginary part,
39 we need a way of holding both these quantities in one data type,
40 and a structure will do just the trick.
41 Here is how we might declare our complex type:
42 <pre>
43 struct complex
44 {
45 double real;
46 double imag;
47 };
48 </pre>
49 A structure declaration consists of
50 up to
51 four parts,
52 of which we can see three in the example above.
54 which indicates that we are talking about a structure.
56 by which this structure
57 (that is, this new data type)
58 will be known.
62 and contains what look like the declarations of ordinary variables.
63 Each member has a name and a type,
64 just like ordinary variables,
65 but here we are not declaring variables;
66 we are setting up the structure of the structure
68 by defining the collection of data types which will make up the structure.
70 will be made up of two members,
73 </p><p>It's important to understand that what we've defined here
74 is just the new data type;
77 (the second part of the structure declaration)
78 is not the name of a variable;
79 it's the name of the structure type.
81 they're identifiers for the two components of the structure.
83 with declarations like these:
84 <pre>
85 struct complex c1;
86 or
87 struct complex c2, c3;
88 </pre>
89 These look almost like our previous declarations
90 of variables having basic types,
91 except that instead of a type keyword
95 that we're talking about a structure,
97 is the name
98 for the particular structure we're talking about.
101 each one of them will have real and imaginary parts buried inside them.
102 (We'll see how to get at those parts in the next section.)
103 Using our graphic, ``labeled box'' notation,
104 we could draw representations of
106 like this:
107 <br>
109 <br>
110 Actually, these pictures are a bit misleading;
111 the outer box indicating each composite structure
112 suggests that there might be more inside them
113 than just the two members,
116 A simpler but more representative picture would be:
117 <br>
119 <br>
121 (the two boxes);
122 all
123 the
124 names
125 are just for our convenience
126 and the compiler's reference;
127 none are typically stored
128 in the program's memory
129 at run time.
130 </p><p>Notice that when we define structures in this way
131 we have not quite defined a new type
134 <pre>
135 complex c1; /* WRONG */
136 </pre>
139 it's just the name of a particular structure,
143 to talk about that structure type.
144 (There is a way to define new full-fledged type names
146 and in C++ a new structure does automatically become a full-fledged type,
147 but we won't worry about these wrinkles for now.)
148 </p><p>I said that a structure definition consisted of
149 up to
150 four parts.
151 We saw the first three of them in the first example;
152 the fourth
153 part
154 of a full strucure declaration
155 is simply a list of variables,
156 which are to be declared as having the structure type
158 at the same time as the structure itself is defined.
159 For example, if we had written
160 <pre>
161 struct complex
162 {
163 double real;
164 double imag;
165 } c1, c2, c3;
166 </pre>
168 and right away declared three variables
171 </p><p>In fact, three of the four parts of a structure declaration
174 are optional.
176 a structure tag,
177 and a brace-enclosed list of members
178 (as in the first structure definition we saw),
179 it's a definition of the structure itself
180 (that is, just the template).
182 a structure tag,
183 and a list of variable names
184 (as in the first declarations of
186 we saw),
187 it's a declaration of those variables having that structure type
188 (the structure type itself must of course typically be declared elsewhere).
189 If a declaration contains all four elements
190 (as in the second declaration of
192 we saw),
194 a declaration of some variables.
195 It's also possible to use the first, third, and fourth parts:
196 <pre>
197 struct {
198 double real;
199 double imag;
200 } c1, c2, c3;
201 </pre>
203 as having a structure type with no tag name,
204 which is not usually very useful,
205 because without a tag name
206 we won't be able to declare any other variables or functions of this type
208 (Finally, it's also possible to declare just the tag name,
209 leaving both the list of members
210 and any declarations of variables for later,
211 but
212 this
214 is only needed in certain fairly rare and obscure situations.)
215 </p><p>Because a structure definition can also declare variables,
216 it's important not to forget the semicolon
217 at the end of a structure definition.
218 If you accidentally write
219 <pre>
220 struct complex
221 {
222 double real;
223 double imag;
224 }
225 </pre>
226 without a semicolon,
227 the compiler will keep looking for something later in the file
228 and try to declare it
229 as being
231 which will either result in a confusing error message or
232 (if the compiler succeeds)
233 a confusing misdeclaration.
234 </p><hr>
235 <p>
236 Read sequentially:
241 </p>
242 <p>
246 </p>
247 </body>
248 </html>