Copyright © 2016, 2017
Robert W. Hasker

Note 14: Structs

Structures

• Arrays: collection of items where the type of each element is the same.
• Structures: collection of different types of elements
• C++: generally use classes, but not available in C
• C solution: struct
  • See points0.c
  • All fields public - there is no public/private/protected in C
  • No constructors, no member functions, no inheritance
    • Can have these (including inheritance) in C++!
    • struct in C++: class with all public fields
• Problem: using struct in declarations gets repetitive; better, use typedef: points.c
• Example:
  • Student has name, id, term_hours, cum_hours, term_gpa, cum_gpa

    	typedef struct
    	{
    	   char name[NAME_LEN];
    	   int  id;
    	   int  term_hours, cum_hours;
    	   int  term_gp,    cum_gp;
    	} Student;
    
    	Student grace;
    
    
            strcpy(grace.name, "Grace Hopper");
            grace.id         = 101;
            grace.term_hours = 14; ...
    

    Assuming "..." is the right code, get

    grace
    name: Grace Hopper id: 101 term_hours: 14 cum_hours: 110 term_gp: 49.2 cum_gp: 385.0

• As a pointer:

          Student *new = malloc(sizeof(Student));
          new->term_gp = new->cum_gp = 0.0;
          strcpy(new->name, "Help?");
  

Structures as Parameters

• by default, passed by value
• In C++: use & to pass by reference
• Example: print cumulative gpa
  • cumulative gpa = cumulative gp / cumulative hours

  	void print_gpa(Student stu)
  	{
  	   printf("%.4g", stu.cum_gp / stu.cum_hours);
  	}
  

• calling:

          print_gpa(grace);
          print_gpa(*new);
  

• problem: overhead in copying just to print gpa; better:

  	void print_gpa(const Student *stu)
  	{
  	   printf("%.4g", stu->cum_gp / stu->cum_hours);
  	}
  

• So now the calls are

          print_gpa(&grace);
          print_gpa(new);
  

Combining Structures

• Example:

  	typedef struct
  	{
  	   int x, y;
  	} Point;
  
  	typedef struct
  	{
  	   Point a, b;
  	} Line;
  

• Array of structures:

  	Line image[MAXLINES];
  

  • [draw picture of image as stored in memory]
• Accessing the x coordinate of the a point on the 10th line:

  	printf("%d", image[9].a.x);
  

  • In general, work from variable to field; let types tell you what to do.
  • image is an array, so we must index it.
  • image[9] is a structure, so we must use dot to access the a field.
  • image[9].a is also a structure, so must again use dot to access x.
• Example of using this array: drawing an entire image:

  	void DrawImage(const Line image[], int numLines)
  	{
  	   for(int i = 0; i < numLines; i++)
             {
  	      MoveTo(image[i].a.x, image[i].a.y);
                LineTo(image[i].b.x, image[i].b.y);
             }
  	}
  

• Examples:
  • Find all items with one of the x coordinates equal to 0.
  • Draw all lines with positive slopes.

Unions

• Variables are allows to store different types values:

          union Message 
          {
             char  text[1000];
             float xs[200];
          } msg;
          strcpy(msg.text, "Hello, World");
          msg.xs[0] = 3243.5234e12; msg.xs[1] = -1e5;
          printf("%s", msg.text);
  

  • prints "z_8Y" for some combinations of g++/Linux
• More useful: add flag indicating type of data:

          struct Message
          {
             enum { TEXT, DATA } message_type;
             union MessageContents
             {
                char  text[1000];
                float xs[200];
             } contents;
          } msg;
  
  
          ...
          if ( msg.message_type == TEXT )
             display(msg.contents.text);
          else
             print_table(msg.contents.xs);
  

Type Equivalence

• typedef: simply an alias for a type:

          typedef long my_type;
          long a = 5;
          my_type b = a;          // ok!
  

  • Two types are not different just because of a difference in alias
  • Means you cannot use this to check units:

            typedef meters double;
            typedef kilograms double;
            meters m;
            ...
            kilograms k = m;        // legal
    

• Structures: name equivalence

          struct Stack {
             int data[100];
             int count;
          };
  
          struct Set {
             int data[100];
             int count;
          };
  
          ...
          struct Stack a, b;
          ...
          a = b;          // ok!
          ...
          struct Set x;
          x = a;          // illegal!
  

  • Typedefs don't change this:

            typdef struct {
               int data[100];
               int count;
            } Stack100;
    

    creates an anonymous struct that's distinct from Set, Stack.

Review

• structures, nested structures, arrays of structures
• key: draw pictures
• string.h
• unions
• type equivalence
• Next: parameter passing, memory management