IN 147 Program og maskinvare

Transkript

1 Dagens tema Deklarasjon av nye typer Typekonvertering mellom pekere Regning med pekere Pekere til funksjoner Pekere til pekere til... Vanlige feil ved bruk av pekere Feilsøking Debuggere lint Kompilatormeldinger Egne testutskrifter Ark 1 av 28 Forelesning

2 Deklarasjon av nye typer I C kan vi definere nye typer: typedef unsigned char uc; uc c1, ctab[10]; Typedefinisjoner brukes til å unngå lange navn: uc kontra unsigned char punkt kontra struct punkt definisjoner som kan variere fra ett system til et annet; for eksempel i stdlib.h på en SGI: typedef unsigned int size_t; Typen size t brukes som type for en størrelse, for eksempel det sizeof gir. Forelesning Ark 2 av 28

3 Typekonvertering mellom pekere Siden pekere i prinsippet kan være av ulikt antall bit, skal man egentlig angi konvertering mellom dem. (Dette hjelper også kompilatoren å finne feil.) Pekertypen void* er garantert stor nok til alle pekere, og kan derfor betraktes som en «peker til alt mulig». Funksjonen malloc er derfor definert som void *malloc (size_t size) Korrekt bruk av malloc er derfor xxx *p; : p=(xxx*)malloc(sizeof(xxx)); Forelesning Ark 3 av 28

4 Regning med pekere I C gjelder alltid at a[i] *(a+i) Dette er greit om a er en char-vektor, men hva om den er en long? Egne regneregler for pekere I C gjelder egne regneregler for pekere: p+i betyr «Øk p med i multiplisert med størrelsen av det p peker på.» #include <stdio.h> typedef unsigned long ul; int main(void) { char *cp = (char*)0x123400; long *lp = (long*)0x123400; cp++; lp++; printf("cp = 0x%lx\nlp = 0x%lx\n", (ul)cp, (ul)lp); return 0; } gir følgende når det kjøres: cp = 0x lp = 0x Forelesning Ark 4 av 28

5 Pekere til funksjoner Det er nyttig å kunne behandle funksjoner som om de var variable, og noen høynivåspråk tilbyr dette. C tilbyr noe som er nesten like godt: pekere til funksjoner. #include <stdio.h> int sum(int (*f)(int x), int n) { /* Beregn summen av f(x) for x=1,...,n. */ int res = 0, ix; for (ix = 1; ix <= n; ++ix) res += f(ix); } return res; Her er parameteren f en peker til en funksjon: Denne funksjonen returnerer en int. Denne funksjonen har én parameter: n som er en int. Forelesning Ark 5 av 28

6 Bruk av funksjonspekere Bruk av et funksjonsnavn uten parenteser bak, gir en peker til funksjonen. (Dette implementeres som adressen til første instruksjon i funksjonen.) int odd(int x) /* Er x et oddetall? */ { return x%2; } int sqr(int v) /* Finn kvadratet av v. */ { return v*v; } int main(void) { printf("sum av odd(n): %5d\n", sum(odd,10)); printf("sum av sqr(n): %5d\n", sum(sqr,10)); return 0; } Kjøring av dette lille programmet gir følgende resultat: Sum av odd(n): 5 Sum av sqr(n): 385 Forelesning Ark 6 av 28

7 Pekere til pekere til... Noen ganger trenger man en peker til en pekervariabel (for eksempel fordi den skal overføres som parameter og endres). Siden vanlige pekere deklareres som xxx *p; må en «peker til en peker» angis som xxx **pp = &p; Dette kan utvides med så mange stjerner man ønsker. Eksempel Omgivelsesvariable i UNIX inneholder opplysninger om en bruker og hans eller hennes preferanser: LOGNAME=dag PAGER=less HOSTTYPE=sgi PRINTER=prent HOME=/home/ansatte/03/dag SHELL=/local/gnu/bin/bash Forelesning Ark 7 av 28

