Föreläsning 13. In- och utmatning

Transkript

1 Föreläsning 13 In- och utmatning

2 Dagens kluring Deklarera en struct som kan användas för att representera en rät linje Använd den I main för att deklarera en variabel som du initierar så att den representerar en linje som går genom punken (0,2) och (4,-2) Om du hinner skriv en funktion som tar en linje och returnerar för vilket x den skär x-axeln

3 struct line //finns andra val, ex x1,y1,x2,y2 { double k,m; ; typedef struct line Line; double xcrossing(line l1) { return l1.m/l1.k; int main(){ Line myline; myline.k=-1; myline.m=2; printf("skarningen med x-axeln sker vid x = %f",xcrossing(myline)); 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 i en textfil sparar vi 5 tecken vilket tar 5 byte: Sparar vi samma heltal binärt kan det representeras av 2 byte: 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 int main(){ 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.. int main(){ 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 oppna filen?");

9 Läsa från textfil med fscanf int main(){ FILE *fp; char s1[wordlength],s2[wordlength]; 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 WORDLENGTH 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 saab fiat

11 void readfromfile(car reg[],int *pnrofcars) { FILE *fp; fp=fopen("minfil.txt","r"); if(fp!=null){ char model[wordlength]; int year,milage; while(fscanf(fp,"%s",model)==1){ fscanf(fp,"%d",&year); fscanf(fp,"%d",&milage); reg[*pnrofcars]=createcar(model,year,milage); (*pnrofcars)++; fclose(fp); int main(){ Car carregister[max]; int nrofcars=0; readfromfile(carregister,&nrofcars); printregister(carregister, nrofcars); return 0;

12 Alternativ Vi lägger in information om antal bilar överst i filen: 3 volvo saab fiat

13 void readfromfile(car reg[],int *pnrofcars) { FILE *fp; fp=fopen("minfil3.txt","r"); if(fp!=null){ char model[wordlength]; int year,milage,i; fscanf(fp,"%d",pnrofcars); for(i=0;i<(*pnrofcars);i++){ fscanf(fp,"%s",model); fscanf(fp,"%d",&year); fscanf(fp,"%d",&milage); reg[i]=createcar(model,year,milage); fclose(fp);

14 Snyggare textfil och snyggare kod? Vi arrangerar nu textfilen enligt nedan: volvo saab fiat

15 void readfromfile(car reg[],int *pnrofcars) { FILE *fp; fp=fopen("minfil3.txt","r"); if(fp!=null){ char model[wordlength]; int year,milage; while(fscanf(fp,"%s %d %d",model,&year,&milage)==3){ reg[*pnrofcars]=createcar(model,year,milage); (*pnrofcars)++; fclose(fp);

16 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 (ascii to int) 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

17 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

18 ##include <stdio.h> #include <string.h> #define WORDLENGTH 30 #define MAX 100 int main(){ char s[max][wordlength]; FILE *fp; fp = fopen ("minfil.txt","r"); if(fp!=null){ int numberof=0; while(fgets(s[numberof],sizeof(s[numberof]),fp)){ s[numberof][strlen(s[numberof])-1]='\0'; numberof++; fclose(fp); int i; for(i=0;i<numberof;i++) printf("%s\n",s[i]); return 0; //byter ut '\n'

19 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ånga 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!

20 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

21 void writebinary(car reg[],int nrofcars) { FILE *fp; fp = fopen("bildata","wb"); if(fp==null) { printf("misslyckades med sparning pga misslyckad filoppning"); exit(exit_failure); //<stdlib.h> fwrite(&nrofcars,sizeof(nrofcars),1,fp); //det finns ett snitsigt sätt att ta reda på antal från filstorleken fwrite(reg,sizeof(car),nrofcars,fp); //här skriver vi hela arrayen med structar fclose(fp); void readbinary(car reg[],int *pnrofcars) { FILE *fp; fp = fopen("bildata","rb"); if(fp==null) { printf("misslyckad filoppning vid lasning"); exit(exit_failure); fread(pnrofcars,sizeof(*pnrofcars),1,fp); fread(reg,sizeof(car),*pnrofcars,fp); //här läser vi hela arrayen med structar fclose(fp);