Structures (Part 2)

Structures and the assignment operator

• With regular primitive types we have a wide variety of operations available, including assignment, comparisons, arithmetic, etc.
• Most of these operations would NOT make sense on structures. Arithmetic and comparisons, for example:

    struct student s1, s2;
  
    s1 = s1 + s2;		// ILLEGAL!
  			// How would we add two students together, anyways?
  
    if (s1 < s2)		// ILLEGAL.  What would this mean, anyways?
       // yadda yadda
  

• HOWEVER, using the assignment operator on structures IS legal, as long as they are the same type. Example (using previous struct definitions):

    struct student s1, s2;
    struct fraction f1, f2;
  
    s1 = s2;		// LEGAL.  Copies contents of s2 into s1
    f1 = f2;		// LEGAL.  Copies f2 into f1
  

• Note that in the above example, the two assignment statements are equivalent to doing the following:

    strcpy(s1.fName, s2.fName);		// these 4 lines are equivalent to
    strcpy(s1.lName, s2.lName);		//    s1 = s2;
    s1.socSecNumber = s2.socSecNumber;
    s1.gpa = s2.gpa;
  
    f1.num = f2.num;			// these 2 lines are equivalent to
    f1.denom = f2.denom;			//    f1 = f2;
  

  Clearly, direct assignment between entire structures is easier, if a full copy of the whole thing is the desired result!

Passing structures into and out of functions

• Just like a variable of a basic type, a structure can be passed into functions, and a structure can be returned from a function.
• To use structures in functions, use struct structname as the parameter type, or as a return type, on a function declaration
• Examples (assuming struct definition examples from previous page):

    // function that passes a structure variable as a parameter
    void PrintStudent(struct student s);	
  
    // function that passes in structure variables and returns a struct
    struct fraction Add(struct fraction f1, struct fraction f2);
  

• structfunc1.c -- Here's an example using a function that takes a structure as a parameter
• To simplify the declarations, this is where typedef statements can come in handy. Use typedef to create single official typenames for structures. One of the above examples, simplified with a typedef:

   typedef struct fraction
   {   int num;
       int denom;
   } Fraction;		// typename is Fraction
  
   Fraction Add(Fraction f1, Fraction f2);	// prototype of function
  

• structfunc2.c -- This is the same as structfunc1.c, but with a typedef used to simplify the declarations

Pass by value vs. Pass by address

• Just like with regular varaibles, structures can be passed by value or by address.
• If just a plain structure variable is passed, as in the above examples, it's pass by value. A copy of the structure is made
• To pass by address, use pointers to structures as the parameters and/or return
• Examples (using the previously seen structure definitions):

    // function that passes a pointer-to-student-structure as a parameter
    void GetStudentData(struct student* s);	
  
    // function that passes in structure pointers and returns a struct
    struct fraction Add(struct fraction* f1, struct fraction* f2);
  
    // function that uses const on a structure pointer parameter
    void PrintStudent(const struct student* s);
  

• As with pointers to the regular built-in types, you can use const to ensure a function cannot change the target of a pointer
• It's often a GOOD idea to pass structures to and from functions by address
  • structures are compound data, usually larger than plain atomic variables
  • Pass-by-value means copying a structure. NOT copying is desirable for efficiency, especially if the structure is very large
• students.c -- an example of structures passed by address into functions
• frac.c -- Example of fraction structure, along with some functions