The structure (or struct) in C is analogous to a degenerate class (class with no methods) in Java. Also, structs have no mechanism for data hiding - all fields (data members to you Java disciples) defined in the struct are public and accessible to client code via the dot operator. Further, there is no bundling of functions (methods) with the data - although function pointers can be stored as fields. Lastly, since there is no OOP in C - a struct cannot be used to derive other classes. There is no inheritance, only composition.
One other significant difference between a Java class and a C struct is that in Java when you declare a class variable you are creating a reference to an object and, usually, instantiating an object of the type. In C, when you define a struct variable you are getting what is essentially a standard variable. The effect of this is as follows: when you pass a struct into a function as a parameter you are passing a copy of the struct, not a pointer to it. A struct's name is NOT an address, like an array. A struct's name is like the name of a primitive type such as int, char, double etc. You can, of course, explicitly declare a pointer to a struct or use the & operator on a struct's name in order to pass the address of the struct into a function. We will now look at code that declares automatic and dynamic struct variables and passes the structs or their addresses into functions.
Note in the above sample we declare a local struct variable and use the dot notation to access the fields inside. The string hanging from the name field is created at run-time but the struct itself is a compile-time, stack-allocated, local variable.
You'll notice the use of typedef to simplify the declaration of struct variables. There are LOTS of ways to declare the person struct (with name (char *) and age (int) members):
struct {
char *name;
int age;
} p, p2, p3; /* 8 bytes of storage allocated for each of p, p2, p3 */
/* but this doesn't allow for additional variable declarations except here */
struct Person {
char *name;
int age;
}; /* don't forget the semi-colon! */
/* no storage allocated */
struct Person p, p2, p3; /* storage allocated for p, p2, p3 */
/* could add */
typedef struct Person Person;
/* and then declare the variable as */
Person p, p2, p3; */
struct {
char *name;
int age;
} typedef Person; /* don't forget the semi-colon! */
/* no storage allocated */
Person p, p2 p3; /* storage allocated for p, p2, p3 */
typedef struct {
char * name;
int age;
} Person; /* don't forget the semi-colon! */
/* no storage allocated */
Person p, p2 p3; /* storage allocated for p, p2, p3 */
Regardless of how you declare it, the only legal operations on a struct are
HandsOn: We played around quite a bit with this code,
writing functions that would modify the age field of an arbitrary
Person. Our final version can be found in
structs_1-rev.c.
We then proceeded to look at pointers to structs in
Note in demo 2 that we introduce the -> operator. This operator is a shortcut that combines the dereference and the field-access operator. Thus, p->field is synonymous with (*p).field (the parentheses around *p are important! Clearly the -> notation is simpler and is preferred. The rule concerning whether to use . or ->) is simple: if you are accessing the struct via its name, use the . (dot) operator to access the fields; if you accessing the struct via a pointer, use the -> operator.
One other warning about structs before we go on. While it is the case that the fields of a struct are allocated in the same order that they are declared, alignment rules may force "spaces" in the actual memory allocated, so you can never assume that the sizeof a struct is equal to the sum of the sizes of the individual fields. more specifically, never try to do "pointer arithmetic" to calculate the address (offset) of where some field starts inside the struct. Of course, if one of the fields is an array you may use pointer arithmetic on (within) the array itself, but you must never use pointer arithmetic to calculate the offset from the start of the struct to where any field starts. Pointer arithmetic is for elements that are guaranteed to be contiguous in storage and homogenous in size. The fields within a struct are guaranteed to be neither.
Looking at the Person struct, the member name is a char *, i.e., a pointer to char. You should not assume that the first 4 bytes of the struct are the name field or that the second 4 bytes of a Person are the age field. The name field will, indeed, be allocated a memory address that occurs before the age field, but the compiler reserves the right to store the fields aligned as it needs. As a result, you cannot assume that the sizeof a struct is the sum of the sizeof's of its constituent fields (although, clearly, the sizeof the struct must be at least this large!). Sometimes the compiler has to pad to ensure that certain types start on a word boundary. You will cover this topic in more detail in 15-213.
Let's now look at
And finally, let's look at
Some discussion points: