Programming in C. Lecture Tiina Niklander. Faculty of Science

Transcription

1 Programming in C Lecture Tiina Niklander Faculty of Science Department of Computer Science

2 Week 2 covers Pointer basics operators and address arithmetics as function argument Precedence and associativity (covered in Lecture 2) Dynamic memory allocation Strings Linked lists Faculty of Science Department of Computer Science

3 Briefly about pointers char *p; /* pointer to a character or string */ int *q; /* pointer to one integer (or array) */ /*Memory allocated only for the pointer! */ 345 : Main memory Memory block char *p = This string is allocated ; int numbers[] = {1, 2, 3, 4, 5; double table[100]; Allocate memory for the array and map the name to address of the array. (No memory allocated for array name! constant pointer only allocates the memory block containing the values!) 678 : pointer p 680 : 915 : pointer q 740 : 830 : Program code function foo1 function foo2 Faculty of Science Department of Computer Science

4 Pointers (and arrays) Array is just a sequence of values with a joint name. int a[15] is sequence of 15 integers. Array name is treated as a pointer, whose value is the address of the first element in the sequence. pa = &a[0] pa = a pointer arithmetic allows operations on array elements *(pa +3) is the same as a[3] pa+3 is the same as &a[3] Faculty of Science Department of Computer Science

5 Pointer arithmetics and operations Remember: NULL p = &c c = *p c = **r p = q address of c value of the address pointed by p - - (two jumps ) allowed when p and q of same type p+i, p-i p is array, i has to be integer with suitable value p-q, p and q pointers of the same array and q<p p < q, p == q *ip++ increments the address by one (*ip)++ increments the value in the address by one Faculty of Science Department of Computer Science

6 Pointer arithmetics p int **p; int *q,*r; 3 i 12 int i; i = **p; q const int *p; q = &i; /* q s new value is i s address int const *p; i = *q+1; i = ++*q; /* i=6*/ const int const *p; i = *q++; /*???? */ r = q; *r = 3; /* i=3 */ char msg [] = It is time ; msg: It is time\0 char *pv = It is time ; It is time\0 void *p; i= *(int*) p; pv Faculty of Science Department of Computer Science

7 Example code int main(int argc, char** argv) { int x=1, y=2, z[10]; int *ip; int *p, q; int *r, *s; ip = &x; y = *ip; /* y = x =1 */ *ip = 0; /* x = 0 */ ip = &z[0]; p is a pointer variable and q is integer variable x y z ip double atof(char * string); Faculty of Science Department of Computer Science Pointers as arguments for functions are very common. (Always used with arrays and needed for call by reference)

8 Memory allocation Explicit memory allocations! malloc static data structures calloc dynamic array realloc change the size of already allocated object free deallocate the memory /* ALWAYS CHECK THE RETURN VALUE!!! */ if (!(k=malloc(sizeof(double)))) error; /* allocation failed, do something else or terminate program */ /* memory allocation succeeded and k is the pointer to the new structure */ Faculty of Science Department of Computer Science

9 Functions: Call by value, call by reference C uses always call by value => function cannot change the value it receives as argument. Call by reference done with pointers!!! void swap(int x, int y) { int apu; apu=x; x=y; y= apu; copies void swap(int *x, int *y) { int apu; apu=*x; *x=*y; *y= apu; Faculty of Science Department of Computer Science x y Addresses of x and y Call: swap (&x, &y); double product (const double block, int size); 3 4 Make sure that function does not change the variable (ANSI standard!)

10 #include <stdio.h> Example code: copy a string - Passing array to a function void copy_string( char *s, char *t) { int i =0; while ( (s[i] = t[i])!= \0 ) i++; Strings (character arrays ending with \0 ) as arguments. C is always passing only the address of the first element of any array. int main (void) Processing one character of each array { char here [] = This string is copied., there[50]; copy_string ( here, there); printf( %s\n, there); copy_string ( there, here); printf( %s\n, there); return 0; Faculty of Science Department of Computer Science

11 Example code: copy a string Now with pointers Version 1: Version 2: void copy_string( char *s, char *t) { while ( (*s = *t)!= \0 ) s++; t++; void copy_string( char *s, char *t) { while ( (*s++ = *t++)!= \0 ) ; Version 3: void copy_string( char *s, char *t) { while ( *s++ = *t++ ) ; NOTE: The function prototype is identical with the previous slide Faculty of Science Department of Computer Science Minimalistic!

12 More about pointers and some good practices Generic pointer (void *p) can be used with type cast to handle a variable of that type. *(double *)p Memory allocation for n integers int *p; if ((p=malloc(n*sizeof(int))) == NULL) error; Memory deallocation: remember to free(p); p=null; i th element of array p[i] (preferred over *(p+i) ) Handling an array p for (pi = p; pi < p+size; pi++) remember to use pointer pi in the loop Faculty of Science Department of Computer Science

13 Still more Call by reference 1. Prototype s argument a pointer void func(int *pp) 2. In the function use the pointed value. *pp 3. In the function call: address of the variable func(&variable); 4. In the function call: pointer func(pointer_variable); Array of struct (next slide) for (p = block; p < block + n*elsize; p+= elsize) i. element of struct array p = block + i*elsize Faculty of Science Department of Computer Science

14 Struct struct info { char firstname[20]; char lastname[20]; int age; ; struct info i1, i2; typedef struct InfoT { char firstname[20]; char lastname[20]; int age; InfoT; InfoT p1; Preferable alternative! Access to struct field with. notation struct.field: p1.age = 18; printf("%s\n", i2.firstname); struct info { char firstname[20]; char lastname[20]; int age; k1, k2;

15 Pointer to struct Access to struct field: (*p).x or p->x typedef struct pair { double x; double y; PairT, *PairTP; PairT x; PairTP p; PairT w; PairTP q; PairTP p = &w; if((q = malloc(sizeof(pairt))) == NULL) if((q = malloc(sizeof(struct pair))) == NULL) w.x = 2; p->x = 1; (*p).x = 1; *p.x = 1; q->y = 3.5;

16 Linked lists Faculty of Science Department of Computer Science

17 List (abstract data type) source: Wikipedia Sequential structure Access from the head (or tail) element by element Typical operations Creation Add element To beginning, to middle, to end Remove element From beginning, from middle, from end Locate first element Test for empty, Faculty of Science Department of Computer Science

18 List (abstract data type) List can be used to implement: Queue (FIFO, first-in-first-out) Enqueue to one end Dequeue from the other end Stack (LIFO, last-in-first-out) Push to top Pull from top Faculty of Science Department of Computer Science

19 List (abstract data type) List can be implemented Using array data structure Using linked list data structure Here focus only on the linked list data structure Faculty of Science Department of Computer Science

20 Linked lists List as abstract data structure: covered in data structures and algorithms course Linked list structural decisions: single or double (traversals to one or two directions) Loop or no-loop (= NULL terminated) Header node or not Ordered or not Unique elements or multiple occurrences of same value

21 Linked List - definitions Header, singly linked No loop = NULL to terminate NOTE: definition of the next field! typedef double DataType; typedef struct elem { DataType value; struct elem *next; ElemT, *ElemTP; typedef struct { ElemTP first; ListT, *ListTP; ListTP p; p first ListT value 2 next ElemT value 3.5 next NULL ElemT

22 Linked list with header: Create and delete Create list Just allocate header node and set its field values Delete list Separate function to remove elements Here just free space of header node ListTP construct(void) { ListTP p; if((p = malloc(sizeof(listt))) == NULL) return NULL; p->first = NULL; return p; void destruct(listtp *this) { clear(*this); /* remove list elements */ free(*this); *this = NULL;

23 Linked list with header: Using it All list operations must maintain the following invariants: For empty list, always p->first ==NULL. For non-empty list, always last node s next-field == NULL. p first ListT p NULL first ListT value 2 next ElemT value 3.5 next ElemT NULL

24 Linked list with header: using it p Operations: List traversal first ListT value 2 next ElemT Always (and only) to the link direction Adding to list Beginning, middle, end Removing from the list Beginning, middle, end value 3.5 next ElemT NULL

25 p List traversal first ListT value 2 next ElemT value 3.5 next ElemT aux void printall(const ListTP this) { ElemTP aux; for(aux=this->first; aux!=null; aux=aux->next) printf("%f\n", aux->value); NULL /* Keep aux in previous node */ If ((p->first!= NULL) && (p->first->next!=null)) for(aux = p->first; aux->next!= NULL; aux = aux->next)...

26 Add to beginning of the list p this first ListT int insertfront(listtp this, DataType d) { ElemTP aux; if((aux = malloc(sizeof(elemt))) == NULL) return 0; value 2 next ElemT value 2 next ElemT value 3.5 next ElemT aux NULL aux->next = this->first; /* save state */ aux->value = d; this->first = aux; return 1;

27 Removing last node int deletelast(listtp this, DataType *value) { ElemTP aux; if(this->first == NULL) /* empty list */ return 0; if(this->first->next == NULL) { /* single */ *value = this->first->value; free(this->first); this->first = NULL; return 1; for(aux = this->first; aux->next->next!= NULL; aux = aux->next) ; /* aux points to second last element */ *value = aux->next->value; free(aux->next); aux->next = NULL; return 1; p first ListT value 2 next ElemT value 3.5 next ElemT this aux NULL

28 Deleting/clearing the whole list Free node by node from beginning to end int deletefirst(listtp this) { ElemTP aux = this->first; if(aux == NULL) /* empty list */ return 0; this->first = aux->next; free(aux); return 1; void clear(listtp this) { while(deletefirst(this)) ; this->first = NULL; EXPLICIT MEMORY DEALLOCATION

29 Linked list without separate header node type No ListTP type, so only type is the ElemTP Pointer to list is pointer to the first element So empty list: pointer == NULL List changes Must pass to functions the address to the list pointer, value is not enough Faculty of Science Department of Computer Science

30 Example: ModuleList (doubly-linked list with header) Own module (list.h and list.c) that can be compiled separately, contains type definitions and functions This module can - Handle multiple separate lists - Data handled by void pointer, so different lists can contain different types of data - Hide the actual implementation details of the list Type definitions: ListItem and List Functions: CreateList, CreateItem, AddTail, AddHead, ListLength, DeleteList, PrintStringList, EmptyList Source: Jan Lindström s (Finnish) lecture material,2000

31 Interface definitions: list.h #ifndef MY_LIST_LIBRARY #define MY_LIST_LIBRARY /* Type definitions*/ typedef struct listitem { struct listitem *Next; /* Pointer to next element */ struct listitem *Prev; /* pointer to previous elem */ void *Data; /* Pointer to data */ unsigned long Size; /* Size of data */ ListItem; typedef struct { /* header node of the list */ ListItem *Head; ListItem *Tail; unsigned long Items; /* number of elements */ List;

32 List.h continues /* Function signatures / interface definitions*/ extern List *CreateList(void); /* Create new list */ extern ListItem *CreateItem(void *Data, unsigned long Size); /* Create new element*/ extern int AddTail(List *,ListItem *); /*Add to end*/ extern int AddHead(List *,ListItem *); /* Add to beginning */ extern unsigned long ListLength(List *); /* Count lenght */ extern void DeleteList(List *); /* Destroy list */ extern void PrintStringList(List *); /* Print the list content, assume strings */ extern int EmptyList(List *); /* Check if list is empty */ #endif

33 List.c : CreateList /* Reserve memory area for the new list and set the fields */ List *CreateList(void) { List *new; if(!(new = (List *)malloc(sizeof(list)))) return NULL; new->head = NULL; new->tail = NULL; new->items = 0; return new;

34 List.c: CreateItem /* Allocate memory for new node and set fields*/ ListItem *CreateItem(void *Data,unsigned long size) { ListItem *uusi; /* If no data, exit and do not create a node*/ if (Data == NULL) return NULL; if(!(uusi = (ListItem *)malloc(sizeof(listitem)))) return NULL; if(!(uusi->data = (void *)malloc(size))) return NULL; uusi->next = NULL; uusi->prev = NULL; memcpy(uusi->data,data,size); uusi->size = size; return uusi;

35 List.c: AddTail /* Add to the end of the list*/ extern int AddTail(List *lista,listitem *item) { if (lista == NULL item == NULL ) return 1; if ( lista->head == NULL) lista->head = lista->tail = item; else { lista->tail->next = item; item->prev = lista->tail; lista->tail = item; lista->items++; return 0;

36 List.c: AddHead /* Add to the head of the list*/ extern int AddHead(List *lista,listitem *item) { if (lista == NULL item == NULL ) return 1; if ( lista->head == NULL) lista->head = lista->tail = item; else { lista->head->prev = item; item->next = lista->head; lista->head = item; lista->items++; return 0;

37 List.c: ListLength ja EmptyList /* Count' list length */ unsigned long ListLength(List *lista) { if ( lista == NULL ) return 0; else return lista->items; /* Check if list is empty */ int EmptyList(List *lista) { if ( lista == NULL) return 1; else if (lista->head == NULL ) return 1; else

38 List.c:DeleteList /* Destroy the whole list*/ void DeleteList(List *lista) { ListItem *tmp; if ( lista == NULL ) return; tmp = lista->head; while(tmp!= NULL) { tmp = lista->head->next; free(lista->head->data); free(lista->head); lista->head = tmp; free(lista);

39 List.c: PrintStringList /* Print the whole list */ void PrintStringList(List *lista) { ListItem *tmp = lista->head; printf(" "); while(tmp!= NULL) { printf("%s ",(char *)tmp->data); tmp = tmp->next; printf(" -\n"); Here assumes that list contains strings. More generic solutions would be to use function parameter to handle data. Caller would then provide function to handle data elements and the print function would be more general.