C Bootstrapping (2 weeks)

Det är obligatoriskt att göra dem, men inte att göra dem på plats. Redovisning är enbart möjligt på plats, men alla labbar finns ute från dag 1 och kan göras när som helst.

Ja. Nej. Nja. Det är bra att arbeta i par om två – dels för att du kommer att göra det senare under kursen, ev. också arbetslivet, men också för att det främjar reflektion att samarbeta med någon annan – eftersom ni måste diskutera vad ni håller på med och inte “bara göra det” i en blind jakt på att bli klar³. Det viktigaste är att varje enskild person har varit med och gjort allt som labbarna innehåller. Om du jobbar själv händer det automagiskt. Om du jobbar med någon annan måste du se till att vara 50% av tiden framför tangentbordet! *Du kommer inte att lära dig programmering om du låter någon annan skriva all kod!!!*

Vi rekommenderar att du försöker hinna klart med uppgifterna på det labbtillfälle de ges (under Adams Weckor). Varje labbs mjuka deadline är alltså samma dag som den ges. Om du av någon anledning inte hinner klart, eller om du missar en labb kan du göra klart labben på egen hand och istället redovisa den på efterföljande labb. Varje labbs hårda deadline är alltså efterföljande labbtillfälle.

Om du av någon anledning tror att du inte kommer klara någon hård deadline, hör av dig till en senior assistent eller till Tobias så hittar vi en lösning!

Det finns många sätt att komma vidare om du kör fast:

Fråga en labbassistent - Assarna är här för att hjälpa till

Kom ihåg att de inte sitter på “det rätta svaret” (det finns nästan aldrig bara en enda lösning när man programmerar) men förmodligen kan hjälpa dig komma vidare med din egen lösning.

Fråga en kompis

Att prata om programmering är ett utmärkt sätt att lära sig programmera, oavsett om man är den som förklarar eller den som får hjälp. Så länge man inte skriver av varandras lösningar rakt av så finns det inga problem att diskutera lösningar med varandra.

Ställ en fråga på Piazza

På Piazza kan din fråga besvaras av assistenter och av andra studenter utanför labbtid. Gör gärna din fråga publik så att fler kan ta del av svaren!

Googla problemet

Att kunna hitta svaret på sina frågor på Internet är en av de viktigaste sakerna man måste lära sig som programmerare. Någon gång kommer du hamna i en situation där det inte finns någon annan att be om hjälp, och då är det bra att veta hur man letar själv.

Börja om

Det låter kanske konstigt, men ofta när man kör fast beror det på att man har lett in sig själv i en återvändsgränd. Var inte rädd att skriva om program (eller i alla fall delar av ett program) helt från början. Ta bort (eller flytta) gammal kod så att du inte ser den när du skriver den nya.

De första två veckorna har vi valt att prioritera de som inte har programmerat mycket utanför tidigare kurser på IT/DV så att fler ska nå en nivå där det går att samarbeta och göra intressanta och roliga saker. Om du redan kan det som tas upp här kommer labbarna att gå snabbt. Om du stöter på något som tar längre tid så visade det sig att det fanns något för dig att lära dig ändå!

Blir du klar med uppgiften tidigt får du gärna hjälpa andra, men kom ihåg att poängen med att ge någon hjälp inte är att den andra ska bli klar så snabbt som möjligt utan denne ska lära sig så mycket som möjligt!

Programming is about problem solving. Most time is spent thinking – and the time it takes to write down the outcome of the thinking, the banging on the keyboard, is only a small fraction of the time. Also note that the goal of this course is to teach programming – not programming in a specific language. We use C (and later Java) to illustrate concepts like how to think about problem decomposition, resource management, code quality etc. We could use different languages, but still teach the same (well, mostly) course.

How to transform a specification (or an idea or a task…) into a running program is something that many beginner programmer consider magical. Often, it feels like the solution should just magically appear, or be obvious. This is far from the truth. However, a finishied program rarely gives us any idea of all the intermediate steps – and buggy variants of the final program – that the programmers went through to get there.

As a guide to the personal programming process, we recommend following the steps of the SIMPLE programming methodology. It provides some good practises and introduces some key tricks that experienced programmers often use to incrementally approach a solution to a problem.

Even if you have programming experience from before, please take a look at SIMPLE!

Som du säkert vet kommer vi att använda Emacs som editor på kursen. (Notera att med Emacs avses också vi/vim.) Emacs är en utökningsbar editor som är skriven i C och programspråket Emacs-lisp. Man utökar och raffinerar sin egen Emacs genom ytterligare paket skrivna i Emacs-lisp. Man kan skriva dessa paket själv, eller ladda ned dem och installera dem själv eller via Emacs inbyggda pakethanterare.

Emacs-resurser på kurswebben:

• Introduktion till Emacs
• Screencasts om Emacs
• Emacs lathund

Nu följer två olika uppsättningar instruktioner beroende på om du kör Linux eller OS X/macOS. För dig som kör Windows har vi tyvärr ingen handledning, men vi råder dig att installera Linux under kursens gång då det är en bättre programmeringsmiljö för den C-programmering som vi skall göra.

Nu är det dags att skapa en katalog för kursen i din hemkatalog på Linux-maskinerna (eller på din egen dator, eller båda). Ett lämpligt namn för denna katalog är ioopm. Sedan skall vi skapa en underkatalog lab1, en tom fil hello.c i den och starta Emacs för att editera filen.

$ cd ~              # gå till din hemkatalog
$ mkdir ioopm       # skapa underkatalogen ioopm
$ cd ioopm          # gå in i ioopm-katalogen
$ mkdir lab1        # skapa underkatalogen lab1
$ cd lab1           # gå in i lab1-katalogen
$ touch hello.c     # skapa en tom fil hello.c
$ emacs hello.c &   # starta Emacs för att editera filen
$

Om du kör på institutionens Linux och inte har gjort någon egen konfigurering kan du växla mellan program med Alt+Tab. Vi kommer att använda editorn för att skriva text och terminalen för att kompilera och köra programmet. Pröva att växla några gånger mellan programmen.

Om du använder förstersystemet Gnome (standard på t.ex. Ubuntu) kan du använda Ctrl+Win+vänsterpil för att maximera det aktuella fönstret på skärmens vänstra halva och motsvarande för den högra. Det är ett bra sätt att ha både terminalen och editorn så att man kan se all information alltid.

Var noga med att spara en version av varje färdigt program! Ta för vana att experimentera i en ny fil som du antingen skapar tom eller kopierar från en som fungerar.

Det klassiska första programmet att skriva i varje programspråk är “Hello, world!”

Börja med att skapa filen hello.c så här: C-x C-f hello.c. Tangentbordskombinationen C-x C-f i Emacs är bunden till funktionen find-file som alltså öppnar en fil, eller skapar en fil – om filen inte finns. För att spara filen trycker du C-x C-s som är bunden till funktionen save-buffer som sparar innehållet i den buffer som du editerar i, i den fil som den är knuten till.

Det finns många sätt att skriva detta program. Ett enkelt sätt är:

#include <stdio.h>

int main(void)
{
  puts("Hello, world!");
  return 0;
}

%23include%20%3Cstdio.h%3E%0A%0Aint%20main%28void%29%0A%7B%0A%20%20puts%28%22Hello%2C%20world%21%22%29%3B%0A%20%20return%200%3B%0A%7D%0A

Skriv av (eller kopiera, men ännu hellre skriv av) programmet ovan i en editor och döp det till hello.c. Alla C-program startar i funktionen main() (aka “main()-funktionen”) som är en funktion som returnerar ett heltal som berättar för det underliggande operativsystemet om körningen av programmet gick bra. Tillsvidare returnerar vi alltid 0.

Kompilera programmet med gcc hello.c – nu skapas filen a.out som du kör så här: ./a.out. Så här kan det se ut i terminalen:

$ emacs hello.c &       # startar Emacs
$ gcc hello.c           # kompilerar hello.c
$ ls                    # listar filerna i terminalen
a.out   hello.c
$ ./a.out               # kör a.out
Hello, world!           # programmets output
$ _                     # väntande kommandoprompt

Funktionen puts() skriver ut en sträng på terminalen (puts = “put string”). Låt oss nu experimentera med att använda funktionen printf(). Denna funktion tar ett variabelt antal argument. Börja med att ändra puts("Hello, world!"); till printf("Hello, world!");, kompilera om och kör programmet igen. Kan du se någon skillnad?

Skillnaden är add printf() inte automatiskt skriver ut en radbrytning efter utskriften. Sätt dit det genom att skriva \n efter !, dvs. printf("Hello, world!\n");.

Funktionerna puts() och printf() är två helt olika funktioner. Den första skriver ut en enskild sträng medan den andra kan användas för att skriva ut en mängd olika saker: strängar, heltal, flyttal, minnesadresser etc.

Pröva gärna att titta på skillnaden mellan puts() och printf() genom att skriva man puts och man printf i terminalen och titta på manualsidorna för funktionerna. Du scrollar med mellanslag och avslutar med q. (Du kan skriva man pager för att läsa vilka kortkommandon som finns för att läsa manualsidor med man-kommandot. Du kan också skriva man man för att få veta mer om man-kommandot.)

Pröva att ändra utskriften så här:

char *msg = "Hello, world!";
int year = 2017;
printf("%s in the year %d\n", msg, year);

char%20%2Amsg%20%3D%20%22Hello%2C%20world%21%22%3B%0Aint%20year%20%3D%202017%3B%0Aprintf%28%22%25s%20in%20the%20year%20%25d%5Cn%22%2C%20msg%2C%20year%29%3B%0A

Vi deklarerar nu en variabel msg som är en sträng (i C är typen för sträng char *, mer om detta senare) vars innehåll är texten “Hello, world!” och en variabel year som innehåller heltalet 2017. (Minns att en typ är ett namn på en samling värden som delar vissa egenskaper. I C har vi t.ex. en typ för heltal, en för flyttal, etc.)

Sedan säger vi åt printf() att skriva ut en sträng (%s) följt av texten “ in the year ”, följt av ett heltal (%d) följt av en radbrytning (\n). Sedan skickar vi med msg och year – i samma ordning som %s och %d (vad händer om du råkar byta plats på dem?).

Observera att printf() nu tar 3 argument. Funktionen tar alltid in en formatsträng (i vårt exempel "%s in the year %d\n") och sedan ytterligare ett argument för varje “styrkod” (%s och %d i detta exempel) som finns med i formatsträngen.

Från Haskell är du van vid att man binder namn till värden, t.ex. let x = 5 in BLAHRG. Där är x en konstant vars värde är 5. När vi har denna typ av namnbindningar kan vi söka och ersätta alla förekomster av x med 5 i BLAHRG och få samma resultat.