8 Omgivelsen overføres nesten alltid fra program til program ved en tredje parameter til main: int main(int argc, char *argv[], char **envir) Parameteren envir peker på en vektor av pekere som hver peker på en omgivelsesvariabel og den definisjon. LOGNAME=dag envir 0 PAGER=less HOSTTYPE=sgi PRINTER=prent HOME=/home/ansatte/03/dag SHELL=/local/gnu/bin/bash Forelesning Ark 8 av 28

9 Vanlige pekerfeil Det er noen feil som går igjen: Glemme initiering av pekeren! long *p; printf("verdien er %ld.\n", *p); Glemme frigjøring av objekt! long *p; p = (long*)malloc(sizeof(long)); p = NULL; Det allokerte objektet vil nå være utilgjengelig, men vil «flyte rundt» og oppta plass så lenge programmet kjører. Dette kalles en hukommelseslekkasje. Forelesning Ark 9 av 28

10 La en global peker peke på lokal variabel! long *p; void f(void) { long x; } p = &x; f(); p peker nå på en variabel som ikke finnes mer. Stedet på stakken der x lå, kan være tatt i bruk av andre funksjoner. Peke på resirkulert objekt! long *p, *q; p = q = (long*)malloc(sizeof(long)); free(p); p = NULL; q peker nå på et objekt som er frigjort og som kanskje er tatt i bruk gjennom nye kall på malloc. Forelesning Ark 10 av 28

11 Feilsøking Hva gjør vi når alt bare går galt? #include <stdio.h> #include <stdlib.h> int *vec[10]; int main(void) { int i; for (i = 0; i<10; ++i) { vec[1] = (int*)malloc(sizeof(int)); *vec[i] = i; } for (i = 9; i>=0; --i) { printf("vec[%d] peker på %d.\n", i, *vec[i]); } return 0; } Forelesning Ark 11 av 28

12 Forsøk på å kjøre dette programmet gir bare Segmentation Fault Dette forteller om en ulovlig peker/adresse, men hvor? I hvilken programkodelinje skjedde feilen? Hva var situasjonen da? Nærmere bestemt vil vi gjerne vite Hva inneholder de ulike variablene? Hva er kallkjeden (dvs hvilke funksjoner er kalt, og hvorfra)? Forelesning Ark 12 av 28

13 Debuggere En «debugger» er et meget nyttig feilsøkingsverktøy. Det kan analysere en program-dump, vise innholdet av variable, vise hvilke funksjoner som er kalt, kjøre programmet én og én linje, og kjøre til angitt stoppunkter. Debuggeren gdb er laget for å brukes sammen med både cc og gcc. Denharet vindusgrensesnitt som heter ddd. For å bruke gdb/ddd må vi gjøre to ting: kompilere våre programmer med opsjonen -g, og angi at vi ønsker programdumper: ulimit -c unlimited hvis vi bruker bash. (Da må vi huske å fjerne programdumpfilene selv; de er store!) Forelesning Ark 13 av 28

14 Programdumper Når et program dør på grunn av en feil («aborterer»), prøver det ofte å skrive innholdet av hele prosessen på en fil slik at det kan analyseres siden. 1. Programmet kompileres med debuggingsinformasjon: maskin navn> cc -g test-gdb.c -o test-gdb 2. Programmet kjøres: maskin navn> test-gdb Segmentation Fault (core dumped) maskin navn> ls -l core -rw-r--r-- 1 dag dag Feb 28 13:28 core Dette kalles ofte en «core-dump» siden datamaskinene for år siden hadde hurtiglager bygget opp av ringer med kjerne av feritt. I UNIX heter denne filen derfor core. Forelesning Ark 14 av 28

15 maskin navn> /local/hacks/sgi/bin/ddd test-gdb & Forelesning Ark 15 av 28

16 I File-menyen finner vi «Open Core Dump». Forelesning Ark 16 av 28

17 Nå vet vi at feilen oppsto på linje 12 i forbindelse med *vec[i] = i. Kanskje det er noe galt med indeksen i? I Data-menyen finner vi «Display Local Variables» Forelesning Ark 17 av 28

