Struct Data Type | Research & Encyclopedia Articles

Struct Data Type

The "struct" data type is specific to the C and C++ programming languages. The original data type came from C and then was subsumed into C++. While the C++ version retains the original semantics and syntax of the original, it has been extended to make C++ structs bona-fide objects in their own right.

Structures contain a set of contiguously allocated member variables that can be of any type, including other structures. In C++ structures may have member functions, too. C++ structures are identical to C++ classes except that the access rights to a structure's functions and data members are public rather than private unless the programmer says otherwise. The reason for this is that the conceptual difference is that a structure is a collection of related data elements whereas a class is a tightly bound cohesive unit or object.

The struct keyword is short for "structure" and is followed by one or more variable declarations within a set of braces (the "{" and "}" characters respectively). A typical C structure declaration is shown in the code fragment below:

• struct roadVehicle {
• int engineSize;
• int wheelCount;
• int seatCount;
• };

This fragment declares a structure that might represent a road vehicle. Once it has been declared, it can then be used as a type blueprint from which the programmer can create roadVehicle objects. For example the code below declares two unique and separate variables:

• struct roadVehicle car;
• struct roadVehicle truck;

The syntax is a little cumbersome, so C has the "typedef" keyword that associates a simple identifier with a complex declaration. So if the structure had been declared as

• typedef struct {
• int engineSize;
• int wheelCount;
• int seatCount;
• } roadVehicle;

it would be possible to write

• roadVehicle car;
• roadVehicle truck;

In C++ the typedef keyword is not needed here although it is supported for backwards compatibility with C; in other words it would have been possible to have the struct declared like this

• struct roadVehicle {
• int engineSize;
• int wheelCount;
• int seatCount;
• };

and then to write

• roadVehicle car;
• roadVehicle truck;

The method used to access a structure's members in both C and C++ depends on whether the structure is being accessed by value (as an object), or via a pointer. In C++ it is also possible to access a structure's members by reference, in which cases the syntax is the same as for access by value.

For example:

• roadVehicle car;
• roadVehicle truck;
• roadVehicle van;
• roadVehicle* carPtr = car
• roadVehicle& vanRef = van; // C++ only

To assign a value to the number of wheels of each vehicle the code could look like this:

• vanRef.wheelCount = 3; // must have hit a drain
• carPtrengineSize = 400;
• truck.seatCount = 2;

The only type of variable a structure cannot contain is its own type, so the following declaration is illegal:

• struct roadVehicle {
• roadVehicle vehicle;
• int engineSize;
• int wheelCount;
• int seatCount;
• };

However, it can contain a "pointer" to its own type like this:

• struct roadVehicle {
• roadVehicle* next;
• int engineSize;
• int wheelCount;
• int seatCount;
• };

Why this is useful is not perhaps immediately apparent, but on closer examination it can be seen that "next" can point to another roadVehicle, which can point to another roadVehicle, . . . and so on. Thus the structure is the basic element of linked lists in C.

A special kind of structure is a "union." A union is a set of overlaid structures that all begin at the same address. A union is really only of any use as "containers" of structures that can have more than one "view" of them. For example, a programmer may wish to store a set of integers or characters in a structure of a single type:

• typedef struct {
• int a;
• int b;
• } integers;
•  
• typedef struct {
• char a;
• char b;
• } characters;
•  
• typedef union {
• integers i;
• characters c;
• } values;

What this union does is give two "views" of integer values. If the programmer accesses an object of type "values" via an "integer" structure, he will get integer values out; if he access it via a "character" structure, he will get char values out.

Structures provide an extremely powerful way of building very complex data types in C and it is almost impossible to create a program of any real utility without them. Their use in C++ has been somewhat attenuated by the class declaration, but they still have their place where a full class would be considered overkill.