Variabler i C fungerar annorlunda i och med att deras värden kan ändras! int x = 5; ... betyder att vi har skapat ett namn, x, som avser ett heltal, som initialt är 5, men som kan komma att ändra värde. Om ... ovan t.ex. är

printf("%d\n", x);
x = 42;
printf("%d\n", x);

printf%28%22%25d%5Cn%22%2C%20x%29%3B%0Ax%20%3D%2042%3B%0Aprintf%28%22%25d%5Cn%22%2C%20x%29%3B%0A

kommer första utskriften av x att bli 5 och den andra 42.

Skriv ett program p1 som, när det körs, skriver ut talen 1 till 10 så här:

$ gcc p1.c
$ ./a.out
1
2
3
4
5
6
7
8
9
10

Du ska använd en for-loop och kan utgå från följande programskelett:

#include <stdio.h>

int main(void)
{
  int i = 1;              // deklaration och initiering av iterationsvariabeln
  while (i <= 10)         // iterationsvillkor (utför blocket så länge i är mindre än 11)
  {                       // loop-kropp (utförs så länge iterationsvillkoret är uppfyllt)
    printf("%d\n", 1);    // skriv ut 1, och en radbrytning
    i = i + 1;            // öka i:s värde med 1 (förändring av iterationsvariabeln)
  }
  return 0;
}

%23include%20%3Cstdio.h%3E%0A%0Aint%20main%28void%29%0A%7B%0A%20%20int%20i%20%3D%201%3B%20%20%20%20%20%20%20%20%20%20%20%20%20%20%2F%2F%20deklaration%20och%20initiering%20av%20iterationsvariabeln%0A%20%20while%20%28i%20%3C%3D%2010%29%20%20%20%20%20%20%20%20%20%2F%2F%20iterationsvillkor%20%28utf%C3%B6r%20blocket%20s%C3%A5%20l%C3%A4nge%20i%20%C3%A4r%20mindre%20%C3%A4n%2011%29%0A%20%20%7B%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%2F%2F%20loop-kropp%20%28utf%C3%B6rs%20s%C3%A5%20l%C3%A4nge%20iterationsvillkoret%20%C3%A4r%20uppfyllt%29%0A%20%20%20%20printf%28%22%25d%5Cn%22%2C%201%29%3B%20%20%20%20%2F%2F%20skriv%20ut%201%2C%20och%20en%20radbrytning%0A%20%20%20%20i%20%3D%20i%20%2B%201%3B%20%20%20%20%20%20%20%20%20%20%20%20%2F%2F%20%C3%B6ka%20i%3As%20v%C3%A4rde%20med%201%20%28f%C3%B6r%C3%A4ndring%20av%20iterationsvariabeln%29%0A%20%20%7D%0A%20%20return%200%3B%0A%7D%0A

Detta program är trasigt: det skriver ut 1 hela tiden. Börja med att fixa det (ledning: titta anropet till printf()), och skriv sedan om while-loopen med en for-loop som har följande syntax:

for ( deklaration och initiering av iterationsvariabel ;
      iterationsvillkor ;
      förändring av iterationsvariabel )
  {
    loop-kropp
  }

for%20%28%20deklaration%20och%20initiering%20av%20iterationsvariabel%20%3B%0A%20%20%20%20%20%20iterationsvillkor%20%3B%0A%20%20%20%20%20%20f%C3%B6r%C3%A4ndring%20av%20iterationsvariabel%20%29%0A%20%20%7B%0A%20%20%20%20loop-kropp%0A%20%20%7D%0A

Det så-kallade preprocessormakrot #include <stdio.h> talar om för C-kompilatorn att vi vill använda standardbiblioteket för input/output, som alltså heter stdio. Filen stdio.h som finns någonstans i filsystemet innehåller deklaration av funktioner och datatyper som blir tillgängliga i och med att man skriver #include <stdio.h> i den fil som vill använda biblioteket.

Kopiera programmet p1.c ovan till p2.c⁴ och skriv om det så att talföljden går ned från 10 till 1 istället:

$ gcc p2.c
$ ./a.out
10
9
8
7
6
5
4
3
2
1

Nu skall vi experimentera med nästade loopar, dvs. loopar vars loopkroppar innehåller loopar. Kopiera p1.c till p3.c och skriv om programmet så att det istället för tal skriver ut en ökande mängd *. Sist skall det skrivas ut hur många * (asterisker) som skrev ut:

$ gcc p3.c
$ ./a.out
*
**
***
****
*****
******
*******
********
*********
**********
Totalt: 55
$ _

Skriva ut N stycken * kan enkelt göras med en loop som i N varv skriver ut ett * i varje varv utan efterföljande radbrytning.

Här är ett förslag på delproblemen för den här uppgiften som alla kan lösas en i taget:

1. Skriv en loop som itererar från 1 till 10 (redan löst i p1.c).
2. Skriv en loop som skriver ut N stycken asterisker (för något värde på N).
3. Ändra loopen i 1. så att asterisker skrivs ut istället för tal (använd loopen från 2.).
4. Skriv ut summan av alla utskrivna asterisker (*).

Kopiera p3.c till p4.c – nu skall vi utöka programmet så att det går att skicka in antalet staplar som skall skrivas ut, samt hur snabbt staplarna skall växa. Här är tre exempelkörningar av programmet:

$ gcc p4.c
$ ./a.out 3 2
**
****
******
Totalt: 12
$ ./a.out 0 25
Totalt: 0
$ ./a.out 4 4
****
********
************
****************
Totalt: 40
$ ./a.out
Usage: ./a.out rows growth
$ _

Kommandoradsargument skickas automagiskt in som argument till main()-funktionen. Vi kan skriva programmet eko så här (som bara “ekar” alla kommandoradsargument):

#include <stdio.h>

int main(int argc, char *argv[])
{
  for (int i = 0; i < argc; ++i)
  {
    puts(argv[i]);
  }
  return 0;
}

%23include%20%3Cstdio.h%3E%0A%0Aint%20main%28int%20argc%2C%20char%20%2Aargv%5B%5D%29%0A%7B%0A%20%20for%20%28int%20i%20%3D%200%3B%20i%20%3C%20argc%3B%20%2B%2Bi%29%0A%20%20%7B%0A%20%20%20%20puts%28argv%5Bi%5D%29%3B%0A%20%20%7D%0A%20%20return%200%3B%0A%7D%0A

Observera nu att main()-funktionens signatur ser annorlunda ut. Två nya parametrar har lagts till:

1. int argc – heltalet argc som håller reda på hur många argument som skickades in
2. char *argv[] – en array av strängar som motsvarar kommandoradsargumenten

Minns att char * är C:s strängtyp – det efterföljande [] visar att argv inte är bara en sträng, utan en hel array av strängar.

Minns att en array är som en lista – dvs. en sekvens av värden, men till skillnad från en lista (i t.ex. Haskell) kan en array inte utökas. Om arrayen arr är en array med tre element kan vi komma åt element 1 med arr[0], element 2 med arr[1] och element 3 med arr[2]. Om vi skriver arr[3] för att komma åt det 4:e elementet är resultatet skräp, och exakt vad det betyder kan variera mellan olika implementationer av kompilatorer, etc. Det är alltså något som vi skall undvika, men som kompilatorn inte skyddar oss emot.

Arrayer indexeras från 0 i C (och många andra programspråk), dvs. puts(argv[0]) skriver ut den första strängen i argv. argv[0] = "Ivor Cutler" gör så att den första strängen i argv-arrayen blir strängen “Ivor Cutler”.

När programmet ovan körs skriver det ut sina kommandoradsargument så här:

$ gcc eko.c
$ ./a.out hej hopp fallera 42
./a.out
hej
hopp
fallera
42
$ _

I ovanstående körning anropas main()-funktionen med argc = 5 och argv = ["./a.out", "hej", "hopp", "fallera", "42"].

Observera att den första strängen i argv alltid är det namn som man använde för att starta programmet – alltså ./a.out i alla våra exempel hittills.

Observera att "42" är en sträng och att 42 är ett heltal – de är alltså olika datatyper som inte är kompatibla. Man kan konvertera strängen "42" till talet 42 med hjälp av funktionen atoi():

char *str = "42";
int num = atoi(str);
printf("%s == %d?\n", str, num);

char%20%2Astr%20%3D%20%2242%22%3B%0Aint%20num%20%3D%20atoi%28str%29%3B%0Aprintf%28%22%25s%20%3D%3D%20%25d%3F%5Cn%22%2C%20str%2C%20num%29%3B%0A

atoi() står för ASCII to Integer. (En av anledningarna till att namnen på många funktioner är så korta och usla är att man i förhistorisk tid kunde tjäna många sekunder på att slippa skicka “onödiga” tecken över väldigt långsamma linor när man skulle programmera via terminaler. Det är inte en giltig anledning längre, men det är svårt att ändra 30+ år gamla standardbibliotek som regleras av trögrörliga standardiseringsorgan.)

För att använda atoi() måste programmet inkludera standardbiblioteket stdlib.h:

#include <stdio.h>   // stod redan
#include <stdlib.h>

%23include%20%3Cstdio.h%3E%20%20%20%2F%2F%20stod%20redan%0A%23include%20%3Cstdlib.h%3E%0A

(Senare skall vi skriva en funktion som konverterar från ett heltal till en sträng.)

I körningsexemplet ovan detekterar programmet om det körs utan några argument (eller – mer korrekt – utan andra argument än programmets namn) och skriver i så fall ut en hjälptext:

Usage: ./a.out rows growth

Vi kan använda en if-sats för att kontrollera om antalet argument är felaktigt.

if (antalet argument < 2 || antalet argument > 3)
{
  skriv ut felmeddelande
}
else
{
  utför uppgiften
}

if%20%28antalet%20argument%20%3C%202%20%7C%7C%20antalet%20argument%20%3E%203%29%0A%7B%0A%20%20skriv%20ut%20felmeddelande%0A%7D%0Aelse%0A%7B%0A%20%20utf%C3%B6r%20uppgiften%0A%7D%0A

Den märkliga ||-symbolen är ett logiskt eller dvs. a || b är sant om a är sant, eller om b är sant, eller om båda är sanna.

Betänk följande:

• Arrayer indexeras från 0
• argv[0] är programmets namn
• Programmet blir lättare att läsa och förstå om du sparar argv[1] och argv[2] i variabler med vettiga namn.
• Programmet klarar inte av kommandoradsargument som inte är tal

Med hjälp av vad vi lärt oss hittills kan vi nu skriva ett enkelt program som tar emot ett tal som kommandoradsargument och avgör om det är ett primtal. Utgå från p4.c och kopiera det till p5.c.

