Deklarera en struct som kan användas för att representera en rät linje

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) Hemma (eller om du hinner) skriv en funktion som tar en linje och returnerar för vilket x den skär x-axeln

struct linje//här kan man göra andra val, tex repr med två punkter som linjen { //skär double k,m; ; typedef struct linje Linje; double xskarning(linje rl) { return -rl.m/rl.k; int main(){ Linje minlinje; minlinje.k=-1; minlinje.m=2; printf("skarningen med x-axeln sker vid x = %f",xskarning(minlinje)); return 0;

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

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>

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.

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;

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 öppna filen?");

int main(){ 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å

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

void lasin(bil reg[],int *antal) { FILE *fp; fp=fopen("minfil.txt","r"); if(fp!=null){ char marke[ordlangd]; int arsmodell,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); fscanf(fp,"%d",&mil); reg[*antal]=skapabil(marke,arsmodell,mil); (*antal)++; fclose(fp); int main(){ Bil bilregister[max]; int antal=0; lasin(bilregister,&antal); skrivautregister(bilregister,antal); return 0; // in det och använda en for-loop

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

void lasin(bil reg[],int *antal) { FILE *fp; fp=fopen("minfil.txt","r"); if(fp!=null){ char marke[ordlangd]; int arsmodell,mil; while(fscanf(fp,"%s %d %d",marke,&arsmodell,&mil)==3){ reg[*antal]=skapabil(marke,arsmodell,mil); (*antal)++; fclose(fp);

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

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

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

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!

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

void skrivabinart(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); void lasabinart(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);

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-programming projects