Lesson 09: Structures

9.1 Structures

The struct keyword is used to create an aggregate data type called a structure. A structure is a collection of one or more data members (variables). The data members in a structure can be of different types: Some can be int, some can be float, and some can be another struct, and so on. Structure in C/C++ is unlike the array, in which all the variables must be the same type.

There are many situations in which we want to process data about a certain entity or object, but the data consists of items of various types. For example, the data for a student (the student record) may consist of several fields such as a name, address, phone number (all are strings), number of courses taken (integer), fees payable (floating-point), student ID (string), grades obtained (character), and so on.

Suppose we want to store data for 30 students in a program. One solution is to have a separate array for each field and use subscripts to link the fields together. Thus, name[i], address[i], fees[i], and so on, refer to the data for the i_th student.

The problem with this solution is that if there are many fields, handling several parallel arrays becomes clumsy and unwieldy. For example, we want to pass a student's data to a function via the parameter list, which will involve the passing of several arrays. Also, when we are sorting the data by name field, we have to change the data in the other arrays when two names are swapped. In such situations, C structures are convenient to use.

In C++, a structure can contain both function and data members. The detailed structure in C++ will be discussed in C++ Lesson 02: Classes and Objects.

The format of the struct statement is as follows:

struct structure_name {
    type    member1;
    type    member2;
    ...
} variable_list;

Declare Structure and Structure Variables

A structure variable can either be declared with a structure declaration or a separate declaration like how we declare a variable.

Structure declaration

struct Point {              // Structure Declaration
    int     x;
    int     y;
};

The above statement defines a new data type (struct Point) that can be used in declaring other variables as below:

struct Point p1, p2, p3;

A variable declaration with structure declaration.

struct Point {              // Structure Declaration
    int     x;
    int     y;
} p1;                       // Define Structure Variable

The above definition actually tells the C compiler two things:

1. The first one is the structure of a "struct Point", which can be used to declare another structure variable.
2. This statement also declares the variable p1ent.

Since the structure of "struct Point" has been defined, so it can use that to declare additional variables:

struct Point p2, p3;

Use of typedef in structure to shorten the names

We also can use typedef to construct shorter or more meaningful names for structures. The following code shows a new data type name Point, which is synonymous with "struct Point":

typedef struct Point {      // Structure Point Declaration
    int     x;
    int     y;
} Point;                    // Data Type Point

We can now declare "structure variables" of type Point, such as the following:

Point p1, p2, p3;         // Define Structure Variables

Notice how much shorter and neater this is compared to the following:

struct Point p1, p2, p3;  // Define Structure Variables

Since there is hardly any reason to use the "struct Point" form, we could omit Point from the previous declaration and write this:

typedef struct {            // Structure Datatype Declaration
    int     x;
    int     y;
} Point;                    // Data Type Name

Structure in Memory

Consider the following statements:

typedef struct {            // Structure Datatype Declaration
    int     x;
    int     y;
} Point;                    // Datatype Name

Point   p1;                 // Define Structure Variable

When a structure variable, p1, is declared, the definition reserves enough memory spaces to hold all the members of p1 — namely x and y. In this case, there will be 4 bytes for each of the two ints. Figure 9.1 shows how p1, p2, and p3 look in memory.

Figure 9.1: Structure Members in Memory

typedef struct{
   int heightInches;
   int weightPounds;
} PatientData;

typedef struct {           // Structure Declaration
    int     year;
    int     month;
    int     day;
} Date;