En enkel algoritm för att kontrollera om talet N är ett primtal är att pröva om x * y = N för alla kombinationer av x och y i intervallet 2 till N. Om det inte går att hitta ett sådant x anser vi att N är ett primtal. Två tal kan jämföras med operatorn ==, t.ex. så här:

if (a == b)
{
  puts("Lika");
}
else
{
  puts("Inte lika");
}

if%20%28a%20%3D%3D%20b%29%0A%7B%0A%20%20puts%28%22Lika%22%29%3B%0A%7D%0Aelse%0A%7B%0A%20%20puts%28%22Inte%20lika%22%29%3B%0A%7D%0A

Med en nästad loop kan du prova alla kombinationer av x och y genom att räkna ut 2*2, 2*3, …, 2*(N-1), 3*2, 3*3… och se om någon produkt är lika med N.

En optimering av algoritmen ovan är att inte växa x högre än roten av N. Roten av N kan räknas fram med biblioteksfunktionen sqrt(). Optimeringar kan vi göra först när vi fått en första version av programmet att fungera.

float roten_ur_n = sqrt(N);

float%20roten_ur_n%20%3D%20sqrt%28N%29%3B%0A

För att använda sqrt() måste programmet inkludera matematikbiblioteket math.h på samma sätt som du inkluderat stdio.h och stdlib.h tidigare: #include <math.h>.

Notera att sqrt() returnerar ett flyttal. Hjälpfunktionen floor() skapar ett heltal från ett flyttal och avrundar nedåt. Gränsen för x blir därför:

float tmp = sqrt(N);
int limit = floor(tmp) + 1;

float%20tmp%20%3D%20sqrt%28N%29%3B%0Aint%20limit%20%3D%20floor%28tmp%29%20%2B%201%3B%0A

Det går också att skriva detta program utan variabeln tmp. (Gör gärna det – här ville vi lyfta fram de två delstegen.)

Skriv klart programmet och testa det:

$ gcc p5.c
$ ./a.out 7
7 is a prime number
$ ./a.out 2
2 is a prime number
$ ./a.out 4
4 is not a prime number

Anser programmet att 1 är ett primtal? Anser programmet att 0 är ett primtal?

Skriv nu ett program som tar emot två positiva tal och skriver ut deras största gemensamma delare med hjälp av Euklides algoritm:

gcd(a, b) = a                om a = b
gcd(a, b) = gdc(a - b, b)    om a > b
gcd(a, b) = gdc(a, b - a)    om a < b

Använd en while-loop eller en for-loop för att lösa problemet. Varje varv i loopen kommer variabeln a eller variabeln b att ändra värde beroende på vilken som innehåller det största värdet. Till slut är de lika och då har vi svaret.

Du kan utgå från p5.c och skapa p6.c eller skriva programmet från grunden. Så här skall en exempelkörning av programmet se ut:

$ gcc p6.c
$ ./a.out 40 12
gcd(40, 12) = 4

Använd printf() för utskriften. Minns att %d är styrkoden för heltal och %s är styrkoden för strängar.

Tips på jämförelseoperatorer:

a == b // sant om a och b innehåller samma värde
a != b // sant om a och b inte innehåller samma värde
a < b  // sant om a:s värde är strikt mindre än b:s värde
a > b  // sant om a:s värde är strikt större än b:s värde

Boolesk algebra i C:

!a     // sant om a är falskt
a && b // sant om både a och b är sanna
a || b // sant om a och/eller b är sanna/sant

Vi kan nu beskiva ytterligare C-operatorer i termer av de vi redan sett:

• a <= b är logiskt ekvivalent med a < b || a == b
• a >= b är logiskt ekvivalent med a > b || a == b
• a != b är logiskt ekvivalent med !(a == b) alternativt a < b || a > b
• a == b är logiskt ekvivalent med !(a < b || a > b) alternativt !(a < b) && !(a > b)

Tips på sätt att manipulera numeriska variabler:

• a = a - 1 ändrar värdet på a till 1 mindre än vad det var innan
• a -= 1 är ekvivalent med ovanstående
• a-- och --a minskar värdet på a med 1 på samma sätt, men har subtila skillnader – tills vidare bör du enbart använda dem för sido-effekter (om alls!)
• Motsvarande finns för addition += och ++
• *= och /= existerar även för multiplikation och division

Frivilliga extrauppgifter:

1. Detektera att programmet används korrekt – exakt två positiva tal skickas in
2. Utöka programmet med stöd för hantering av negativa tal

Nu har det blivit dags för oss att skriva vår första funktion (förutom main()-funktionen då) – vilket vi kommer att ägna oss åt under nästa labb. Vi skall skriva funktionen is_number() som tar emot en sträng (char *) och returnerar en boolean (bool) – true om den inskickade strängen är ett positivt eller negativt tal, annars false.

Av historiska skäl måste stöd för booleaner inkluderas explicit i C på följande sätt:

#include <stdbool.h>

%23include%20%3Cstdbool.h%3E%0A

Genom detta bibliotek får du tillgång till datatypen bool samt konstanterna true och false. (Nästan alla värden i C går att konvertera till sanningsvärden, även om det ofta inte är semantiskt vettigt. 0 är falskt och alla andra värden är sanna. Konverteringen sker automatiskt, så bool b = 1; är logiskt ekvivalent med bool b = true; även om det är vansinnig kod att skriva.)

Skapa en ny fil temp.c med en tom main()-funktion med kommandoradsargumenten i (du kan kopiera texten från högre upp på denna sida). Inkludera stdlib.h, stdio.h och stdbool.h med #include-direktivet. Ovanför main()-funktionen, skriv in följande:

bool is_number(char *str)
{
  return false;
}

bool%20is_number%28char%20%2Astr%29%0A%7B%0A%20%20return%20false%3B%0A%7D%0A

Du har nu deklarerat en funktion, is_number(), som tar emot en sträng och returnerar ett sanningsvärde – ett booleskt värde (aka “en boolean”). Funktionens kropp är just nu tom, så när som på satsen return false, vilket innebär att funktionen alltid svarar med falskt. Detta är en s.k. dummy eller stub, dvs. en funktion vars existens är explict men vars implementation ännu inte är skriven. Den innehåller bara minimalt med kod för att den skall vara legal enligt C-kompilatorn, och då är vi konservativa, dvs. ingen sträng är ett tal. Som kropp i main() kan vi skriva följande:

if (argc > 1 && is_number(argv[1]))
{
  printf("%s is a number\n", argv[1]);
}
else
{
  if (argc > 1)
  {
    printf("%s is not a number\n", argv[1]);
  }
  else
  {
    printf("Please provide a command line argument!\n");
  }
}

if%20%28argc%20%3E%201%20%26%26%20is_number%28argv%5B1%5D%29%29%0A%7B%0A%20%20printf%28%22%25s%20is%20a%20number%5Cn%22%2C%20argv%5B1%5D%29%3B%0A%7D%0Aelse%0A%7B%0A%20%20if%20%28argc%20%3E%201%29%0A%20%20%7B%0A%20%20%20%20printf%28%22%25s%20is%20not%20a%20number%5Cn%22%2C%20argv%5B1%5D%29%3B%0A%20%20%7D%0A%20%20else%0A%20%20%7B%0A%20%20%20%20printf%28%22Please%20provide%20a%20command%20line%20argument%21%5Cn%22%29%3B%0A%20%20%7D%0A%7D%0A

Pröva nu att kompilera och köra programmet:

$ gcc temp.c
$ ./a.out 42
42 is not a number
$ _

Perfekt! Nu har vi något som “fungerar” men som gör fel, och vår uppgift nu är att modifiera detta program tills det gör rätt.

Det är viktigt att alltid ha ett fungerande program så att det går att experimentera sig fram till en lösning. Så arbetar såväl nybörjade som experter – ingen tycker att det är en bra idé att skriva 10 rader kod mellan varje kompilering, även om värdet på 10 varierar mellan personer och ofta stiger något med erfarenhet med den aktuella kodbasen.

En sträng i C är en array av tecken och varje tecken representeras som ett heltal (ASCII-värdet för tecknet). Sist i en välformad sträng kommer ett s.k. “nulltecken”, som har värdet 0, och som avser att “nu är strängen slut”. Strängen "Hej" i C innehåller alltså 4 tecken: ['H', 'e', 'j', '\0'] (skrivet som en array av teckenliteraler) eller [72, 101, 106, 0] (skrivet som en array av ASCII-värden).

Ett enkelt sätt att kontrollera om en sträng är ett (hel)tal är att inspektera om varje tecken i strängen är en siffa (0-9), förutom det första tecknet som också kan vara ett minustecken -.