18 Variabelen i er 0, så den er OK. Hva da med vec? Vi kan klikke på en forekomst av vec og så «New Display». Forelesning Ark 18 av 28

19 Her ser vi at vec[0] er 0 mens vec[1] peker på noe; det burde vært omvendt! (vec[1] vec[9] skal ennå ikke ha fått noen verdi (siden i er 0).) Altså oppsto feilen under initieringen av vec der det står for (i = 0; i<10; ++i) { vec[1] = (int*)malloc(sizeof(int)); *vec[i] = i; } Vi kan da avslutte ddd med «Exit» i File-menyen. Forelesning Ark 19 av 28

20 Et eksempel til Følgende program skal skrive ut sine parametre og alle omgivelsesvariablene: #include <stdio.h> int main(int argc, char *argv[], char **envir) { char **p = envir, *e; int i; for (i = 0; i < argc; ++i) { printf("parameter %d: %s \n", i, argv[i]); } while (! (*p = NULL)) { e=*p; printf("%s\n", e); ++p; } return 0; } Kompilering går fint: maskin navn> cc -g printenv-feil.c -o printenv-feil men kjøringen går dårlig: maskin navn> printenv-feil a b Parameter 0: printenv-feil Parameter 1: a Parameter 2: b (null) (null). Control + \ Quit (core dumped) Forelesning Ark 20 av 28

21 Hva sier gdb/ddd? maskin navn> /local/hacks/sgi/bin/ddd printenv-feil & Forelesning Ark 21 av 28

22 Her ser vi imidlertid at feilen er oppstått i write, men den kaller vi da ikke i vårt program? Vi ber om «Backtrace» i Status-menyen. Forelesning Ark 22 av 28

23 Vi ser at feilen oppsto i linje 14 i main i kallet på printf. Vi klikker på «Up» fire ganger, og velger så «Display Local Variables» i Data-menyen. Vi ser at p ser OK ut, men e burde vel ikke være 0? La oss kjøre programmet på nytt, men legge inn et stoppunkt øverst i while-løkken. Pek og klikk på linjen, og så på «Break at ()». Så kan vi klikke på «Run» igjen. Forelesning Ark 23 av 28

24 Forelesning Ark 24 av 28

25 Etter at programmet er stoppet før det skal utføre while-løkken for første gang, lar vi det utføre de to første linjene ved å klikke på «Step». Forelesning Ark 25 av 28

26 Her ser vi at e er 0, og det må være galt! Dette skjedde i den gale testen while (! (*p = NULL)) { som burde vært skrevet while (*p!= NULL) { eller while (*p) { Konklusjon Noen timer brukt på å lære seg gdb og ddd får man mangedobbelt igjen senere i kurset! Forelesning Ark 26 av 28

27 Andre feilsøkingverktøy Programmet lint Dette programmet sjekker C-programmer og rapporterer mulig feil og foreslår hvorledes koden kan forbedres. maskin navn> lint prog.c (37) warning: variable may be used before set: q (37) warning: evaluation order undefined: q (37) warning: variable may be used before set: p (37) warning: evaluation order undefined: q (37) warning: evaluation order undefined: p (38) warning: argument mismatch: 1 arg passed, 0 expected (39) warning: variable may be used before set: x (88) warning: function returns value that is always ignored: printf variable unused in function (11) end in define (6) begin in define Kompilatormeldinger Noen ganger kan kompilatoren gi fornuftige advarsler om potensielle farer hvis man ber om det: maskin navn> cc -fullwarn printenv-feil.c Egne meldinger Det aller beste er å regne med at man gjør feil og legge inn egne utskrifter som kan slås av og på ved behov. Forelesning Ark 27 av 28

28 Programmet purify Dette kommersielle programmet legger inn alle mulig tester som blir utført under kjøringen: maskin navn> purify cc test-gdb.c -o test-gdb Purify 4.1 IRIX6, Copyright (C) Rational Software Corp.... Processing "/usr/lib/libc.so.1"... Processing "test-gdb" Når feil oppstår, kommer et meldingsvindu: Forelesning Ark 28 av 28