Quick Navigation Bar
strings :: structures :: advanced data structures
[ toc | forums ]

Note: If the document URL does not begin with https://randu.org/tutorials/c/ then you are viewing a copy. Please direct your browser to the correct location for the most recent version.

Structures

A structure in C is a collection of items of different types. You can think of a structure as a "record" is in Pascal or a class in Java without methods.
Structures, or structs, are very useful in creating data structures larger and more complex than the ones we have discussed so far. We will take a cursory look at some more complex ones in the next section.

Structures :: Declaration and Syntax

So how is a structure declared and initialized? Let's look at an example:

  struct student {
    char *first;
    char *last;
    char SSN[9];
    float gpa;
    char **classes;
  };

  struct student student_a, student_b;

Another way to declare the same thing is:

  struct {
    char *first;
    char *last;
    char SSN[10];
    float gpa;
    char **classes;
  } student_a, student_b;

As you can see, the tag immediately after struct is optional. But in the second case, if you wanted to declare another struct later, you couldn't.

The "better" method of initializing structs is:
```
  struct student_t {
    char *first;
    char *last;
    char SSN[10];
    float gpa;
    char **classes;
  } student, *pstudent;
```
Now we have created a student_t student and a student_t pointer. The pointer allows us greater flexibility (e.g. Create lists of students).
How do you go about initializing a struct? You could do it just like an array initialization. But be careful, you can't initialize this struct at declaration time because of the pointers.
But how do we access fields inside of the structure? C has a special operator for this called "member of" operator denoted by . (period). For example, to assign the SSN of student_a:
```
  strcpy(student_a.SSN, "111223333\0");
```

Structures :: Pointers to Structs

Sometimes it is useful to assign pointers to structures (this will be evident in the next section with self-referential structures). Declaring pointers to structures is basically the same as declaring a normal pointer:
```
  struct student *student_a;
```
But how do we dereference the pointer to the struct and its fields? You can do it in one of two ways, the first way is:
```
  printf("%s\n", (*student_a).SSN);
```
This would get the SSN in student_a. Messy and the readability is horrible! Is there a better way? Of course, programmers are lazy! :)
To dereference, you can use the infix operator: ->. The above example using the new operator:
```
  printf("%s\n", student_a->SSN);
```
If we malloc'd space for the structure for *student_a could we start assigning things to pointer fields inside the structure? No. You must malloc space for each individual pointer within the structure that is being pointed to.

Structures :: typedef

There is an easier way to define structs or you could "alias" types you create. For example:
```
  typedef struct {
    char *first;
    char *last;
    char SSN[9];
    float gpa;
    char **classes;
  } student;

  student student_a;
```
Now we get rid of those silly struct tags. You can use typedef for non-structs:
```
  typedef long int *pint32;

  pint32 x, y, z;
```
x, y and z are all pointers to long ints. typedef is your friend. Use it.

Structures :: Unions

Unions are declared in the same fashion as structs, but have a fundamental difference. Only one item within the union can be used at any time, because the memory allocated for each item inside the union is in a shared memory location. Why you ask? An example first:
```
  struct conditions {
    float temp;
    union feels_like {
      float wind_chill;
      float heat_index;
    }
  } today;
```
As you know, wind_chill is only calculated when it is "cold" and heat_index when it is "hot". There is no need for both. So when you specify the temp in today, feels_like only has one value, either a float for wind_chill or a float for heat_index.
Types inside of unions are unrestricted, you can even use structs within unions.

Structures :: Enumerated Types

What if you wanted a series of constants without creating a new type? Enter enumerated types. Say you wanted an "array" of months in a year:
```
  enum e_months {JAN=1, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC};
  typedef enum e_months month;

  month currentmonth;
  currentmonth = JUN;      /* same as currentmonth = 6; */
  printf("%d\n", currentmonth);
```
We are enumerating the months in a year into a type called month. You aren't creating a type, because enumerated types are simply integers. Thus the printf statement uses %d, not %s.
If you notice the first month, JAN=1 tells C to make the enumeration start at 1 instead of 0.

Note: This would be almost the same as using:

#define JAN 1
#define FEB 2
#define MAR 3
/* ... etc ... */

Structures :: Abilities and Limitations

You can create arrays of structs.
Structs can be copied or assigned.
The & operator may be used with structs to show addresses.
Structs can be passed into functions. Structs can also be returned from functions.
Structs cannot be compared!

Structures Review

Structures can store non-homogenous data types into a single collection, much like an array does for common data (except it isn't accessed in the same manner).
Pointers to structs have a special infix operator: -> for dereferencing the pointer.
typedef can help you clear your code up and can help save some keystrokes.
Enumerated types allow you to have a series of constants much like a series of #define statements.

Notice: Please do not replicate or copy these pages and host them elsewhere. This is to ensure that the latest version can always be found here.

Disclaimer: The document author has published these pages with the hope that it may be useful to others. However, the document author does not guarantee that all information contained on these webpages are correct or accurate. There is no warranty, expressed or implied, of merchantability or fitness for any purpose. The author does not assume any liability or responsibility for the use of the information contained on these webpages.

If you see an error, please send an email to the address below indicating the error. Your feedback is greatly appreciated and will help to continually improve these pages.