• Funktionen strlen() i biblioteket string.h (#include <string.h>) returnerar längden av en sträng (med eller utan nulltecknet? Utforska!)
• Funktionen isdigit() i biblioteket ctype.h testar om ett enskilt tecken är en siffra
• Implementera testet med hjälp av en loop från i=0 till längden av strängen (utan nulltecknet)
• Minns att str[42] läser ut det 43:e tecknet från arrayen str

Nu har du nog med information för att skriva programmet! När du fått det att fungera, kopiera funktionen (och import-satser) över in i p6.c och använd funktionen för att kontrollera att kommandoradsargumenten är heltal. Lägg också in en kontroll att de inte är negativa (dvs. tal >= 0). Denna kontroll skall inte ske i is_number() eftersom is_number() stöder negativa tal.

int dead_code_example()
{
  return 17; // Här avbryts funktionen
  puts("This string will never be printed"); // denna rad körs aldrig
}

int%20dead_code_example%28%29%0A%7B%0A%20%20return%2017%3B%20%2F%2F%20H%C3%A4r%20avbryts%20funktionen%0A%20%20puts%28%22This%20string%20will%20never%20be%20printed%22%29%3B%20%2F%2F%20denna%20rad%20k%C3%B6rs%20aldrig%0A%7D%0A

För dig som är tidigt färdig eller känner att du vill arbeta mer med materialet.

Här behandlas den “vita lögnen” ovan om “en typ för heltal […]”.

Hittills har vi använt typen int som en heltalsvariabel. Under programmets körning sparas en int som ett binärt tal i ett utrymme som är lika stort som ett maskinord, dvs. 32 eller 64 bitar beroende på vilken typ av dator man sitter på. Antalet bitar styr (naturligtvis) hur stora tal som ryms i variabeln. En 32-bitars int har som maxvärde 2^31-1 och minvärde -2^31.

• Hur stor är en int på datorn du sitter på? Du kan pröva detta genom att lägga till #include <limits.h> överst i filen och sedan göra printf("%d\n%d\n", INT_MIN, INT_MAX);
• En unsigned int har endast positiva värden och
• Pröva vad som händer om du sparar ett för stort tal i en heltalsvariabel! (T.ex. genom att räkna ut ett för stort tal med fib-programmet.)

Datatypen long rymmer större tal (se LONG_MAX).

I modern C använder vi ofta datatyper vars storlek är garanterad oavsett vilken plattform vi sitter på. Om du inkluderar #include <stdint.h> i dina program får du tillgång till typer som:

• int64_t ett heltal som är garanterat att vara 64 bitar stort
• uint64_t ett “unsigned” heltal som är garanterat att vara 64 bitar stort (och alltså bara sparar positiva tal)
• int8_t ett heltal som är garanterat att vara 8 bitar stort
• etc.

Liknande gäller för flyttal. Analogt med int och long finns float och double, samt ytterligare bibliotek för flyttalsberäkningar enligt olika standarder.

Från och med den här labben kommer vi att använda flaggan -Wall (show all warnings) varje gång vi kompilerar. Det berättar för kompilatorn att den ska ge varningar för fler saker än vanligt. Var vaksam om du får en varning från kompilatorn. Även om felet inte alltid ligger precis där kompilatorn varnar så betyder en varning att någonting är fel i programmet, eller borde skrivas om. Om man tar för vana att inte fixa “ofarliga varningar” kommer det att vara svårare att hitta “de farliga varningarna” i allt mummel som kompilatorn spottar ur sig. (Läs mer om att kompilera C-program här!)

Ingen människa skriver felfria program direkt. Ibland kan ett program kompilera men ändå göra fel eller krascha, och det är inte alltid lätt att hitta vad som orsakar en bugg. Ett verktyg som kan användas för att hitta buggar i ett körande program kallas för en “debugger” (på stolpig svenska kallas de ibland för “avlusare”). Program skrivna i C kan “debuggas” med programmet gdb (eller lldb om du kör på OS X).

Här finns en en kort screencast om gdb som du bör se vid tillfälle, samt en lathund som går igenom hur gdb fungerar. Om du stöter på en bugg och vill prova att använda gdb redan på den här labben kan du be en assistent om hjälp.

Fizz Buzz är en klassisk programmeringsövning som går ut på att implementera leken “Fizz Buzz” där man sitter i en ring och räknar uppåt från 1. Den som börjar börjar säger 1, och nästa person säger 2, etc. – men alla tal som är delbara med 3 ersätts med “Fizz”, alla tal som är delbara med 5 ersätts med “Buzz” och alla tal som är delbara med både 3 och 5 med “Fizz Buzz”.

Skriv ett program som räknar från 1 till ett på kommandoraden angivet tal på detta sätt:

$ gcc -Wall fizzbuzz.c
$ ./a.out 16
1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, Fizz Buzz, 16
$ _

Strukturera programmet så här:

1. En main()-funktion som läser in ett tal T som ett kommandoradsargument (se föregående labb)
2. En loop i main()-funktionen som räknar från 1 till T
3. En funktion void print_number(int num) som anropas för varje T och skriver /T_, Fizz, Buzz eller Fizz Buzz
4. Fundera på hur du skall göra för att inte ha något sista avslutande ,-tecken

Tips: i C är modulo-operatorn %, dvs. 10 % 5 = 0 och 10 % 3 = 1.

I/O – input/output – är en viktig del av många program, och ibland knepigt beroende på hur långt ned i mjukvarustacken man befinner sig. Ju närmare hårdvaran – desto lägre abstraktionsnivå erbjuds, vilket tvingar oss att tänka på fler detaljer.

Vi skall börja med att implementera en generell rutin för att ställa en fråga och läsa in ett svar i form av ett heltal. Vi kommer att göra det i ett antal delsteg som förbättrar programmet på ett antal sätt, och därigenom illustrera en vanlig programmeringsprocess.

Börja med att skapa filen ioopm/lab2/utils.c – vi skall jobba med den idag. Den skall inkludera stdio.h, som är C:s standardbibliotek för I/O-funktioner.

Nu skall vi skapa vår första header-fil! Skapa utils.h i samma katalog som utils.c och flytta dit samtliga funktionsprototyper från utils.c. I utils.h borde det nu alltså åtminstone stå:

#include <stdbool.h>
int read_string(char *buf, int buf_siz);
bool is_number(char *str);
int ask_question_int(char *question);
char *ask_question_string(char *question, char *buf, int buf_siz);

%23include%20%3Cstdbool.h%3E%0Aint%20read_string%28char%20%2Abuf%2C%20int%20buf_siz%29%3B%0Abool%20is_number%28char%20%2Astr%29%3B%0Aint%20ask_question_int%28char%20%2Aquestion%29%3B%0Achar%20%2Aask_question_string%28char%20%2Aquestion%2C%20char%20%2Abuf%2C%20int%20buf_siz%29%3B%0A

Som första rader i utils.h skriv

#ifndef __UTILS_H__
#define __UTILS_H__

%23ifndef%20__UTILS_H__%0A%23define%20__UTILS_H__%0A

och som sista rader skriv

#endif

%23endif%0A

(alternativt skriv bara #pragma once högst upp i utils.c!)

Vi återkommer till dessa magiska instruktioner senare. Om du är nyfiken – kolla i kurslitteraturen, sök på nätet, eller fråga en assistent!

Lägg till #include "utils.h" i utils.c – notera "..." istället för <...>.

Passa också på att ta bort main()-funktione ur utils.c. Nu har vi ett “riktigt bibliotek” som kan inkluderas av program som behöver komma åt hjälpfunktionerna.

Nu skall vi skapa programmet guess.c som använder sig av våra två ask_-funktioner. Interaktion med programmet skall se ut så här:

$ gcc -Wall guess.c
$ ./a.out
Skriv in ditt namn:
Tobias
Du Tobias, jag tänker på ett tal ... kan du gissa vilket?
0
För litet!
1000
För stort!
500!
För stort!
... (osv)
För litet!
42
Bingo!
Det tog Tobias 12 gissningar att komma fram till 42
$ _

Om man tar mer än 15 gissningar på sig skall programmet skriva ut:

...
Nu har du slut på gissningar! Jag tänkte på 42!
$ _

Programmet skall alltså:

1. Slumpa fram ett tal T (med hjälp av funktionen random() i stdlib.h)
2. Fråga efter användarens namn N
3. Skriva ut “Du N, jag tänker på ett tal kan du gissa vilket?”
4. I en loop, läsa in tal från användaren och skriva ut “För litet!” eller “För stort!” eller “Bingo!”
5. Vid bingo, skriv ut “Det tog N G gissningar att komma fram till T”
6. Om G når 15, skriva ut “Nu har du slut på gissningar! Jag tänkte på T!”

Funktionen random() i stdlib.h returnerar ett slumptal som kan vara mycket stort. För att skapa ett slumptal mellan 0 och N kan du använda modulo:

random() % 1024  // slumptal mellan 0 och 1023

random%28%29%20%25%201024%20%20%2F%2F%20slumptal%20mellan%200%20och%201023%0A

Programmet använder naturligtvis funktionerna från utils.c, utefter den beskrivning som finns i utils.h. Importera dem i guess.c så här:

#include "utils.h"

%23include%20%22utils.h%22%0A

Om när du kompilerar – ange båda källkodsfilerna:

$ gcc -Wall utils.c guess.c

Om du har glömt att ta bort main()-funktionen från utils.c kommer detta inte att fungera eftersom det då finns två main()-funktioner, vilket är tvetydigt och därför inte är tillåtet!

#include <stdlib.h>
#include <time.h>

...

srandom(time(NULL)); /// initialize randomness -- call once per program run
...
int r = rand(); /// generate a random value

%23include%20%3Cstdlib.h%3E%0A%23include%20%3Ctime.h%3E%0A%0A...%0A%0Asrandom%28time%28NULL%29%29%3B%20%2F%2F%2F%20initialize%20randomness%20--%20call%20once%20per%20program%20run%0A...%0Aint%20r%20%3D%20rand%28%29%3B%20%2F%2F%2F%20generate%20a%20random%20value%0A

För dig som är tidigt färdig eller känner att du vill arbeta mer med materialet.

Att arbeta med fler än en fil i Emacs är lämpligt att göra genom att öppna flera windows i samma Emacs-fönster (eller frame med Emacs-termer). Nedan använder jag ordet frame för det som du normalt kallar för fönster, och ordet window för en del av en frame som visar en buffer med text.

För att återskapa ovanstående split i tre windows. Gör så här efter att du startat Emacs:

1. C-x − för att dela (det aktuella) window:et horizontellt
2. C-x ∣ för att dela (det aktuella) window:et vertikalt

Navigera mellan de olika Emacs-window:arna så här: C-x ←, C-x →, C-x ↑ och C-x ↓.

Positionera dig längst ned (med kommandona ovan) och öppa utils.c med C-x C-f utils.c ↵. Positionera dig i övre vänstre window:et ned (med kommandona ovan) och öppa tmp.c med C-x C-f tmp.c ↵. Positionera dig i övre högra window:et och växla så att den visar samma buffert som någon av de andra window:arna med C-x b. Skriv sedan namnet på buffern (du kan använda tab för autocomplete) och tryck ↵.

Om du gillar att ha många filer öppna i Emacs samtidigt kan du pröva att trycka till exempel C-x C-b för att lista alla öppna buffrar. Nu kan du navigera till den buffer du vill öppna med piltangenterna och trycka enter.

Om du vill stänga window:et som du står i: C-x 0. Om du vill stänga alla andra windows utom det du står i: C-x 1.

Två anledningar till att det inte är bra att köra emacs fil.c & flera gånger i terminalen är att det startar flera instanser av Emacs och:

1. det åtgår en massa mer minne – \(N\) gånger för \(N\) instanser
2. de olika instanserna är inte medvetna om varandra – och en fil som är öppen i flera instanser kan hamna i osynk

Ovanstående gäller inte bara Emacs utan generellt. På macOS med ett grafiskt Emacs kommer emacs fil.c & att öppna ett redan körande Emacs om ett sådant finns.

Om du föredrar att ha flera separata fönster öppet på skärmen kan du använda kommandot M-x make-frame ↵ för att öppna ett nytt fönster och sedan C-x C-f som vanligt för att öppna en fil i det fönstret.

Skapa ett program str.c.

Som du säkert minns är C:s strängtyp char *. Det betyder en adress till en plats i minnet där det finns lagrat ett eller fler tecken. Det är i de flesta avseenden ekvivalent med typen char [] som avser en array av ett eller fler tecken. Strängar innehåller ingen information om hur långa de är – istället används ett speciellt tecken som ett stopptecken: det s.k. null-tecknet som skrivs '\0'.

Om vi skriver char *str = "Guy Maddin, Winnipeg"; har vi skapat en sträng vars innehåll är 21 tecken. Om vi skriver detta som en array: ['G', 'u', 'y', ' ', 'M', 'a', 'd', 'd', 'i', 'n', ',', ' ', 'W', 'i', 'n', 'n', 'i', 'p', 'e', 'g', '\0']. Det enda sättet att ta reda på hur lång en sträng är är att “loopa igenom den” och leta efter null-tecknet.

Du är bekant med rekursionsbegreppet sedan förut. Rekursion i C fungerar i stort sett likadant. I labb 1 var en extrauppgift att implementera ett program som skrev ut tal ur Fibonacci-serien på ett imperativt sätt. Nedan följer ett liknande program, som bara skriver ut det sista talet i serien och inte varenda tal på vägen dit. Målet med denna uppgift är att skriva om fib()-funktionen så att den blir rekursiv. Efter koden nedan kommer ett exempel som visar hur man kan skriva en annan imperativ funktion med rekursion.

#include <stdio.h>
#include <stdlib.h>

/// Den intressanta delen av programmet
int fib(int num)
{
  int ppf = 0; // the two given fib values
  int pf  = 1;

  for (int i = 1; i < num; ++i)
  {
    int tmp = pf;
    pf = ppf + pf;
    ppf = tmp;
  }

  return pf;
}

/// Den ointressanta main()-funktionen
int main(int argc, char *argv[])
{
  if (argc != 2)
  {
    printf("Usage: %s number\n", argv[0]);
  }
  else
  {
    int n = atoi(argv[1]);
    if (n < 2)
    {
      printf("fib(%d) = %d\n", n, n);
    }
    else
    {
      printf("fib(%s) = %d\n", argv[1], fib(n));
    }
  }
  return 0;
}

%23include%20%3Cstdio.h%3E%0A%23include%20%3Cstdlib.h%3E%0A%0A%2F%2F%2F%20Den%20intressanta%20delen%20av%20programmet%0Aint%20fib%28int%20num%29%0A%7B%0A%20%20int%20ppf%20%3D%200%3B%20%2F%2F%20the%20two%20given%20fib%20values%0A%20%20int%20pf%20%20%3D%201%3B%0A%0A%20%20for%20%28int%20i%20%3D%201%3B%20i%20%3C%20num%3B%20%2B%2Bi%29%0A%20%20%7B%0A%20%20%20%20int%20tmp%20%3D%20pf%3B%0A%20%20%20%20pf%20%3D%20ppf%20%2B%20pf%3B%0A%20%20%20%20ppf%20%3D%20tmp%3B%0A%20%20%7D%0A%0A%20%20return%20pf%3B%0A%7D%0A%0A%2F%2F%2F%20Den%20ointressanta%20main%28%29-funktionen%0Aint%20main%28int%20argc%2C%20char%20%2Aargv%5B%5D%29%0A%7B%0A%20%20if%20%28argc%20%21%3D%202%29%0A%20%20%7B%0A%20%20%20%20printf%28%22Usage%3A%20%25s%20number%5Cn%22%2C%20argv%5B0%5D%29%3B%0A%20%20%7D%0A%20%20else%0A%20%20%7B%0A%20%20%20%20int%20n%20%3D%20atoi%28argv%5B1%5D%29%3B%0A%20%20%20%20if%20%28n%20%3C%202%29%0A%20%20%20%20%7B%0A%20%20%20%20%20%20printf%28%22fib%28%25d%29%20%3D%20%25d%5Cn%22%2C%20n%2C%20n%29%3B%0A%20%20%20%20%7D%0A%20%20%20%20else%0A%20%20%20%20%7B%0A%20%20%20%20%20%20printf%28%22fib%28%25s%29%20%3D%20%25d%5Cn%22%2C%20argv%5B1%5D%2C%20fib%28n%29%29%3B%0A%20%20%20%20%7D%0A%20%20%7D%0A%20%20return%200%3B%0A%7D%0A

Pekare är som bekant adresser till platser i datorns minne där data finns lagrat. Vi har ännu inte stiftat någon djup bekantskap med dem men vi har sett att strängar i C är pekare (char *), och att vi skickat in pekare till int:ar i scanf(). Nu skall vi stifta bekantskap med pekare till funktioner. Detta motsvarar högre ordningens funktioner som du använt i Haskell, t.ex. när du skickat in en funktion och en datasamling till map.

C:s syntax för funktionspekares typer är fruktansvärd och det är därför brukligt att man skapa ett typalias – dvs. skapar ett beskrivande namn på en krånglig typ som man sedan kan använda istället för dess krångliga motsvarighet. Syntaxen för ett typalias är så här:

typedef existerande_typ nytt_namn;

typedef%20existerande_typ%20nytt_namn%3B%0A

Exempel på typalias som inte berör funktionspekare:

typedef char *string_t;
typedef unsigned int age_t;

typedef%20char%20%2Astring_t%3B%0Atypedef%20unsigned%20int%20age_t%3B%0A

Här har vi skapat två typalias: string_t kan nu användas överallt som en synonym för char * och vi har angivit att typen age_t är ett icke-negativt heltal. Suffixet _t är en namnkonvention.

Just typaliaset string_t är ett alias vi skall undvika eftersom det avviker från alla andra C-program och därför blir förvirrande för någon som läser din kod, även om string_t förmodligen har mindre kognitiv belastning än char * för en ny C-programmerare.

Låt oss nu använda typedef-nyckelordet för att definiera ett typalias för en funktion. Det är invecklat, men inte speciellt svårt när man väl har lärt sig läsa koden:

typedef int(*int_fold_func)(int, int);

typedef%20int%28%2Aint_fold_func%29%28int%2C%20int%29%3B%0A

Koden ovan definierar typen int_fold_func som en funktion som tar som argument två int:ar och returnerar en int. I Haskell skulle typen skrivas Int -> Int -> Int. Asterisken * framför namnet int_fold_func ovan är det som gör det hela till en pekare. Denna skall dock inte vara med i namnet.

Om jag har en funktion add(...) och vill skicka en pekare till den funktionen skriver jag alltså add. Funktionens namn utan parenteser och argument. Om jag skriver add(2,2) är det ju ett helt vanligt anrop till funktionen och det som skickas in är resultatet!

Nu kan vi använda int_fold_func som en datatyp och deklarara t.ex. en left fold (som du kanske minns från PKD). Om du inte minns hur en left fold fungerar – försök att räkna ut det från C-koden nedan!

/// En funktion som tar en array av heltal, arrayens längd och
/// en pekare till en funktion f av typen Int -> Int -> Int
int foldl_int_int(int numbers[], int numbers_siz, int_fold_func f)
{
  int result = 0;

  // Loopa över arrayen och för varje element e utför result = f(result, e)
  for (int i = 0; i < numbers_siz; ++i)
  {
    result = f(result, numbers[i]);
  }

  return result;
}

%2F%2F%2F%20En%20funktion%20som%20tar%20en%20array%20av%20heltal%2C%20arrayens%20l%C3%A4ngd%20och%0A%2F%2F%2F%20en%20pekare%20till%20en%20funktion%20f%20av%20typen%20Int%20-%3E%20Int%20-%3E%20Int%0Aint%20foldl_int_int%28int%20numbers%5B%5D%2C%20int%20numbers_siz%2C%20int_fold_func%20f%29%0A%7B%0A%20%20int%20result%20%3D%200%3B%0A%0A%20%20%2F%2F%20Loopa%20%C3%B6ver%20arrayen%20och%20f%C3%B6r%20varje%20element%20e%20utf%C3%B6r%20result%20%3D%20f%28result%2C%20e%29%0A%20%20for%20%28int%20i%20%3D%200%3B%20i%20%3C%20numbers_siz%3B%20%2B%2Bi%29%0A%20%20%7B%0A%20%20%20%20result%20%3D%20f%28result%2C%20numbers%5Bi%5D%29%3B%0A%20%20%7D%0A%0A%20%20return%20result%3B%0A%7D%0A

Låt oss skriva en funktion som adderar två tal:

int add(int a, int b)
{
  return a + b;
}

int%20add%28int%20a%2C%20int%20b%29%0A%7B%0A%20%20return%20a%20%2B%20b%3B%0A%7D%0A

Eftersom add() är en funktion av typen Int -> Int -> Int kan den användas tillsammans med foldl_int_int. För att skicka med en funktion som en parameter skriver du bara funktionens namn, i detta fall alltså add.

Uppgift: Skriv om sum()-funktionen ovan med hjälp av foldl_int_int() och add(). Du behöver inte ändra i vare sig foldl_int_int() eller add().

Skapa en ny fil med ett lämpligt namn, t.ex. experiment.c med en tom main()-funktion. Skriv all kod för denna uppgift här, kompilera ofta och fundera på hur du kan skriva kod i main()-funktionen som testar/kör den kod som du skriver. Vi kommer att vilja använda kod som du har skrivit tidigare. Välj själv om du vill inkludera utils.h och kompilera med gcc experiment.c utils.c eller om du vill kopiera in all kod som behövs i experiment.c.

Med hjälp av funktionspekare skall vi nu skriva en generell inläsningsrutin som ger ytterligare abstraktion vid inläsning. Den fångar det generella mönstret för inläsning:

1. Skriv ut frågan (t.ex. “mata in ett tal”)
2. Läser in svaret
3. Kontrollerar att svaret är på rätt format (t.ex. att det är ett tal) och går tillbaka till 1. igen vid behov
4. Konverterar det till rätt format (t.ex. från "42" till 42)
5. Returnerar resultatet

För att göra detta skall vår nya ask_question()-funktion ha tre parametrar:

1. Frågan i form av en sträng (char *)
2. En pekare till en funktion som kontrollerar att svaret har rätt format
3. En pekare till en funktion som konverterar en sträng till något annat format

Typen på kontrollfunktionen skall vara char * -> bool, dvs. den tar emot en sträng och returnerar sant eller falskt.

Typen på konverteringsfunktionen skall vara char * -> answer_t – vilket introducerar en ny typ som vi ännu inte har sätt, nämligen typen answer_t som är en s.k. union:

typedef union { 
  int   int_value;
  float float_value;
  char *string_value;
} answer_t;

typedef%20union%20%7B%20%0A%20%20int%20%20%20int_value%3B%0A%20%20float%20float_value%3B%0A%20%20char%20%2Astring_value%3B%0A%7D%20answer_t%3B%0A

Typen answer_t avser ett värde som antingen är en int eller_ en float /eller en sträng (char *). Om val är en variabel av typen answer_t så kan jag tilldela den ett heltal via val.int_value = 42 och läsa det på motsvarande sätt ... = val.int_value, eller en sträng via val.string_value = ... och ... = val.string_value. Namnen int_value, float_valu och string_value har jag valt i min definition av answer_t och kan bytas ut mot andra namn om man så önskar.

Uppgift! Använd typedef för att definiera typerna check_func och convert_func med typerna ovan. Utgå från exemplet från int_fold_func.

Ett exempel på en kontrollfunktion är den is_number() som du redan skrivit (labb 1) och som tar in en sträng och returnerar true eller false beroende på om strängen kan konverteras till ett tal. En kontrollfunktion som kontrollerar att en sträng inte är tom kan se ut så här:

/// Hjälpfunktion till ask_question_string
bool not_empty(char *str)
{
  if (strlen(str) > 0)
  {
    return true;
  }
  else
  {
    return false;
  }
}

%2F%2F%2F%20Hj%C3%A4lpfunktion%20till%20ask_question_string%0Abool%20not_empty%28char%20%2Astr%29%0A%7B%0A%20%20if%20%28strlen%28str%29%20%3E%200%29%0A%20%20%7B%0A%20%20%20%20return%20true%3B%0A%20%20%7D%0A%20%20else%0A%20%20%7B%0A%20%20%20%20return%20false%3B%0A%20%20%7D%0A%7D%0A

Eller, mer kompakt och bättre:

/// Hjälpfunktion till ask_question_string
bool not_empty(char *str)
{
  return strlen(str) > 0;
}

%2F%2F%2F%20Hj%C3%A4lpfunktion%20till%20ask_question_string%0Abool%20not_empty%28char%20%2Astr%29%0A%7B%0A%20%20return%20strlen%28str%29%20%3E%200%3B%0A%7D%0A

Ett exempel på en funktion som går att använda som konverteringsfunktion är funktionen atoi() som vi har använt förut. Den fungerar eftersom atoi() returnerar ett heltal som så att säga är en delmängd av answer_t.

Dock: Om man försöker skicka in atoi som argument till en funktion vars motsvarande parameter är convert_func kommer kompilatorn att klaga eftersom answer_t och int inte är samma typ. Det kan man lösa med hjälp av en typomvandling (eng. type cast):

atoi                     // har typen char * -> int
(convert_func) atoi      // har typen char * -> answer_t

Uppgift! Nu är det dags att skriva funktionen ask_question() med signaturen:

answer_t ask_question(char *question, check_func check, convert_func convert)

answer_t%20ask_question%28char%20%2Aquestion%2C%20check_func%20check%2C%20convert_func%20convert%29%0A

Inuti denna funktion avser variablerna check och convert funktioner som kan anropas check(str) etc.

1. Skapa en buffert av lämplig längd
2. I en loop
   • skriv ut frågan
   • läs in en sträng med din egen read_string()-funktion
   • Använd check för att kontrollera att det du läst in är korrekt och terminera loopen
3. Använd convert för att konvertera resultatet och returnera det

Med hjälp av din generella ask_question()-funktion är det nu busenkelt att definiera nya. T.ex. kan vi definiera ask_question_int() så här:

int ask_question_int(char *question)
{
  answer_t answer = ask_question(question, is_number, (convert_func) atoi);
  return answer.int_value; // svaret som ett heltal
}

int%20ask_question_int%28char%20%2Aquestion%29%0A%7B%0A%20%20answer_t%20answer%20%3D%20ask_question%28question%2C%20is_number%2C%20%28convert_func%29%20atoi%29%3B%0A%20%20return%20answer.int_value%3B%20%2F%2F%20svaret%20som%20ett%20heltal%0A%7D%0A

Om du har skrivit en is_float() på en tidigare labb kan du använda den för att definiera ask_question_float(). Dock – för att göra detta måste vi skapa en funktion som skapar ett answer_t från en double:

answer_t make_float(char *str)
{
  answer_t a;                // skapa ett oinitierat answer_t-värde
  a.float_value = atof(str); // gör det till en float, via atof
  return a;                  // returnera värdet
}

answer_t%20make_float%28char%20%2Astr%29%0A%7B%0A%20%20answer_t%20a%3B%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%2F%2F%20skapa%20ett%20oinitierat%20answer_t-v%C3%A4rde%0A%20%20a.float_value%20%3D%20atof%28str%29%3B%20%2F%2F%20g%C3%B6r%20det%20till%20en%20float%2C%20via%20atof%0A%20%20return%20a%3B%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%2F%2F%20returnera%20v%C3%A4rdet%0A%7D%0A

Eller, mer kompakt (skapar ett nytt answer_t-värde) – via en syntax som vi skall behandla i mer detalj på nästa labb:

answer_t make_float(char *str)
{
  return (answer_t) { .float_value = atof(str) };
}

answer_t%20make_float%28char%20%2Astr%29%0A%7B%0A%20%20return%20%28answer_t%29%20%7B%20.float_value%20%3D%20atof%28str%29%20%7D%3B%0A%7D%0A

Här skriver vi ask_question_float() utan den onödiga variabeln answer bara för att visa att det också är möjligt (notera .float_value på slutet!).

double ask_question_float(char *question)
{
  return ask_question(question, is_float, make_float).float_value;
}

double%20ask_question_float%28char%20%2Aquestion%29%0A%7B%0A%20%20return%20ask_question%28question%2C%20is_float%2C%20make_float%29.float_value%3B%0A%7D%0A

För att göra ask_question_string() måste vi tyvärr gå händelserna i förväg en aning och använda en funktion, strdup() vars funktion är svårt att förklara med den begränsade del av C som vi har tittat på hittills. Den inlästa strängen i din ask_question() är ju redan en sträng, så man kan tycka att man kunde returnera den rakt av, men så är inte fallet!

Skriv så här längst upp i filen så länge. Senare kommer vi att skriva en egen version av denna kod:

extern char *strdup(const char *);

extern%20char%20%2Astrdup%28const%20char%20%2A%29%3B%0A

Det är nämligen så att din inläsningsbuffert (iallafall om du har använt en array, som är det enda vi gått igenom hittills) är knuten till den omslutande funktionen – och efter att funktionen är klar kan minnet där texten lästes in komma att återanvändas när som helst. Vi måste därför skapa en kopia av strängen som är fri att skickas vart som helst. Detta görs med hjälp av funktionen strdup() som finns i string.h och som duplicerar en sträng. Exemplet nedan skapar en kopia och skriver ut både kopian och originalet:

char *original = "foo bar baz!"
char *kopia = strdup(original);
printf("%s\n%s\n", original, kopia);

char%20%2Aoriginal%20%3D%20%22foo%20bar%20baz%21%22%0Achar%20%2Akopia%20%3D%20strdup%28original%29%3B%0Aprintf%28%22%25s%5Cn%25s%5Cn%22%2C%20original%2C%20kopia%29%3B%0A

Nu kan vi skriva klar ask_question_string() så här:

char *ask_question_string(char *question)
{
  return ask_question(question, not_empty, (convert_func) strdup).string_value;
}

char%20%2Aask_question_string%28char%20%2Aquestion%29%0A%7B%0A%20%20return%20ask_question%28question%2C%20not_empty%2C%20%28convert_func%29%20strdup%29.string_value%3B%0A%7D%0A

Nu är det dags att uppdatera det generella biblioteket utils. Kopiera in dina funktioner och typalias dit. Där bör nu ligga följande funktioner (åtminstone), i någon ordning:

• Typen answer_t
• Typen check_func
• Typen convert_func
• Deklarationen extern char *strdup(const char *);
• int read_string(char *buf, int buf_siz)
• bool is_number(char *str)
• bool is_float(char *str) och answer_t make_float(char *) (inte obligatoriska)
• bool not_empty(char *str)
• answer_t ask_question(char *question, check_func check, convert_func convert)
• char *ask_question_string(char *question)
• int ask_question_int(char *question)
• double ask_question_float(char *question) (inte obligatorisk)

Själva definitionen av funktionerna (med koden i) skall ligga i utils.c. Funktionsprototyperna (t.ex. bool is_number(char *str);), extern... samt typedef:arna skall ligga i utils.h.

Senare under kursen skall vi diskutera mer ingående hur man skapar bibliotek/moduler, placering av funktioner och definitioner, inkapsling och synlighet.

Om du har gjort allt rätt kan du kompilera om ditt Gissa Talet-program från föregående labb mot ditt nya utils-bibliotek:

$ gcc -Wall utils.c guess.c

Du borde inte få några varningar vid kompilering (såvida du inte fick det förut – vilket du inte borde ha gjort!) och om du kör programmet igen skall det fungera precis som förut.

Verifiera att så är fallet och fixa till eventuella buggar!

Fråga: Vad skriver detta program ut på skärmen när det körs?

1. 7, 42
2. 42, 7
3. Något annat

#include <stdio.h>

void swap(int a, int b)
{
  int tmp = a;
  a = b;
  b = tmp;
}

int main(void)
{
  int x = 7;
  int y = 42;
  swap(x, y);
  printf("%d, %d\n", x, y);
  return 0;
}

%23include%20%3Cstdio.h%3E%0A%0Avoid%20swap%28int%20a%2C%20int%20b%29%0A%7B%0A%20%20int%20tmp%20%3D%20a%3B%0A%20%20a%20%3D%20b%3B%0A%20%20b%20%3D%20tmp%3B%0A%7D%0A%0Aint%20main%28void%29%0A%7B%0A%20%20int%20x%20%3D%207%3B%0A%20%20int%20y%20%3D%2042%3B%0A%20%20swap%28x%2C%20y%29%3B%0A%20%20printf%28%22%25d%2C%20%25d%5Cn%22%2C%20x%2C%20y%29%3B%0A%20%20return%200%3B%0A%7D%0A

Om det råder minsta tvekan – kör programmet!

Programmet exemplifierar värdesemantik, dvs. att vid anrop överförs argumentens värde genom kopiering. a och b i swap() har samma värde som x respektive y initialt, men förändringar av a och b påverkar inte x och y.

Namnet swap() i programmet ovan är misledande – det antyder något som i programmet ovan inte stämmer. Nu skall vi skriva om swap() så att det använder pekare istället. Det påverkar typerna:

int  a  // a är en variabel som innehåller ett heltal
int *b  // b är en variabel som innehåller en adress till en plats i minnet där det finns ett heltal

int%20%20a%20%20%2F%2F%20a%20%C3%A4r%20en%20variabel%20som%20inneh%C3%A5ller%20ett%20heltal%0Aint%20%2Ab%20%20%2F%2F%20b%20%C3%A4r%20en%20variabel%20som%20inneh%C3%A5ller%20en%20adress%20till%20en%20plats%20i%20minnet%20d%C3%A4r%20det%20finns%20ett%20heltal%0A

Variabeln b ovan innehåller alltså en adress. För att komma åt det heltal som ligger på den adressen skriver vi *b. Vi säger att vi avrefererar b. Vi har tidigare sett adresstagningsoperatorn & som vi kan använda för att få platsen i minnet där något data finns. Vi kan t.ex. skriva &a för att avse platsen där a:s värde finns lagrat. Om a och b är deklarerade enligt ovan kan vi skriva:

a = 42;  // a innehåller nu heltalet 42
b = &a;  // b innehåller nu en adress till där värdet på a finns lagrat
printf("%d, %d\n", a, *b);  // skriver ut 42, 42
a = 7;
printf("%d, %d\n", a, *b);  // skriver ut 7, 7
*b = 42;
printf("%d, %d\n", a, *b);  // skriver ut 42, 42

a%20%3D%2042%3B%20%20%2F%2F%20a%20inneh%C3%A5ller%20nu%20heltalet%2042%0Ab%20%3D%20%26a%3B%20%20%2F%2F%20b%20inneh%C3%A5ller%20nu%20en%20adress%20till%20d%C3%A4r%20v%C3%A4rdet%20p%C3%A5%20a%20finns%20lagrat%0Aprintf%28%22%25d%2C%20%25d%5Cn%22%2C%20a%2C%20%2Ab%29%3B%20%20%2F%2F%20skriver%20ut%2042%2C%2042%0Aa%20%3D%207%3B%0Aprintf%28%22%25d%2C%20%25d%5Cn%22%2C%20a%2C%20%2Ab%29%3B%20%20%2F%2F%20skriver%20ut%207%2C%207%0A%2Ab%20%3D%2042%3B%0Aprintf%28%22%25d%2C%20%25d%5Cn%22%2C%20a%2C%20%2Ab%29%3B%20%20%2F%2F%20skriver%20ut%2042%2C%2042%0A

Med hjälp av pekartypen int *, adresstagningsoperatorn & och avrefereringsoperatorn * kan vi nu skriva om swap() så att funktionen tar in två pekare (aka adresser) till heltal, och byter plats på värdena som finns lagrade på dessa två platser. Målet är att skriva om Program 1 ovan så att 42, 7 skrivs ut när det körs.

Ledning:

1. Signaturen för swap() skall vara void swap(int *a, int *b)
2. Du kommer att använda avrefereringsoperatorn i implementationen av swap()
3. Du måste använda adresstagningsoperatorn i main() för att kunna anropa swap() (detta är enda ändringen du skall göra i main())

Vi har sett att C:s strängtyp är char * och att en sträng är en array av tecken. Ovan såg vi att int * betyder pekare till en int. Hur kan en sträng vara både en pekare och en array? Är inte det typvidrigt?

Skillnaden mellan arrayer och pekare i C är extremt liten, och tillsvidare kan vi betrakta pekare och arrayer som samma sak.

Typerna t * och t[] är i regel utbytbara, för varje typ t. Det betyder t.ex. att char *argv[] också kan skrivas char **argv. Ovan sade vi att int * betyder en pekare till en plats i minnet där det finns ett heltal. Det var en vit lögn – det borde vara “där det finns ett eller flera heltal.”

Arrayer i C överförs med pekare, dvs. när man skickar en array från en funktion till en annan skickas inte en kopia av arrayen utan bara själva adressen till den. Att det är så är inte så konstigt om man betänker att arrayer i C inte känner till sin egen längd (jmf. strängar vars längd vi måste räkna ut genom att räkna antal tecken fram till '\0'). C kan alltså inte själv räkna ut hur många bytes som skall kopieras när man kopierar en array, så det enda alternativ som återstår är att överföra pekaren istället.

Pekararitmetik är aritmetik som innefattar adresser. Om a har typen int * pekar a på ett heltal och a + 1 på “nästa heltal”. Uttrycket a + 1 skapar en ny adress från adressen i a. Observera att a + 1 alltid kan beräknas, oavsett om det finns något “nästa heltal” eller inte – analogt med att C inte vet längden på en array och därmed inte kan förhindra åtkomst till element 26 i en array med bara 20 element. Det är helt enkelt något som programmeraren måste sköta själv!

Många program som manipulerar arrayer kan skrivas om på ett kortare sätt med pekararitmetik. Här är t.ex. funktionen string_copy() som kopierar en sträng till en annan (kopierar alla tecken från en array av tecken till en annan):

void string_copy(char *source, char *dest)
{
  while (*dst++ = *source++) ;
}

void%20string_copy%28char%20%2Asource%2C%20char%20%2Adest%29%0A%7B%0A%20%20while%20%28%2Adst%2B%2B%20%3D%20%2Asource%2B%2B%29%20%3B%0A%7D%0A

En bättre (mer lättläst) version:

void string_copy(char *source, char *dest)
{
  while (*source)
  {
    *dest = *source;
    ++dest;
    ++source;
  }
}

void%20string_copy%28char%20%2Asource%2C%20char%20%2Adest%29%0A%7B%0A%20%20while%20%28%2Asource%29%0A%20%20%7B%0A%20%20%20%20%2Adest%20%3D%20%2Asource%3B%0A%20%20%20%20%2B%2Bdest%3B%0A%20%20%20%20%2B%2Bsource%3B%0A%20%20%7D%0A%7D%0A

Eller med en for-loop (där iterationsvillkoret har blivit tydligare):

void string_copy(char *source, char *dest)
{
  for (; *source != '\0'; ++dest, ++source)
  {
    *dest = *source;
  }
}

void%20string_copy%28char%20%2Asource%2C%20char%20%2Adest%29%0A%7B%0A%20%20for%20%28%3B%20%2Asource%20%21%3D%20%27%5C0%27%3B%20%2B%2Bdest%2C%20%2B%2Bsource%29%0A%20%20%7B%0A%20%20%20%20%2Adest%20%3D%20%2Asource%3B%0A%20%20%7D%0A%7D%0A

För att illustrera pekararitmetik ytterligare kan vi skriva om string_length() från labb 3 så här:

int string_length(char *str)
{
  char *end = str;
  while (*end != '\0') ++end;
  return end - str;
}

int%20string_length%28char%20%2Astr%29%0A%7B%0A%20%20char%20%2Aend%20%3D%20str%3B%0A%20%20while%20%28%2Aend%20%21%3D%20%27%5C0%27%29%20%2B%2Bend%3B%0A%20%20return%20end%20-%20str%3B%0A%7D%0A

Förklaring:

1. end pekar från början på starten av strängen, precis som str
2. Så länge som tecknet som end pekar på (dvs. *end) inte är '\0', flytta end-pekaren till nästa tecken
3. Längden på strängen är “avståndet” mellan end och str när end pekar på strängens nulltecken

void print(char *str)
{
   ...
}

void%20print%28char%20%2Astr%29%0A%7B%0A%20%20%20...%0A%7D%0A

Använd str som en pekare och använd inte array-indexering (alltså inte str[12]).

Ledning: Vi kan implementera trim()-funktionen från labb 3 på motsvarande sätt:

char *trim(char *str)
{
  char *start = str;
  char *end = start + strlen(str)-1;

  while (isspace(*start)) ++start;
  while (isspace(*end)) --end;

  char *cursor = str;
  for (; start <= end; ++start, ++cursor)
    {
      *cursor = *start;
    }
  *cursor = '\0';

  return str;
}

char%20%2Atrim%28char%20%2Astr%29%0A%7B%0A%20%20char%20%2Astart%20%3D%20str%3B%0A%20%20char%20%2Aend%20%3D%20start%20%2B%20strlen%28str%29-1%3B%0A%0A%20%20while%20%28isspace%28%2Astart%29%29%20%2B%2Bstart%3B%0A%20%20while%20%28isspace%28%2Aend%29%29%20--end%3B%0A%0A%20%20char%20%2Acursor%20%3D%20str%3B%0A%20%20for%20%28%3B%20start%20%3C%3D%20end%3B%20%2B%2Bstart%2C%20%2B%2Bcursor%29%0A%20%20%20%20%7B%0A%20%20%20%20%20%20%2Acursor%20%3D%20%2Astart%3B%0A%20%20%20%20%7D%0A%20%20%2Acursor%20%3D%20%27%5C0%27%3B%0A%0A%20%20return%20str%3B%0A%7D%0A

Struktar är grupperingar av värden. En strukt-deklaration skapar en ny typ som kan användas i ett C-program.

En strukt deklareras precis som en union men använder nyckelordet strukt istället:

struct point
{
  int x;
  int y;
};

struct%20point%0A%7B%0A%20%20int%20x%3B%0A%20%20int%20y%3B%0A%7D%3B%0A

Strukten point innehåller två fält (aka poster, ibland medlemmar eller medlemsvariabler), x och y – båda av heltalstyp. Ett värde av point-typ, “en point”, grupperar alltså två värden som hör ihop, i detta fall x- och y-koordinaterna hos en punkt. På så vis kan man skicka runt en punkt mellan funktioner som ett sammanhållet värde, istället för att skicka en massa “lösa variabler”. Ponera t.ex. att du skulle vilja skapa en rektangel från två punkter – fyra koordinater. Om du inte grupperade dem som punkter måste du komma på något system för att veta vilken x-koordinat som hör ihop med vilken y-koordinat.

Den närmsta motsvarigheten till struktar i Haskell är definitionen av nya datatyper:

data Point = Point {x :: Int, y :: Int}

data%20Point%20%3D%20Point%20%7Bx%20%3A%3A%20Int%2C%20y%20%3A%3A%20Int%7D%0A

Struktar i C har värdesemantik – dvs. överförs med kopiering. Så här kan man skapa (och skriva ut) en strukt:

struct point p;
p.x = 10;
p.y = -42;

printf("point(x=%d,y=%d)\n", p.x, p.y);

struct%20point%20p%3B%0Ap.x%20%3D%2010%3B%0Ap.y%20%3D%20-42%3B%0A%0Aprintf%28%22point%28x%3D%25d%2Cy%3D%25d%29%5Cn%22%2C%20p.x%2C%20p.y%29%3B%0A

Klistra in ovanstående i ett tomt program tillsammans med struct-deklarationen av point och kör programmet. En smidig syntax för att skapa struktar med initialvärden finns – här är samma program skriven med hjälp av denna:

struct point p = { .x = 10, .y = -42};

printf("point(x=%d,y=%d)\n", p.x, p.y);

struct%20point%20p%20%3D%20%7B%20.x%20%3D%2010%2C%20.y%20%3D%20-42%7D%3B%0A%0Aprintf%28%22point%28x%3D%25d%2Cy%3D%25d%29%5Cn%22%2C%20p.x%2C%20p.y%29%3B%0A

Ofta använder man en typedef för att definiera ett typalias som inte innehåller det extra struct-nyckelordet:

typedef struct point point_t;

typedef%20struct%20point%20point_t%3B%0A

Nu är struct point och point_t synomyma och vi kan skriva vårt program så här:

point_t p = { .x = 10, .y = -42};

printf("point(x=%d,y=%d)\n", p.x, p.y);

point_t%20p%20%3D%20%7B%20.x%20%3D%2010%2C%20.y%20%3D%20-42%7D%3B%0A%0Aprintf%28%22point%28x%3D%25d%2Cy%3D%25d%29%5Cn%22%2C%20p.x%2C%20p.y%29%3B%0A

Värt att notera med { .x = 10, .y = -42 }-syntaxen är att det är tillåtet att utelämna fält som då får defaultvärden enligt följande:

1. heltalsfält får värdet 0
2. flyttalsfält får värdet 0
3. booleska fält fär värdet false
4. pekarfält får värdet NULL som betyder att de ännu inte pekar ut något – vi skall återkomma till NULL senare

Följande program är alltså legalt (kör det gärna för att verifiera att din uträkning av vad det skriver ut stämmer):

point_t p1 = { .x = 10 };
point_t p2 = { .y = -42 };
point_t p3 = { };

printf("point(x=%d,y=%d)\n", p1.x, p1.y);
printf("point(x=%d,y=%d)\n", p2.x, p2.y);
printf("point(x=%d,y=%d)\n", p3.x, p3.y);

point_t%20p1%20%3D%20%7B%20.x%20%3D%2010%20%7D%3B%0Apoint_t%20p2%20%3D%20%7B%20.y%20%3D%20-42%20%7D%3B%0Apoint_t%20p3%20%3D%20%7B%20%7D%3B%0A%0Aprintf%28%22point%28x%3D%25d%2Cy%3D%25d%29%5Cn%22%2C%20p1.x%2C%20p1.y%29%3B%0Aprintf%28%22point%28x%3D%25d%2Cy%3D%25d%29%5Cn%22%2C%20p2.x%2C%20p2.y%29%3B%0Aprintf%28%22point%28x%3D%25d%2Cy%3D%25d%29%5Cn%22%2C%20p3.x%2C%20p3.y%29%3B%0A

Eftersom struktar har värdesemantik tar följande funktion för att flytta en punkt i planet in två struktar och skapar en ny, flyttad punkt, som returneras:

struct point translate(point_t p1, point_t p2)
{
  p1.x += p2.x;
  p1.y += p2.y;
  return p1;
}

struct%20point%20translate%28point_t%20p1%2C%20point_t%20p2%29%0A%7B%0A%20%20p1.x%20%2B%3D%20p2.x%3B%0A%20%20p1.y%20%2B%3D%20p2.y%3B%0A%20%20return%20p1%3B%0A%7D%0A

Om vi vill skriva om translate() så att den punkt som skickas in förändras (en så-kallad sido-effekt) kan vi göra det med hjälp av pekare:

void translate(point_t *p1, point_t *p2)
{
  p1->x += p2->x;
  p1->y += p2->y;
}

void%20translate%28point_t%20%2Ap1%2C%20point_t%20%2Ap2%29%0A%7B%0A%20%20p1-%3Ex%20%2B%3D%20p2-%3Ex%3B%0A%20%20p1-%3Ey%20%2B%3D%20p2-%3Ey%3B%0A%7D%0A

Observera att .-notationen för att komma åt fält i en strukt byts ut mot pilar -> när man gör åtkomst till fält i en pekare till en strukt.

En anledning till pilnotationen är för att förtydliga att vi inte vet så mycket om värdet vars fält vi läser och skriver. I den sista implementationen av translate() är det t.ex. möjligt att anropa translate med samma argument två gånger:

point_t p = { .x = 10, .y = 7 };
translate(&p, &p);

point_t%20p%20%3D%20%7B%20.x%20%3D%2010%2C%20.y%20%3D%207%20%7D%3B%0Atranslate%28%26p%2C%20%26p%29%3B%0A

(observera &p eftersom funktionen vill ha adressen till där punkten finns, inte en kopia av själva punkten).

Om translate anropas med samma punkt som första och andra argument kommer även det andra argumentet att förändras. Det är förmodligen lite överraskande (varför skulle den det?) och detta illustrerar att pekare är kraftfulla men också knepiga att programmera med.

Börja med att skapa en ny fil geo.c med en tom main()-metod etc. Kopiera dit struktdefinitionen för punkt, samt typaliaset och den sista translate()-funktionen.

1. Skriv en funktion print_point() som tar en point_t * (pekare alltså!) som argument och skriver ut den på terminalen på formatet (x-värde,y-värde). Testa den genom att skriva ut en lämplig punkt.
2. Skriv funktionen make_point() som tar in två heltal som x- och y-koordinater och returnerar en point_t. Testa den med hjälv av print_point().
3. Definiera en strukt för rektanglar. En struct rectangle representeras som två punkter, dvs. dess övre vänstra hörn och dess nedre högra hörn.
4. Definiera ett typalias rectangle_t till struct rectangle
5. Skriv funktionen print_rect() som tar in en pekare till en rektangel och skriver ut den på terminalen på formatet rectangle(upper_left=(x,y), lower_right=(x,y)). Använd print_point() för att implementera funktionen. Ändra sedan print_point() till att skriva ut point(x,y) istället och kompilera om programmet och se att förändringen också får genomslagskraft i definitionen av print_rect().
6. Skriv funktionen make_rect() som tar in fyra heltal och utifrån dem skapar en rektangel. Testa den med hjälp av print_rect().
7. Skriv funktionen area_rect() som tar in en pekare till en rektangel och räknar ut dess area (dvs. basen * höjden). Testa den på några enkla exempel vars areor du enkelt kan räkna ut själv.
8. Skriv funktionen intersects_rect() som tar in två pekare till rektanglar och returnerar true om det finns minst en punkt i planet som finns i båda rektanglarna, annars false. Testa den med både negativa och positiva exempel, alltså både med rektanglar som överlappar och rektanglar som inte gör det.
9. Skriv funktionen intersection_rect() som tar in två pekare till rektanglar R1 och R2 och returnerar en ny rektangel (med värdesemantik) som är den minsta rektangel som innefattar alla punkter som som finns i både R1 och R2. Testa den med de positiva exemplen från föregående fråga.
10. Frivillig Definiera en strukt för cirklar med en point_t som mittpunkt och ett heltal som radie.
11. Frivillig Definiera ett typalias circle_t för cirklar.
12. Frivillig Definiera en print_circle() som skriver ut circle(center=point(x,y), radius=r).
13. Frivillig Definiera en make_circle().
14. Frivillig Definiera en area_circle() som räknar ut arean på en cirkel som \(\pi \cdot{} r^2\) (där \(r\) = radie). Du kan använda lämpliga funktioner och konstanter i math.h för att lösa uppgiften. Returtypen på area_circle() skall vara ett flyttal.

Detta program skall skrivas i filen db.c. Du kommer att kunna återanvända delar av detta program i en inlämningsuppgift senare på kursen!

En vara har ett namn, en beskrivning, ett pris och en lagerhylla som avser platsen där den är lagrad.

• Namn och beskrivning skall vara strängar (char *)
• Pris skall vara i ören och är därför ett heltal (int)
• Lagerhylla skall vara en bokstav åtföljd av en eller flera siffror t.ex. A25 men inte A 25 eller 25A (en möjlig datatyp för detta är t.ex. char * – det tillåter lagerhyllor som inte följer formatet, så kontrollen att endast valida lagerhyllor finns i varor måste ske någon annanstans!)

Nedan följer en version av programmet cat som läser en fil och skriver ut filen på terminalen (stdout). Programmet är väldigt likt passthrough.c ovan – med skillnaden att vi vill öppna en namngiven fil, inte stdin:

/// cat.c
#include <stdio.h>

void cat(char *filename)
{
  FILE *f = fopen(filename, "r");
  int c = fgetc(f);

  while (c != EOF)
  {
    fputc(c, stdout);
    c = fgetc(f);
  }

  fclose(f);
}

int main(int argc, char *argv[])
{
  if (argc < 2)
  {
    fprintf(stdout, "Usage: %s fil1 ...\n", argv[0]);
  }
  else
  {
    for (int i = 1; i < argc; ++i)
    {
      cat(argv[i]);
    }
  }

  return 0;
}

%2F%2F%2F%20cat.c%0A%23include%20%3Cstdio.h%3E%0A%0Avoid%20cat%28char%20%2Afilename%29%0A%7B%0A%20%20FILE%20%2Af%20%3D%20fopen%28filename%2C%20%22r%22%29%3B%0A%20%20int%20c%20%3D%20fgetc%28f%29%3B%0A%0A%20%20while%20%28c%20%21%3D%20EOF%29%0A%20%20%7B%0A%20%20%20%20fputc%28c%2C%20stdout%29%3B%0A%20%20%20%20c%20%3D%20fgetc%28f%29%3B%0A%20%20%7D%0A%0A%20%20fclose%28f%29%3B%0A%7D%0A%0Aint%20main%28int%20argc%2C%20char%20%2Aargv%5B%5D%29%0A%7B%0A%20%20if%20%28argc%20%3C%202%29%0A%20%20%7B%0A%20%20%20%20fprintf%28stdout%2C%20%22Usage%3A%20%25s%20fil1%20...%5Cn%22%2C%20argv%5B0%5D%29%3B%0A%20%20%7D%0A%20%20else%0A%20%20%7B%0A%20%20%20%20for%20%28int%20i%20%3D%201%3B%20i%20%3C%20argc%3B%20%2B%2Bi%29%0A%20%20%20%20%7B%0A%20%20%20%20%20%20cat%28argv%5Bi%5D%29%3B%0A%20%20%20%20%7D%0A%20%20%7D%0A%0A%20%20return%200%3B%0A%7D%0A

(observera att detta program inte fungerar så bra om vi anger filer som inte finns – men det är inget du behöver fixa.)

Titta på programmet ovan: i funktionen cat() läser vi infilen tecken för tecken. Nu vill vi skriva ut filen så att varje rad börjar med ett radnummer. Här är ett exempel från texten i labben:

1   Titta på programmet ovan: ...
2   tecken för tecken. Nu vill ...
3   börjar med ett radnummer ...

Uppvärmning: Frivilliga utökningar av cat

1. Utöka programmet så att när flera filer skrivs ut (stöds redan) börjar radräknaren inte om från 0 vid varje ny fil
2. Innan varje fil skrivs ut, skriv ut ==== filnamn.ext ==== i terminalen
3. Skriv om cat.c till cp.c och låt programmet kopiera från en fil till en annan, tecken för tecken, analogt med programmet cp

Nu skall vi avsluta vår implementation av databasprogrammet. I en senare inlämningsuppgift skall vi utöka databasen med stöd för att spara och ladda databasen på fil med hjälp av funktionerna ovan (och andra), men det är lite för tidigt ännu. Istället skall vi utöka programmet med en interaktiv meny, och stöd för insättning och borttagning.