Programming in C. Week Tiina Niklander. Faculty of Science

Size: px

Start display at page:

Download "Programming in C. Week Tiina Niklander. Faculty of Science"

Godfrey Chandler
5 years ago
Views:

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

2 Meeting structure First week Some notes Second week Focus on pointers Slides related to first week topics covered if time allows or some questions arise Faculty of Science Department of Computer Science

3 First week tasks TMC problems Difficulties configuring NetBeans properly Submission failed occasionally, Some tasks did not succeed locally, but were correct on the server Tasks Uninitialized values: test failure information not useful Printf: formatting problems, especially \n Faculty of Science Department of Computer Science

4 Feedback Math.h use the functions for mathematical tasks -> less errors ceil andfabs should have been used in 1.2 various sums Study the material, not just trial-and-error from book, man pages Printf and scanf see next slide Faculty of Science Department of Computer Science

5 /* Program that reads two integer values, and * outputs the maximum of these values. */ #include <stdio.h> int main() { int i, j; printf("enter two integers:"); if(scanf("%d%d", &i, &j)!= 2) { fprintf(stderr, "wrong input\n"); return EXIT_FAILURE; printf("maximum of %d and %d is %d\n", return EXIT_SUCCESS; i, j, i > j? i : j); Read two values Conditional operation

6 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 set the pointer to 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

7 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

8 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

9 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

10 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)

11 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

12 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!)

13 #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

14 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!

15 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

16 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 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

