C Programming: Structures

• Structures are new data types that combine different types into a single, compound data type.
• Struct definitions are analogous to templates or blueprints and composed of members of previously defined types.
• Structures must be defined before they are used.
• C has three different methods to define a structure: variable structures, tagged structures, and type-defined structures.

Struct Variable

• A variable structure definition defines a struct variable.
• An example is struct { double x; double y; } point; where x and y are member names and point is the variable name.
• Keep in mind the semicolon at the end of the definition.

Tagged Structure

• A tagged structure definition defines a type which can be used to define variables, parameters, and return types.
• For example: struct point_t { double x; double y; }; The point_t is the structure tag.
• Variable definitions using the tag looks like this: struct point_t point1, point2, point3;
• point1, point2, and point3 all have members x and y.

Typedef Structure

• A type-defined structure allows the definition of variables without the struct keyword, where tagged are used to define varaibles, parameters, and return types.
• A structure looks like this: typedef struct { long ssn; int empType; float salary; } employee_t; where employee_t is new type name.
• A variable definition looks like this: employee_t emp;
• Variable emp has members ssn, empType, and salary.

Dot Operator

• The dot operator is used to access member variables with a syntax of structure_variable_name.member_name.
• Accessed variables act like other variables.
• Given struct point_t { double x; double y; };, you can access the variables like this:

void setPoints() {
  struct point_t point1, point2;
  point1.x = 7;  // initialize point1 members
  point1.y = 11;
  point2 = point1;  // copy point1 to point2
}

Arrow Operator

• The arrow operator is used to access member variables using a pointer.
• The arrow operator syntax is structure_variable_pointer->member_name.
• The dot operator syntax can also be used like this: (*structure_variable_pointer).member_name
• Given typedef struct { long ssn; int empType; float salary; } employee_t; the following code initializes the variables:

employee_t *newEmp (long n, int type, float sal) {
  employee_t *empPtr = malloc(sizeof(employee_t));
  empPtr->ssn = n;  // -> operator
  empPtr->empType = type;  // -> operator
  (*empPtr).salary = sal;  // dot operator
  return empPtr;
}

Nested Structures

• A member that is of a structure type is considered nested.
• Example:

typedef struct {
  int month;
  int day;
  int year;
} date_t;

typedef struct {
  double height;
  int weight;
  date_t birthday;
} personInfo_t;

• personInfo_t person; defines a variable of type personInfo_t.
• person.birthday is a member of person, and person.birthday.year is a member of person.birthday.

Initializing Structures

• Structures may be initialized at the time they are declared.
• Order is essential; the sequence of values initializes successive variables in the struct.
• It is an error to pass more initializers than members.
• If fewer initializers than members are provided, the initializers provided are used to initialize the data members; the remainder are initialized to 0 for primitive types.
• Given this structure:

typedef struct {
  int month;
  int day;
  int year;
} date_t;

• It can be initialized like this: date_t due_date = {12, 31, 2020};

Dynamic Allocation of Structures

• The sizeof() operator should always be used in dynamic allocation of storage for structured data types, as well as reading and writing structured data types.
• Example:

typedef struct {
  int month;
  int day;
  int year;
} date_t;
date_t due_date;

int date_t_len = sizeof(date_t);  // sizeof type
int due_date_len = sizeof(due_date);  // sizeof variable

printf("sizeof(date_t)=%d\n", date_t_len);
printf("sizeof(due_date)=%d\n", due_date_len);

date_t *due_dates = calloc(100, sizeof(date_t));

• The sizeof(date_t) and sizeof(due_date) both equal 12.

Arrays within Structures

• A member of a structure may be an array.
• Example:

typedef struct {
  long ssn;  // SSN
  double payRate;  // Hourly rate
  float hoursWorked[7];  // Daily hours worked Sun-Sat
} timeCard_t;

timeCard_t empTime;
empTime.hoursWorked[5] = 6.5;  // Thur hours worked

Arrays of Structures

• An array of structure types can be created.
• Example:

typedef struct {
  // unsigned char will hold 0-255
  unsigned char red;
  unsigned char green;
  unsigned char blue;
} pixel_t;

pixel_t pixelMap[800][600];

pixelMap[425][37].red = 127;
pixelMap[425][37].green = 0;
pixelMap[425][37].blue = 58;

Array of Structures Containing Arrays

• Arrays of structures can contain arrays

typedef struct {
  long ssn;            // SSN
  double payRate;      // Hourly rate
  float hoursWorked[7];  // Daily hours worked Sun-Sat
} timeCard_t;
timeCard_t empTime[1000];
// Thur hours worked, emp # 10
empTime[9].hoursWorked[5] = 6.5;

Structures as Parameters

• A struct, like an int, may be passed to a function.
• The process of passing a struct to a function works like passing an int: the complete structure is copied to the stack, and the called function is unable to modify the caller's copy of the variable.
• Example:

typedef struct {
  double x;  // x coordinate
  double y;  // y coordinate
} point_t;

void changePoint(point_t p) {
  printf("x=%.1lf, y=%.11f\n", p.x, p.y);  // x=1.2, y=2.3
  // p.x = 3.4;
  // p.y = 4.5;
}

void mainPoint() {
  point_t point = {1.2, 2.3};
  changePoint(point);
  printf("x=%.1lf, y=%.1lf\n", point.x, point.y);  // x=1.2, y=2.3
}

• A disadvantage of passing structures this way is it's inefficient, potentially causing stack overflow, when copying large structures onto the stack.
• This is especially true for structures like this example which contains 1 billion integers:

typedef struct {
  int w[1000 * 1000 * 1000];  // One billion int elements
} big_t;

Structure Pointers as Parameters

• Passing structure pointers is more effective as passing an address only pushes a single word on the stack.
• The called function can then modify the structure.
• Example:

typedef struct {
  double x;  // x coordinate
  double y;  // y coordinate
} point_t;

void changePoint(point_t *p) {
  printf("x=%.1lf, y=%.1lf\n", p->x, p->y);  // x=1.2, y=2.3
  // p->x = 3.4;
  // p->y = 4.5;
}

void mainPoint() {
  point_t point = {1.2, 2.3};
  changePoint(&point);
  printf("x=%.1lf, y=%.1lf\n", point.x, point.y);  // x=3.4, y=4.5
}

Const Struct Parameter

• If you do not want the recipient to modify the structure, use the const modifier: (const point_t * p)

Return Structure

• Scalar values (int, float, etc.) are efficiently returned in CPU registers.
• Historically, structure assignments and the return of structures were not supported in C.
• The return of pointers (addresses), including pointers to structures, has always been supported.

Return Structure Pointer to Local Variable

• Returning a pointer to a variable that was allocated on the stack during execution of the function is risky.
• Such variables are subject to being wiped out by subsequent function calls.
• It is possible for a function to return a structure, depending on the structure assignment mechanisms that copy one complete structure to another which avoids returning a function.
• This can incur a possible extreme penalty of copying a very large structure

Arrays as Parameters & Return

• An arrays address is passed as a parameter, simulating passing by reference.
• Embedding an array in a structure is the only way to pass an array by value.
• Embedding in a structure is also the only way to return an array.
• Both passing and returning arrays involves copying and must be mindful of size.