• Home
• Syllabus
• Schedule
• Connect
• Checkin
• Homework
  • HW0
  • HW1
  • HW2
  • HW3
  • HW4
• Piazza
• Slides
• Other Info

See this page as a slide show

User Defined Datatypes

CS157 Struct1

User Defined Datatypes

• C has several mechanisms for creating data types other than the basic ones (int, float, etc.) provided by the language.
  • struct — a collection of named variables
  • union — a type that can hold one of a set of variables
  • enum — a set of named integers
  • typedef — define a name for a user type
• These tools are especially useful when combined with pointers and dynamic memory allocation.

Structs

// Declare a person struct
struct person {
    char name[50];
    int age;
    char phone[15];
    float height;
};

• A struct is a user-defined type that specifies a collection of named variables of different data types.
• List of variables, can be of different data types
• Must have { }, and end with ;
• Usually declare structs in global scope, often in a separate file.
  • Global — at top of program, not inside a function
  • It’s a type, so it’s not a global variable.

Structs

Each field has its own memory location.

// Declare a person struct
struct person {
    char name[50];
    int age;
    char phone[15];
    float height;
};

Structs

// Declare a person struct
struct person {
    char name[50];
    int age;
    char phone[15];
    float height;
};

• Declaration of a variable using a struct
  • Must use the struct keyword:
    struct structName variableName;

struct person fritz;
struct person wim, darryl;
struct person teachers[20];

Structs

• A field is an individual variable in the struct. It is accessed by var.field where var is the struct variable and field is the field name.

// Declare a person struct
struct person {
    char name[50];
    int age;
    char phone[15];
    float height;
};

struct person liz;
liz.age = 13;
strcpy(liz.name, "Lizzie");

Work with variables the same way as regular variables of a particular data type.

Structs: Example

struct person {
    char name[50];
    int age;
    float height;
};

int main() {
    struct person who;
    strcpy(who.name, "George W. Shrub");
    who.age = 103;
    who.height = 4.5;
    printf("%s is %d years old\n",
        who.name, who.age);
    return 0;
}

Struct

Various ways to create a structure

// Defining both a new data type and variables:
struct Date {
    int month, day;
} birth, current;
struct Date superbowl;
birth.month = 11;

// Defining a new data type:
struct Date {
    int month, day;
};
struct Date now;
now.month = 5;

// Defining variables, but no type:
struct {
    int month, day;
} birth, current;
// Cannot make any new variables!
birth.month = 11;

Struct

Initializer list (order is important!)

#include <stdio.h>

struct Date {
   int month, day, year;    // Crazy American order
};

int main() {
   struct Date dad = {8, 1, 1922};
   printf("Happy birthday, Dad: %02d/%02d/%d\n",
          dad.month, dad.day, dad.year);
   return 0;
}

Happy birthday, Dad: 08/01/1922

Structures

Passing to functions

Struct

We can send structures to functions

#include <stdio.h>
struct Date {
   int month, day;
};

void modify(struct Date val) {
   val.month = 1;
   val.day = 28;
}

int main() {
   struct Date birth = {7, 4};
   printf("Before: %02d/%02d\n", birth.month, birth.day);
   modify(birth);
   printf("After:  %02d/%02d\n", birth.month, birth.day);
   return 0;
}

Before: 07/04
After:  07/04

Struct — Version 2

We can refer to globally defined structures

#include <stdio.h>
struct Date {
   int month, day;
} birth = {7, 4};

void modify() {
   birth.month = 1;
   birth.day = 28;
}

int main() {
   printf("Before: %02d/%02d\n", birth.month, birth.day);
   modify();
   printf("After:  %02d/%02d\n", birth.month, birth.day);
   return 0;
}

Before: 07/04
After:  01/28

Struct — Version 3

We can send a pointer to the structure

#include <stdio.h>
struct Date {
   int month, day;
};

void modify(struct Date *p) {
   p->month = 1;
   p->day = 28;
}

int main() {
   struct Date birth = {7, 4};
   printf("Before: %02d/%02d\n", birth.month, birth.day);
   modify(&birth);
   printf("After:  %02d/%02d\n", birth.month, birth.day);
   return 0;
}

Before: 07/04
After:  01/28

Structures

Arrays

Arrays of Structs

We can create arrays of structs just like any other type.

int main() {
  struct person people[3];
  strcpy(people[0].name, "Jack");
  people[0].height = 5.5
  strcpy(people[2].name, "Pierre");
  people[2].age = 54;
  ...etc...
}

Struct array

#include <stdio.h>
#include <string.h>
struct student { 
  char   name[50];
  int    age;
};
#define NUM_STUDENTS 3
int main() {
    struct student cs157[NUM_STUDENTS] = {
        {"Bob", 84}, {"Rob", 14}, {"Zob", 4},
    };
    for (int i=0; i<NUM_STUDENTS; i++)
        printf("Student %d: %s %d years old\n", 
                i+1, cs157[i].name, cs157[i].age);
   return 0;
}

Student 1: Bob 84 years old
Student 2: Rob 14 years old
Student 3: Zob 4 years old

Why use structs?

• The last example is one of the main reasons. Rather than having four arrays of items, we have one array of structs.
• When combined with dynamic memory allocation, we can create many different data structures (trees, lists, heaps, etc.).
• Structs help to keep code organized logically.

Unions

Unions

• A union is a type that allows several variables to be stored in the same memory location (but not at the same time), much like a parking spot can fit any type of truck, car, or motorcycle, but only one at a time.
• It provides a way of improving memory efficiency.
• On most modern desktop machines, this is not really an issue, and unions will be used less frequently.

Unions

// Declare a union
union int_or_float {      // tag name
    int i;                // one field
    float f;              // another field
};

• The declaration is similar to that of a struct, but the implementation is different.
• Only one field will contain data and be accessible at any given time.

Unions

// Declare a union
union int_or_float {      // tag name
    int i;                // one field
    float f;              // another field
};

int main() {
    union int_or_float q;
    q.i = 14;
    q.f = 175.543;
    q.i = q.f;
    return 0;
}

Unions

• Accessing a union member that has not been assigned most recently will produce undefined results.
• Only use unions when you are really concerned about memory use (perhaps when writing code for a tiny embedded device, or storing lots of data).

Enumerated Types

• red, yellow, green
• freshman, sophomore, junior, senior
• male, female
• Grumpy, Sneezy, Sleepy, Doc, Dopey, Happy, Bashful

Enumerated Types

• The enum type allows you to specify a finite set of names to which C will automatically give values.
• These names can be compared, which makes them useful in situations where a variable should only take on values from a small set.

Enum

// Declare a enum
enum traffic_light { // tag name
    red,             // value
    yellow,          // value
    green            // value
};

values

• Values are assigned starting at zero and incrementing by one.
• While enums are comparable with ints, you should avoid treating them as integers.

enum Example

enum traffic_light { // tag name
    red,             // value
    yellow,          // value
    green            // value
};

void decide(enum traffic_light light) {
    switch (light) {
        case green:  puts("go");           break;
        case red:    puts("stop");         break;
        case yellow: puts("go very fast"); break;
    }
}

enum — passing to functions

• enum variables are passed by value, therefore the function does not change the original
• They’re really just a thin veneer around ints, so the rules for passing ints apply.

Types

Tag Names and Declarations

• The syntax for defining structs, unions, and enums is very similar.

type tag {
    ...
} var1, var2, var3, ...;

• The type is either struct, union, or enum.
• The tag is a name for the type.
• It differentiates one struct from another.
• After the declaration a list of variables to create can be given.

User: Guest