17 Evaluation order Preceedence Arithmetical ops { Bitwise moves { Value comparations { Bitwise comparations and or Conditional op Same line - same priority () []. ->! ~ & * (tyyppi) sizeof * / % + - << >> < <= > >= ==!= & ^ &&?: = *= /= %= += -= <<= >>= &=!= ^=,

18 Assosiativity Expression a < b < c is interpreted as (a < b) < c And the meaning is different than expression a < b && b < c

19 Style: using space Do not use space with the following : ->. []! ~ (sign) *(pointer)& Usually have space around these: = +=?: + < && + (addition) and others a->b a[i] *c a = a + 2; a= b+ 1; a = a+b * 2;

20 Constants Defined as variables, but with addition const Usually constant names in capital letters const float PI = ; const int BIG_NUMBER = 0xFF7D; const int TRUE = 1; const int FALSE = 0; const char LETTER_A = a ; const char [] MJONO = String has parenthesis around it ;

21 Macros Preprocessor control textual replacement! Macro is a text that is replaced with other text before the actual compilation NOTE: Rest of the line is the replacement string as it is!! Can be used to define constants but is more powerful #define MAKSIMI 30 #define NAME Tiina Niklander #define TRUE 1 #define FALSE 0

22 Avoid mistakes u i = 8 different than i == 8 u Remember to set initial values to variables! u Check the limits (avoid off by one ) u These are not logical operations!!! e1 & e2 e1 e2 if(x = 1)

23 Overflow NEVER test overflow with i + j > INT_MAX BUT do: i > INT_MAX - j Source: Müldner

24 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;

25 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;

26 Linked lists List as abstract data structure: covered in data structures and algorithms course Linked list structural decisions: singly or doubly (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

27 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

28 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;

29 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

30 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

31 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)...

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

33 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 NULL

34 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;

35 Example: ModuleList 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

36 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;

37 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

38 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;

39 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;

40 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;

41 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;

42 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

43 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);

44 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.

45 Slides related to first week Faculty of Science Department of Computer Science

46 Simple types Int 28, 074, 0x2A char, one character, actually a numerical value, do not assume anything a \065 \xa6 float, double NOTE: no boolean - Use integer values FALSE and all other values TRUE Size of these not fixed between systems (see: sizeof or limits.h) signed, unsigned unsigned int signed char short, long long char short int Combined signed short int unsigned long int

47 Header file: limits.h #include <limits.h> Limits.h contains the maximum and minimum values of different types in this environment At department the file is in /usr/include/ Always: INT_MAX >= Lots of values: eg. SHRT_MAX (signed short) With ints you can define the type after value (U, L) 12U is unsigned int and 7L long int sizeof(short) <= sizeof(int) <= sizeof(long)

48 Header file: float.h #include <float.h> Contains size and limit values for - float - double - long double sizeof(float) <= sizeof(double) <= sizeof(long double)

49 Type conversion Implicit: operands with different types -> automatic type conversion for the arithmetic operation using the better quality type: int, char unsigned long unsigned long float double long double Explicit: (double)int_var; (int) letter;

50 Statements Conditional Loops if (cond) statement; else statement; If (cond) { statements else{ statements for (;;) statement while (1) { statements do{ statements while (cond); Interrupting a loop Break - continue from the statement AFTER the loop Continue continue with NEXT ROUND Not named!!

51 Using break While (1) { printf( give two numbers a and b, a < b: ); if (scanf( %d%d, &a, &b) == 2) break; if (a < b) break;... /* break continues from here */ Several typical C features - eternal loop while(1) - error checks!! - standard functions

52 Exiting from a deep loop structure Exit over multiple loop levels must be done with goto (Avoid using for anything else!) for(i = 0; i < length; i++) for(j = 0; j < length1; j++) if(f(i, j) == 0) goto done; done: Break would continue the outer loop!

53 switch.. /* Beginning of main and variable definitions */ Printf( Please give at most %d chars\n, LIMIT); For (i = 1; i <= LIMIT; i++) { if ( (c=getchar()) == EOF) break; /* end of file with CTRL-D */ switch (c) { case : space++; break; case \t : tabul++; break; case * : asterisk++; break; default : if (c>= a && c<= z ) lowercaseletters++;... /* continues e.g. with printing */

54 Control Statements This loop while(expr!= 0) statement; Is identical with this one while(expr) statement;

55 while(1) { Read characters until sentinel if((aux = getchar()) == EOF aux == SENTINEL)... or: while(1) { break; if((aux = getchar()) == EOF) break; if(aux == SENTINEL)... break;

56 Read integers while(1) { if (scanf("%d", &i)!= 1 i == SENTINEL) break;

57 Input and output briefly Character at a time int getchar() int putchar(int) Formatted int scanf("format", &var) int printf("format", exp)

58 /* File: ex1.c * Program that reads a single character and * outputs it, followed by end-of-line */ #include <stdio.h> #include <stdlib.h> int main() { NOTE: These header files are needed for the standard functions used int c; /* chars must be read as ints */ if ((c = getchar()) == EOF) return EXIT_FAILURE; putchar(c); putchar('\n'); return EXIT_SUCCESS;

59 Printf & scanf: integer values d signed decimal ld long decimal u unsigned decimal o octal x, X hexadecimal printf("%d%o%x", 17, 18, 19);

60 Printf and scanf: real number, floating point numbers f e default is 6 digits: [-] ddd.ddd [-] d.ddddde{signdd E [-] d.ddddde{signdd g fe (f, e only if needed (e.g. sign <-4)) G FE printf("%5.3f\n", ); printf("%5.3e\n", ); e+02

61 Printf and scanf: chars and string c one character s string printf("%c", 'a'); printf("%d", 'a'); printf("this %s test", "is");

62 scanf() return value scanf() returns as its value the number of read items and EOF, if not item was read before the end-of-file occured For example scanf("%d%d", &i, &j) may return: 2 If both values were read correctly 1 If only i was read 0 If reading failed completely EOF if file ended.

63 scanf scanf ( %c,c); or scanf ( %c, c); What is the difference in behaviour? Why do you use the space in the beginning of the format string? Faculty of Science Department of Computer Science

Programming in C. Lecture Tiina Niklander. Faculty of Science

Programming in C. Lecture Tiina Niklander. Faculty of Science Programming in C Lecture 3 17.9.2018 Tiina Niklander Faculty of Science Department of Computer Science 17.9.2018 1 Week 2 covers Pointer basics operators and address arithmetics as function argument Precedence