Övning 3 i 2D1324 Strukturering h filer deklaration vs definition Debuggning gdb Preprocessorn #define assert(s) FILE LINE Länkning Avancerad c-programering och repetition
Typisk h-fil #ifndef special_a #define special_a struct another_struct{ char name[30] int age; }; struct dummy_node{ struct another_struct *data; struct dummy_node *next }; typedef struct dummy_node Dummy_Node; typedef stuct another_struct Another_struct; void swap(int *a, int *b); Another_struct* clone(another_struct* to_clone); void print_int_array(int *start, int num_to_print); #endif
Kloning av structar #include <stdio.h> #include <stdlib.h> #include <string.h> #include special_a.h Another_struct* clone(another_struct* to_clone){ Another_struct* p= (Another_struct*)malloc(sizeof(Another_struct)); strcpy(p->name,to_clone->name); p->age=to_clone->age; return p; }
Kopiering av bufferts #include <stdio.h> #include <stdlib.h> #include <string.h> int main(int argc, char* argv[]) { if(argc == 1){ printf("du måste ange ett extra ord när du startar programmet\n usage: %s ord_att_kopiera",argv[0]); } else{ char buffert[30]="initialt innehåll"; printf("buffert innehåller: %s\n kopierar från argv...",buffert); /*För att kopiera innehållet i sträng måste vi använda funktion strcpy(char *dest,char *source) som finns i string.h skriver vi buffert=argv[1]; ändrar vi var buffert pekar istället för innehållet skriver vi *buffert= *(argv[1]); så kopierar vi inte hela strängen */ strcpy(buffert,argv[1]); printf("...koperiering gjord till buffert\nbuffert innehåller: %s\n",buffert); } return 0; }
Deklarerad vs Definerad. int foo(int bar); är en deklaration eftersom den slutar med ; Eftersom foo behövs i flera av våra moduler måste foo deklareras i varje fil. Lättast görs detta i en h fil som har en include guard. Då kan vi inkludera den i varje fil. int foo(int bar){ return bar*2; } är definderad eftersom själva programkoden för foo är med. Eftersom det är definition ska den ligga i c fil.
Dela med sig kod/program? Ofta är det olämpligt att ge folk för mycket kunskap om funktioners innehåll. Du säljer ditt program och vill inte avslöja din lösning. Vidare frestas köparen nyttja kunskap om detaljer som han inte bör ta hänsyn till eftersom du avser att ändra dessa. Om dina deklarationer ligger i h fil som kan inkluderas och c filerna bifogas som o eller lib filer undviker man problemet. Personen kan iofs hypotetiskt köra disassemblings program för att få fram koden i alla fall. Det förbjuds dock normalt uttrycklingen av licensvillkoren.
Abstraktion och separation Ofta har man läget att man dels har logik som väljer vad som ska göras samt programkod som direkt kommunicerar med hårdvara, grafiska komponenter eller annat. Skriver man ett enda program blir det mycket kostsamt att byta hårdvara, logik eller dylikt. All kod måste undersökas innan man vet att allt fungerar. En bättre lösning är att logik lagret har en h fil som beskriver ett mellanlager som i sin tur anropar hårdvaran. Fördelarna med detta är så stora att detta upplägg normalt är krav inom industrin. (dock tyvärr inte alltid på kth)
Kompilera flera filer Man kan kompilera flera c filer genom att skriva. gcc -Wall -g -o result fil1.c fil2.c fil3.c fil4.c (om ni inte vet vad -Wall och -g gör bör ni skyndsamt kolla upp dessa flaggor) Själva h filerna inkluderas i c filerna så dessa står aldrig uttryckligen. Vill man spara tid i kompileringen bör man kompilera endast den fil som ändrats och sedan länka ihop den gamla o filer gcc -Wall -g -c fil2.c
make Make arbetar på filer som innehåller specifikationer om hur ditt program arbetar. Först står mål sedan ett : följt av vilka filer som behövs för att skapa målet. På raden efter följer de kommandon som make ska göra om den märker att filen behöver uppdateras. Är make filen rätt skriven så kommer make undersöka vilka filer som ändrats och kompilera om dessa enbart. Make kan sättas att göra annat än kompilera filer. Kommandon som cp, cd,mv,rm ls och liknande stöds. Man kan även få make att zippa filer eller göra annat nyttigt.
Debuggning Att komma på vad pekare faktiskt gör i ett program kan vara klurigt. Har vi pekare till structar är det ju adressen för det som pekaren pekar på som är intressant och inte adressen till pekaren själv. I praktiken är det lätt att göra bort sig. Om ni inte fattar varför ert progam inte fungerar...kompilera med flaggan -g och använd sedan programmet gdb. En beskrivning av hur man använder gdb finns på http://mia.ece.uic.edu/~papers/www/debugging/debugging-with-gdb.html
Preprocessorn kan hitta buggar #include<assert.h> void open_record(char *record_name) { assert(record_name!=null); /* Rest of code */ } int main(void) { open_record(null); }
Hur skulle assert kunna se ut? #define assert(s) if(s) {} else printf( Assert failed in %s on line %d, FILE, LINE ) /*Dock så finns piffig variant av assert i filen assert.h så man slipper att ens göra testet. FILE och LINE är värden som preprocessorn tillhandahåller som säger vilken fil och vilken rad som koden kommer från. Har man ingen terminal att få utdata till så får man blinka med diod, skicka ett interupt eller göra något annat man kan upptäcka.*/
Dynamisk vs statisk länkning Allt i c standard biblioteket ligger kompilerat redo att länkas in i program. Det finns två sätt att göra detta. Med dynamisk länkning så hämtas funktionen från så kallad dll fil när den behövs. Man sparar massa plats på hårddisken...men måste ha speciellt installationsprogram som kontrollerar om dll filen finns installerad. Alternativt gör man statisk länkning. Från så kallade lib filer hämtas den kompilerade koden och länkas in permanent. Programmet blir betydligt mycket större men kan köras utan installationsprogram.
Viktiga saker om minne Var försiktiga med pekare som inte satts att peka på något menigsfullt. Antingen bör pekare sättas att peka på NULL eller på något från malloc. Varje malloc anrop måste matchas av exakt ett free anrop. Gör man free på samma minne två gånger så får man problem. Sätt därför en pekare att peka på NULL efter att ni gjort free. Det är ofarligt att göra free på en NULL pekare. Läs pekar tutorialen på hemsidan!
Dålig pekar returnering Funktioner som returnerar saker ska aldrig returnera pekare till något som ligger på stacken. Allt som ligger på stacken för funktionen blir ju av allokerat när funktionen tagit slut så minnet pekaren är satt att peka på kan skrivas över när som helst efteråt. Just direkt efter funktionen returnerat märker man dock inget...men det är bara en tidsfråga innan någon funktion anropas. Lösningen är givetvis att allokera minnet med malloc och returnera pekare till detta.
Repetition pekare Läs pekartutorialen på hemsidan! rad[] == *(rad) rad[30] == *(rad+30) Observera att sammanhanget avgör om char rad[30] ska tolkas som en deklaration av 30 char eller som *(rad+30) matris[3][2]==*(*(matris+3)+2)
Returnera flera saker från funktion Python kan returnera flera saker från funktioner eftersom list är en av de inbygda typerna. I c har vi ingen lista. Vi har inte ens en riktig array utan pekar artimetik för att hantera dessa...vi kan dock deklarera en struct, allokera den med malloc och returnera en pekare till denna.
Skumma sätt att skriva saker... Kompakt men kanske lite svårtolkat... z = (a>b)? a : b; if (a>b) z = a; else z=b;
Hur klarar man sig utan try, catch? Lösning : Undersök returvärdet på allt...lusläs manualen så ni vet i vilka fall ni kan få NULL eller annat värde som indikerar fel. Det finns ett kompakt sätt att skriva saker...(nästa sida visar varför detta orsakar problem.) if( char *ptr= (char*)malloc(10*sizeof(char))){ printf( ERROR: Could not alloc memory. ); exit(-1); }
Problemet med = och == Skriver man if(tal = 5 ) istället för if(tal == 5) så betyder det en tilldelning istället för jämförelse. Eftersom 5 inte har samma värde som NULL så tolkas det som sant. Väldigt jobbig loggisk bugg att hitta... Lösningen är att skriva smartare jämförelser. Om if(5 == tal) felskrivs som if( 5 = tal ) så klagar kompilatorn eftersom vi inte får tilldela värden till konstanter.
Pekare till funktioner C stödjer precis som python att man har pekare till funktioner. Precis som i python används det typiskt för att ändra sorteringsvillkor. Ett annan användning är att i structar har pekare till funktioner som operar på structens data... int foo(int); int (*pf) (int) = &foo; #Anrop av samma funktion ans = foo(5); ans = pf(5);
Länkade listor Att repetera länkade listor är bortkastad tid. Ni har gjort swahili labben från i höstas, kan hitta 184 000 000 sidor om länkad listor via google och vet hur man formulerar rekursiva tankar. Att en del personer har problem med listorna är delvis befarat...hälften av de som skrev tentan körde rekursionsuppgiften. Det är dock inget skäl att ni inte ska bli klara med labben denna vecka. Ta en paus...skriva h-filer som uppfyller de krav labben kräver...jobba med rekursiva tankar och ni kommer snart vara helt klara. Själva hash funktionen går fort när ni kommit så långt.