In- och utmatning

1. In- och utmatning

2. Dagens kluring Deklarera en structsomkananvändasförattrepresentera en rätlinje Använd den I main förattdeklarera en variabelsom du initierarsåatt den representerar en linjesomgårgenompunken (0,2) och (4,-2) Hemma (ellerom du hinner) skriv en funktionsom tar en linjeochreturnerarförvilket x den skär x-axeln

3. structlinje//här kan man göra andra val, tex repr med två punkter som linjen { //skär double k,m; }; typedefstruct linje Linje; double xSkarning(Linje rl) { return -rl.m/rl.k; } intmain(){ Linje minLinje; minLinje.k=-1; minLinje.m=2; printf("Skarningen med x-axeln sker vid x = %f",xSkarning(minLinje)); return 0; }

4. In- och utmatning • Strömmar (streams) • Binärfiler och textfiler • Skriva till textfil med fprintf • Läsa från textfil med fscanf • Läsa in till bilregistret med fscanf • Läsa med fgets • Skriva och läsa binärt i bilregistret

5. Strömmar • En ström betyder en källa för indata (tangentbordet, hårddisk, DVD, nätverksportar,…) eller ett mål för utdata (hårddisk, printer, portar,…) • I C kommer vi åt strömmar via en filpekare och en ström kallas ofta helt enkelt för en fil (vilket det ofta är) • När vi från vårt program vill kommunicera med hårddisken öppnar vi en ström och associerar den till en fil på hårddisken, det gör vi med fopen som returnerar en filpekare • När man har läst eller skrivit klart bör man alltid stänga strömmen. Det gör man med fclose. (Ofta skrivs data inte direkt till filen utan till en buffert, stänger vi då inte filen kanske datat aldrig skriv till den fysiska filen) • Printf som vi tidigare har använt för utmatning använder en ström som alltid är öppen och kallas standard output, stdout. Den skriver normalt till kommandotolken men går att omdirigera • Scanf använder på samma sätt strömmen standard input, stdin • Alla funktioner vi behöver bor i stdio.h så glöm inte #include <stdio.h>

6. Textfiler och binära filer • Består inte alla filer av 1or och 0or? Jo frågan här är hur dessa 1or och 0or ska tolkas • I en textfil ska alla ettor och nollor tolkas som ascii-tecken. Dessutom har textfiler radslut (i unix tecken 10 och i windows tecken 13 följt av tecken 10). De kan också ha ett filslutstecken. • I en binärfil skrivs alla 1or och 0or ner precis som programmet har dem lagrade i minnet. Hur de ska tolkas beror på vad man skrivit. Har man skrivit ett heltal ska de tolkas så som C skriver heltal. Endast om man vet exakt vilken sorts data som skrivits är det möjligt att tolka filen. Binärfiler saknar också radslut och filslut. • Ett exempel. Ska vi spara heltalet 32767 i en textfil sparar vi 5 tecken vilket tar 5 byte:00110011|00110010|00110111|00110110|00110111 ’3’ ’2’ ’7’ ’6’ ’7’Sparar vi samma heltal binärt representeras det i datorn av 2 byte:01111111|1111111 • Binära filer blir mindre, går fortare att läsa och skriva. Textfiler kan man öppna i en texteditor och se vad de innehåller.

7. Skriva till textfil med fprintf intmain(){ FILE *fp; fp = fopen("minFil.txt","w"); fprintf(fp,"%s\n",”Tjena"); fprintf(fp,"%s\n",”leget"); fprintf(fp,"%d\n",234); fclose(fp); return 0; }

