1 6.1 Basics of Structures 6.2 Structures and Functions 6.3 Arrays of Structures 6.4 Pointers to Structures 6.5 Self-referential Structures + malloc +

1

6.1 Basics of Structures

6.2 Structures and Functions

6.3 Arrays of Structures

6.4 Pointers to Structures

6.5 Self-referential Structures + malloc + linked list

(6.6 Table Lookup –– not treated in this course)

6.7 Typedef

6.8 Unions

6.9 Bit-fields

Chap. 6 Structures + malloc + linked list

Imperative and System Programming, B. Hirsbrunner, diuf.unifr.ch/pai/ip, Lecture 7 – 7 November 2012KR6 + malloc + linked list: ~90’; Exercises: ~90’

2

6.1 Basics of Structures: definition and examples

Definition

A structure is a collection of one or more variables, possibly of different types.

Examples of type declarations

(no memory allocation)

struct {int x; int y};

struct point {int x; int y;};

– ‘point' is an optional structure tag

Examples of variables definitions

(with memory allocation)

struct {int x; int y} p;

struct point {int x; int y} p1;

struct point p2;

Examples of variables definitions with initialization

struct {int x; int y} p = {5, 5};

struct point {int x; int y} p1 = {0,1};

struct point p2 = {1,2};

3

6.1 Basics of Structures: more definitions and examples

Definitions

1. The variables named in a structure are called members.

2. A struct declaration 'struct {…};' defines a type

i.e. 'struct {…} x;' is syntactically analogous to 'int x;'

More examples of variable declarations/definitions with initialization

1. struct rectangle { struct point p1; struct point p2} r = {{0,1}, {1,2}} ;

// nested structures with initialization

1. struct point f(…); // a function returning a value of type 'struct point'

1. { // local 'struct point' variable definitions with initialization

struct point p1 = {0,1}, p2 = f(…); // assuming that f(…) returns a value of type struct point

}

4

6.1 Basics of Structures: name overloading

Name OverloadingFollowing objects can have the same name without conflicting, since they can

always be distinguished by context:- structure tag - structure member variable- ordinary (i.e. non-member) variable

Example (overloading should be used very carefully)

struct x {int x;}; // declaraton of type 'struct x', with a member x

struct x x = {1}; // declaration of variable x of type 'struct x',

// with member x initialized to 1

Usage: printf("%d", x.x);

5

6.1 Basics of Structures: structure member operator '.'

Definition

A member of a particular structure is referred as follows: structure_name.member

Examples of expressions with the structure member operator '.'

p.x

r.pt1.x

Memory Diagrams

6

6.2 Structures and Functions

Legal Operations

- assignment

- passing arguments to functions and returning values from functions

- taking its address with &

- accessing its members with . or –>

- initialization by a list of constant member values

Parameter Passing to Functions

- pass components separately, eventually pass their addresses

- pass an entire structure, eventually its address

Remark

Structure parameter are passed by value like any others

7

6.2 Structures and Functions : example 1

#define min(a, b) ((a) < (b) ? (a) : (b))

#define max(a, b) ((a) > (b) ? (a) : (b))

/* canonrect: canonicalize coordinates of rectangle */

struct rect canonrect(struct rect r)

{

struct rect temp;

temp.p1.x = min(r.p1.x, r.p2.x);

temp.p1.y = min(r.p1.y, r.p2.y);

temp.p2.x = max(r.p1.x, r.p2.x);

temp.p2.y = max(r.p1.y, r.p2.y);

return temp;

}

8

6.2 Structures and Functions : example 2

struct rect canonrect(struct rect *rp)

{

struct rect temp;

temp.p1.x = min((*rp).p1.x, (*rp).p2.x);

temp.p1.y = min((*rp).p1.y, (*rp).p2.y);

temp.p2.x = max( rp->p1.x, rp->p2.x);

temp.p2.y = max( rp->p1.y, rp->p2.y);

return temp;

}

Remark. Alternative notation for pointer p to a structure:

p –> member-of-structure

9

6.2 Structures and Functions : . and –>

Both . and -> associate from left to right, so if we have

struct rect r, *rp = &r;

then these six expressions are equivalent:

r.p1.x

(r.p1).x

(*rp).p1.x

((*rp).p1).x

rp->p1.x

(rp->p1).x

Remark. The structure operators . and ->, together with () for function calls and [] for subscripts, are at the top of the precedence hierarchy and thus bind very tightly.

10

6.3 Arrays of Structures: example + size of

struct key {

char *word;

int count;

} keytab[NKEYS] = {{"auto",0}, ...};

sizeof (unary operator used to calculate the amount of space any data-element / data-types occupies in memory, in number of bytes) :

sizeof variable or expression // can also be specified with parentheses

()sizeof (type-name) // parentheses () are mandatory

- declares a structure type 'struct key', - defines an array 'keytab[NKEYS]' this type, and - sets aside storage for them

Example#define NKEYS (sizeof keytab / sizeof(struct key))

11

6.4 Pointers to Structures6.5 Self-referential Structures: declarations and definitions

struct node_t {int data; struct node_t *next};

struct node_t node = {1, &node};

struct node_t n2 = {2, NULL}, n1 = {1, &n2};

struct s {char data; struct t *sp} S;

struct t {int data; struct s *tp} T;

T.tp = &S; S.sp = &T;

12

malloc, realloc, free

#include <stdlib.h>

void *malloc(size_t size);

void *realloc(void *ptr, size_t size)

void free(void *ptr);

malloc: allocates a memory of size bytes, and returns a pointer to the first element (a NULL pointer if the memory couldn't be allocated)

Exampleint *ptr;

ptr = malloc(sizeof(int));

ptr = realloc(ptr, sizeof(int));

free(ptr);

realloc: changes the size of the object pointed to by ptr to size. The content will be unchanged up to the minimum of the old and new sizes. It returns a pointer with the same meaning as the one returned by malloc.

free: deallocates the memory pointed by ptr, and previously allocated by malloc or realloc

13

6.5 Self-referential Structures: push/pop example

(1) struct node_t { int data; struct node_t *previous;}; // node type of a stack

(2) struct node_t *stack_ptr = NULL; // 'stack_ptr' variable points to the top node;

// shared variable used by push(), pop()

14

6.5 Self-referential Structures: push/pop example(3) void push(int data) {(4) struct node_t *ptr;(5) ptr = (struct node_t *) malloc(sizeof(struct node_t)); (6) ptr->data = data; (7) ptr->previous = stack_ptr;(8) stack_ptr = ptr;(9) }

15

6.5 Self-referential Structures: push/pop example

(10) int pop(void) {

(11) int data = stack_ptr->data;

(12) struct node_t *ptr = stack_ptr;

(13) stack_ptr = stack_ptr->previous;

(14) free(ptr);

(15) return data;

(16) }

ExerciseDraw the memory diagrams before, during and after pop();

16

6.7 Typedef

Examples of declarations

typedef int length_t; // types int (old) and length_t (new) are synonyms

typedef char *string_t; // string_t is a new type, synonym to type char *

Examples of usage

string_t str, a[], f(string_t);

A more complicated example of declarations (about recursion !)typedef struct node_t *stack_t;

typedef struct node_t {int data; stack_t prev} node_t;

Name overloading

'typedef struct x {int x} x;' is ok, but not recommended

creates two new type keywords called node_t (a structure) and stack_t (a pointer to the structure)

17

6.8 Unions

Example of a declaration (similar syntax as structures)union u_tag { int i; float x; char c;} u = 1; // only the first member can be initialized

struct { char *data; union {int i; float r;} u;} tab[MAX];

Definition: a union is a variable that may hold (at different times) objects of different types and sizes

Remarks1. The variable u will be large enough to hold the largest of its members.

2. Members of a union are accessed just as for structures, with the '.' or '->' operators

3. It is the programmer's responsibility to keep track what type of value is currently stored in a union.

4. Unions may occur within structures and arrays, and vice versa, e.g.:

18

6.9 Bit-fields

Definition: a bit-field is a set of adjacent bits within a word (often 32-bits).

Example of a bit-field variable 'flags' definition

struct {unsigned int is_extern : 1;

unsigned int is_static : 1; } flags;

defines a variable flags that contains two 1-bit fields (the number following the colon represents the field width in bits).

Syntax and access: based on structures.

Assignment examples

flags.is_extern = 1 // turn bit on

flags.is_static = 0 // turn bit off

19

6.9 Bit-fields : virtual address example

'Virtual address' is a very important bit-field structure in all modern operating systems

typedef struct {

unsigned Offset :16;

unsigned Page : 8;

unsigned Segment : 6;

unsigned UNUSED : 1;

unsigned Supervisor: 1;

} virtual_address;

typedef struct {

unsigned Supervisor: 1;

unsigned UNUSED : 1;

unsigned Segment : 6;

unsigned Page : 8;

unsigned Offset :16;

} virtual_address;

big-endian computer(packs bit-fields left to right)

little-endian computer(packs bit-fields right to left)

S Segment Page Offset

1 1 6 8 16