8. Med kontroll.. intmain(){ FILE *fp; fp = fopen("minFil.txt","w"); if(fp!=NULL){//viktigare vid inläsning fprintf(fp,"%s\n",”Tjena"); fprintf(fp,"%s\n",”leget"); fprintf(fp,"%d\n",234); fclose(fp); }else{ printf("Kunde inte öppna filen?"); } }

9. Läsa från fil med fscanf intmain(){ FILE *fp; char s1[ORDLANGD],s2[ORDLANGD]; int i; fp = fopen ("minFil.txt","r"); if(fp!=NULL){ fscanf(fp,"%s",s1); fscanf(fp,"%s",s2); fscanf(fp,"%d",&i); printf("Last:%s,%s,%d",s1,s2,i); fclose(fp); } return 0; } Precis som med scanf finns risken att vi läser in längre ord än vad som får plats. Fördelen är att vi kan använda formatsträngar och därmed tex heltal. Om vi med säkerhet vet att vi inte har längre ord än ORDLANGD tex för att vi använt det när vi skrivit filen kan man överväga att använda det ändå

10. Läsa in med fscanf till bilregistret • Vi förutsätter här att registret är sparat till en fil kallad minfil.txt enligt följande format: volvo 1976 21000 saab 1999 34000 fiat 2013 3000

11. voidlasIn(Bil reg[],int *antal) { FILE *fp; fp=fopen("minFil.txt","r"); if(fp!=NULL){ char marke[ORDLANGD]; intarsmodell,mil; while(fscanf(fp,"%s",marke)==1){//Alternativt kan man först i filen skriva antalet bilar och då läsa fscanf(fp,"%d",&arsmodell); // in det och använda en for-loop fscanf(fp,"%d",&mil); reg[*antal]=skapaBil(marke,arsmodell,mil); (*antal)++; } fclose(fp); } } intmain(){ Bil bilRegister[MAX]; int antal=0; lasIn(bilRegister,&antal); skrivaUtRegister(bilRegister,antal); return 0; }

12. Snitsigare inläsning • Har man lite koll på formaterad inläsning kan man göra en snyggare fil och dessutom läsa in en hel bil med en inläsning. • Vi arrangerar nu textfilen enligt nedan: volvo 1976 21000 saab 1999 34000 fiat 2013 3000

13. voidlasIn(Bil reg[],int *antal) { FILE *fp; fp=fopen("minFil.txt","r"); if(fp!=NULL){ char marke[ORDLANGD]; intarsmodell,mil; while(fscanf(fp,"%s %d %d",marke,&arsmodell,&mil)==3){ reg[*antal]=skapaBil(marke,arsmodell,mil); (*antal)++; } fclose(fp); } }

14. fgets • fscanf har precis som scanf problemet att den riskerar att läsa in större saker än var som får plats. Mycket säkrare då att använda fgets där man kan ange maximalt antal lästa tecken. • Den läser endast strängar så behöver man läsa tex ett heltal får man läsa in heltalet som en sträng och sedan använda funktionen atoi (asciitoint) för att omvandla till ett heltal eller atof för decimaltal. • fgets läser en hel rad och lägger in i en sträng. En egenhet är att den till skillnad från gets också lägger in ’\n’ sist i strängen. Detta vill man oftast inte och man får då manuellt byta ut det mot ’\0’. • Man kan använda fgets istället för gets för att läsa från standard in genom att helt enkelt ange stdin som ström och på så sätt få säkrare inmatning

15. fgets läser från fil • Här kommer ett program där vi läser textrader från en fil till dess att filen är slut. • Eftersom vi inte vill ha med radslutstecknet byter vi också ut det mot ’\0’

16. #include <stdio.h> #include <string.h> #define ORDLANGD 30 #define MAX 100 intmain(){ char s[MAX][ORDLANGD]; fp = fopen ("minFil2.txt","r"); if(fp!=NULL){ int antal=0; while(fgets(s[antal],sizeof(s[antal]),fp)){ //kunde använt ORDLANGD s[antal][strlen(s[antal])-1]='\0'; //byter ut '\n' antal++; } fclose(fp); int i; for(i=0;i<antal;i++) printf("%s\n",s[i]); } return 0; }

17. fgets istället för gets • Man kan enkelt använda fgets istället för gets om man vill ha möjligheten att inte råka läsa för måna tecken. Kom bara ihåg att fgets sparar ’\n’ • Vi skriver då helt enkelt:fgets(str, sizeof(str), stdin);för att läsa till str från standard in • Om användaren nu matar in för många tecken så krachar inte programmet!

18. Binära filer • I denna kurs räcker det om ni vet vad binära filer är. • Vi har valt att fokusera på textfiler för att de är lite mer tillgängliga och för att de är användbara i fler sammanhang • Dock är det ofta kanske lite förvånande lättare att använda binära filer. Man behöver inte bry sig om rader eller format. Man ser bara till att läsa in precis som man skrev ut. • Jag visar därför hur man skulle läsa och skriva binärt i vårt bilregister för den intresserade

19. voidskrivaBinart(Bil reg[],int antal) { FILE *fp; fp = fopen("bildata","wb"); if(fp==NULL) { printf("Misslyckades med sparning pga misslyckad filoppning"); exit(EXIT_FAILURE); //<stdlib.h> } fwrite(&antal,sizeof(antal),1,fp);//det finns ett snitsigt sätt att ta reda på antal från filstorleken men vi skippar det fwrite(reg,sizeof(Bil),antal,fp);//här skriver vi hela arrayen med structar fclose(fp); } voidlasaBinart(Bil reg[],int *antal) { FILE *fp; fp = fopen("bildata","rb"); if(fp==NULL) { printf("Misslyckad filoppning vid lasning"); exit(EXIT_FAILURE); } fread(antal,sizeof(*antal),1,fp); fread(reg,sizeof(Bil),*antal,fp);//här läser vi hela arrayen med structar fclose(fp); }

20. Studieanvisningar F10 • Läs igenom föreläsningen och programmera exemplen och experimentera • Lägg till funktionalitet som skriver ut alla bilar i registret i vårt bilregisterprogram till en textfil när man väljer avsluta. • Lägg till så att man när bilregistret startar kan välja att ange en textfil som programmet läser in bilar från till arrayen. Se till att du matchar inläsningen med hur du skrev ut. Observera att alla bilar läses in först i körningen och alla bilar skrivs ut sist i körningen. Under resten av programmet förekommer ingen filhantering. • Om du vill kan du göra en version av bilregistret som läser och skriver binärt • Om du vill kan du skumma igenom kapitel 22. Det finns mycket användbart men också mycket som inte ingår och texten är något svårtillgänglig så det är ok att hoppa läsningen och fokusera på föreläsningsanteckningarna denna gång om man tycker att man har fullt upp med annat. E-excercises, P-programmingprojects