Kursmaterial för laborationer i

Transkript

1 Kursmaterial för laborationer i PRAG / PROG-I / PROG-C / PROG-D TDDB 18 / TDDB 22 / TDDB 80 / TDDB 81 Sammanställt av Torbjörn Jonsson

2

3 INNEHÅLL Allmänt om Ada-laborationerna 1 De olika laborationerna: Lab0: Mycket grundläggande in- och utmatning 3 Lab1: Enkel in- och utmatning 7 Lab2: Enkla underprogram 11 Lab3: Fälthantering 13 Lab4: Posthantering och ett enkelt paket 15 Lab5: Enkel listhantering 19 Lab6: Hantering av poster och externa filer 23 Lab7: Nätverk och processer 25

4

5 Tekniska Högskolan i Linköping Institutionen för Datavetenskap (IDA) Torbjörn Jonsson Förberedelser Allmänt om Ada-laborationerna Innan varje laborationstillfälle ska tillräckligt förarbete gjorts så att du kan använda tiden på laborationstillfället till inskrivning och provkörning av laborationsuppgiften. Att gå helt oförberedd till en programmeringslaboration är fullständigt meningslöst och resulterar oundvikligen i att man sitter och stirrar blint på ett rörigt program som det aldrig tycks bli någon ordning på! Är man däremot väl förberedd innan laborationen så sparar man garanterat mycket tid, hur tröstlöst förberedelsearbetet än verkar! Det är alltid bra att ha med sig behövliga manualer och någon Ada-bok till datorlaborationerna. Redovisning och Examination För samtliga laborationsuppgifter gäller att de ska redovisas enligt instruktioner i kursinformationen. Om det är så att du arbetar på den fria tiden och ingen assistent finns närvarande får du givetvis själv avgöra om det är värt att fortsätta med nästa deluppgift. Det kan ju hända att assistenten har synpunkter som gör att du får göra om delar av nästa uppgift såväl som den deluppgift som inte är riktigt bra. Generella saker är att de laborationer som skall redovisas skriftligt skall lämnas in i så kallade IDAomslag. Dessa omslag finns vid skrivarna (ett ihopvikt A3 med rutor för era data). Vid komplettering skall de tidigare inlämnade versionerna lämnas tillsammans med det nya. Detta för att hanteringen skall gå fortare och på detta sätt får ni tillbaka laborationerna snabbare. Tid För Ada-laborationerna finns ett antal timmar avsatta och du kommer att behöva den tiden till att programmera och skriva in din kod. Det kan också bli nödvändigt att nyttja den fria (obokningsbara) tiden i laborationslokalerna, d.v.s på vardagarna samt helger. Vilka tider som är anslagna till respektive laboration och när det är reservtider står i kursinformationen eller också kan assistenten delge dig detta. Tips Om du vill hitta var i ett program ett fel uppstår kan du använda dig av spårutskrifter. En spårutskrift är en vanlig utskrift av någon text eller kanske några data som visar var du är i programmet (eller skriver ut värden på variabler). Om utskriften inte dyker upp så är det nog så att du inte har fått programmet att komma till den punkt där utskriften står. Sida 1

6 Sida 2

7 Tekniska Högskolan i Linköping Institutionen för Datavetenskap (IDA) Torbjörn Jonsson Mål Mycket grundläggande in- och utmatning I denna inledande laboration kommer du att öva på de mest grundläggande operationerna för in- och utmatning. Du ska efter denna laboration ha god insikt i skillnaden mellan Get och Put samt New_Line och Skip_Line skillnader och likheter mellan de olika varianterna av Get och Put skillnaden i beteende vid olika inmatningar till Get_Line Uppgift Skriv ett program som hämtar data från tangentbordet enligt exemplen som följer. Det som syns på skärmen när man kör programmet skall stämma till fullo överens med det som står i exemplen. Detta gäller även antal blanktecken mellan ord och tal. Observera att denna laboration till stor del är till för att introducera er till hur man hanterar vår datormiljö vad det gäller skrivande, kompilerande och körande av program. Om ni inte hinner med allt på laborationstiden är det ingen katastrof. Fortsätt på egen tid med resterande delar så att målen med uppgiften är uppfyllda. På kurshemsidan finns en fil som ni kan hämta med ett litet programskelett som innehåller alla texter som programmet skall skriva ut på skärmen. Detta för att ni skall slippa skriva en massa ren text och på så sätt kunna koncentrera er på hur Get/Get_Line/Put/Put_Line/New_Line och Skip_Line fungerar. Ett tips kan vara att ni gör en liten del i taget och ser till att den fungerar för båda de givna körexemplen (se följande sidor). På detta sätt undviker ni att få alla fel på en gång. Sida 3

8 Programkörningar Programmet ska ge resultat enligt följande exempel vid olika körningar (användarens indata markeras med kursiverad stil). Observera att eventuella inmatningar som är extra skall plockas bort innan nästa inmatning görs. Observera att du i ditt program endast får ha en variabel av respektive datatyp (det får alltså inte finnas t.ex. två stycken strängar). Det blir alltså bara fyra variabler i programmet. Exempel 1: Skriv in ett heltal: 10 Du skrev in talet: 10 Skriv in två heltal: Du skrev in talen: Skriv in ett flyttal: Du skrev in flyttalet: Skriv in ett heltal och ett flyttal: Du skrev in heltalet: 67 Du skrev in flyttalet: Skriv in ett tecken: T Du skrev in tecknet: T Skriv in en sträng med 5 tecken: Kalle Du skrev in strängen: Kalle Nästa inmatning skall lagras i samma sträng som den föregående. Skriv in en sträng med 3 tecken: Kul Du skrev in strängen: Kul Skriv in ett heltal och en sträng med 5 tecken: 5 Nisse Du skrev in talet 5 och strängen Nisse. Skriv in en sträng med 3 tecken och ett flyttal: Ria 1.2 Du skrev in och Ria. Skriv in en sträng som är maximalt 5 tecken: Nysta Du skrev in strängen: Nysta Skriv in en sträng som är maximalt 5 tecken: Bä Du skrev in strängen: Bä Sida 4

9 Exempel 2: Skriv in ett heltal: Du skrev in talet: 14 Skriv in två heltal: Du skrev in talen: 0 0 Skriv in ett flyttal: 15 Du skrev in flyttalet: Skriv in ett heltal och ett flyttal: Dum text Du skrev in heltalet: 7 Du skrev in flyttalet: Skriv in ett tecken:! Du skrev in tecknet:! Skriv in en sträng med 5 tecken: #4?. Du skrev in strängen: #4?. Nästa inmatning skall lagras i samma sträng som den föregående. Skriv in en sträng med 3 tecken: HA Du skrev in strängen: HA Skriv in ett heltal och en sträng med 5 tecken: 12 Ploja Du skrev in talet 12 och strängen Ploja. Skriv in en sträng med 3 tecken och ett flyttal: Led Du skrev in och Led. Skriv in en sträng som är maximalt 5 tecken: Per är bra Du skrev in strängen: Per ä Skriv in en sträng som är maximalt 5 tecken: Bra Du skrev in strängen: Bra Sida 5

10 Sida 6

11 Tekniska Högskolan i Linköping Institutionen för Datavetenskap (IDA) Torbjörn Jonsson Mål Enkel in- och utmatning I denna inledande laboration kommer du att öva på de grundläggande styrstrukturerna för repetition och val samt enkel in- och utmatning. Du ska efter denna laboration känna till och kunna använda hur man skriver ett litet Ada-program vad tecknet ; betyder och hur det används de tre formerna av repetitionssatsen loop: loop, for och while valsatsen if läsa in tal med Get (dock utan att ta hand om de fel som kan uppstå om användaren skriver in ett heltal då programmet läser ett reellt tal eller tecken) Put för att skriva ut både heltal, reella tal och strängar både med och utan formatdirektiv. Uppgift Skriv och testa momstabellprogrammet. De övriga tre deluppgifterna är frivilliga, men ju fler av dessa du gör desto bättre grund har du att stå på inför resterande laborationskurs. För samtliga uppgifter gäller att snygga utskrifter ska åstadkommas med hjälp av formatdirektiv till Put, samt att du ska kunna motivera valet av iterationssats. I programmet ska felhantering av användarens inmatning göras. Detta ska göras så fort som felet kan upptäckas. Programmet ska ej avbrytas utan ny fråga ska ställas! Sida 7

12 Momstabell Konstruera ett program som skriver ut en momstabell. Programmet ska på terminalen fråga efter och ta som inmatning följande värden (där alla värden ska rimlighetskontrolleras!): Nedre gräns för prisintervallet Övre gräns för prisintervallet Steg i tabellen Momsprocenten (uttryckt som decimaltal i intervallet 0 till 100 %) För att få lite överblick kan det vara vettigt att börja med antagandet att användaren kommer att mata in rimliga värden och skriva ett program utan felkontroller. Programmet ska ge resultat enligt nedan vid körning (användarens indata kursiverad): Exempel 1: Första pris: Sista pris: Steg: 0.5 Momsprocent: Sida 8 Momstabell ========== Momsprocent: Pris utan moms Moms Pris med moms Exempel 2: Första pris: Sista pris: Steg: 0.3 Momsprocent: Momstabell ========== Momsprocent: Pris utan moms Moms Pris med moms OBS! Sista Pris utan moms -värdet i andra exemplet är och inte (inte heller 12.10)!

13 Befolkningsproblemet (frivillig) Befolkningen i två länder antas växa exponentiellt, dvs ökar varje år med givna bråkdelar av befolkningen vid årets början. Skriv ett program som först läser in ett årtal, folkmängden detta år för två länder A och B samt folkökningen i procent för dessa. Programmet skriver därefter ut en tabell med årtal, hur stor folkökningen varit detta år (för varje land), och folkmängd i slutet av året. Detta fortsätter tills det land med från början mindre folkmängd har erhållit en folkmängd som är större än det andra landets. Detta förutsätter att landet med den mindre folkmängden har en större tillväxtprocent än det andra (kontrollera detta när indata matats in). Programmet ska också besvara frågan När går det (från början) befolkningsmässigt mindre landet om det större? och det ska se ut enligt nedan när programmet körs (användarens indata kursiverad) Exempel:Ange startår: 1976 Ange land A:s folkmängd (i milj.): 200 Ange land A:s befolkningsökning (i %): 10.0 Ange land B:s folkmängd (i milj.): 100 Ange land B:s befolkningsökning (i %): 50.0 Årtal Ökning A Folkmängd A Ökning B Folkmängd B År 1979 har land B gått om land A i befolkning. Födelsedagsproblemet (frivillig) Beräkna sannolikheten p(n) för att bland n personer åtminstone två har samma födelsedag, samt bestäm det n för vilket p(n) är större än 0.5. Vi bortser från skottår och att nativiteten inte är jämnt fördelad över året. p(n)=1-365/365 * 364/365 * 363/ (366-n)/365 Programmet ska läsa in ett maxvärde på n (exempelvis 100) och sedan skriva ut en tabell över n och p(n) för n = 1, 2,... maxvärdet och till sist skriva ut det lägsta n-värde för vilket p(n) är större än 0.5 Kalender (frivillig) Skriv ett program som skriver ut en kalender för en månad. Utskriften ska se ut så här för en viss månad: Må Ti On To Fr Lö Sö Indata till programmet är veckodagsnumret (1-7) för första dagen i månaden och antalet dagar som månaden består av. I exemplet ovan är veckodagsnumret 4. Sida 9

14 Sida 10

15 Tekniska Högskolan i Linköping Institutionen för Datavetenskap (IDA) Torbjörn Jonsson Mål Enkla underprogram I denna laboration kommer du att bekanta dig med underprogram i Ada. I Ada finns två olika typer av underprogram, procedurer och funktioner. Du skall efter denna laboration kunna skriva underprogram i Ada. Dessutom skall du kunna välja vilken typ av underprogram som är lämplig till vad. För övrigt skall du få förståelse för parametrar och hur dessa används (både in-, ut- och in/ut-parametrar). Du skall dessutom förstå att man inte behöver ha all kod i samma fil. Uppgift 1 Du skall skriva ett program som kommunicerar med användaren via en meny. Användaren skall kunna välja mellan olika funktioner. T.ex. addera två tal, beräkna N! o.s.v. Du skall därför skriva ett antal små procedurer och funktioner som utför enkla beräkningar eller andra uppgifter. Det är meningen att du skall använda dig av parametrar för att skicka data till och från underprogrammen. När det gäller funktionerna skall du inte skicka ut något via parametrarna. Dessa är enbart till för att funktionen skall få data att arbeta med. TIPS: Det är inte säkert att du behöver börja med problem nummer 1. Det kan vara bättre att börja med problem 4. Läs igenom alla delproblemen innan du börjar programmera. Huvudprogrammet är givet och ser ut så här: -- Modulbeskrivning samt inkluderade moduler. procedure Enkla_Underprogram is -- Här skall deluppgifterna in. begin Meny; end Enkla_Underprogram; Problem 1, Funktionen N_Fakultet Du skall skriva en funktion som beräknar N! (N-fakultet) för olika N. N skickas in i funktionen som parameter (argument) och är givetvis ett heltal. Följande skelett skall följas: Modulnamn: N_Fakultet -- Beskrivning:Beräknar N!, d.v.s. 1 * 2 * 3 *... * N. -- Indata: Ett positivt heltal (N). -- Returvärde: Fakulteten av talet man fick in (N!). -- Förutsättningar:N måste vara positivt och dessutom så litet -- att resultatet kan lagras som ett heltal function N_Fakultet(N : in Integer) return Integer is begin -- Din kod. end N_Fakultet; Sida 11

16 Problem 2, Funktionen Max_Tal Du skall skriva en funktion som tar in två reella tal och som returnerar det största av dessa Modulnamn: Max_Tal -- Beskrivning:Plockar fram det största av två reella tal. Om -- det är två lika tal returneras det ena av dem. -- Indata: Två reella tal. -- Returvärde: Det största av talen. -- Förutsättningar: Problem 3, Proceduren Summera_Heltal Du skall skriva en procedur som adderar två heltal (som skickas till proceduren via två parametrar) och returnerar summan via den tredje parametern som proceduren har Modulnamn: Summera_Heltal -- Beskrivning:Summerar två heltal och returnerar summan. -- Indata: Två heltal. -- Utdata: Summan (ett heltal). -- Förutsättningar:Att talen inte genererar ett resultat som -- är större än konstanten Integer Last Problem 4, Proceduren Meny Du skall skriva en procedur som hanterar en meny. Du får givetvis dela upp proceduren i flera delar om detta är lämpligt. Du får också använda dig av underprogrammen ovan Modulnamn: Meny -- Beskrivning:Hanterar en meny där man kan välja mellan att -- addera heltal, plocka fram det största av två -- reella tal eller beräkna N! för ett valfritt N. -- All inmatning skall hanteras av proceduren -- (eller underprocedurer) I meneyn skall även ett avslutningsalternativ -- finnas. Vid avslutning skall man återvända till -- huvudprogrammet. -- Indata: Utdata: Förutsättningar: Uppgift 2 Du skall nu dela upp ditt program i flera olika delar. De delar som skall separeras från de övriga är funktionerna N_Fakultet och Max_Tal samt proceduren Summera_Heltal. Dessa skall inkluderas i ditt program, men alltså ligga på separata filer. De övriga procedurerna behöver du inte flytta bort från din huvudprogramsfil. Sida 12

17 Tekniska Högskolan i Linköping Institutionen för Datavetenskap (IDA) Torbjörn Jonsson Mål Fälthantering I denna laboration kommer vi hantera ett fält (en array) fylld med heltal på lite olika sätt. Vi kommer att behandla endimesionella och även tvådimensionella fält. Studenten skall efter denna laboration kunna hantera fältstrukturer, iterera över dessa utan risk för referens till element utanför fältet. Uppgift Uppgifterna som följer kommer att vara varianter på hur man sorterar data. Det spelar inte någon roll vilken sorteringsalgoritm ni använder, men en rekommendation är att använda Bubble Sort. Denna förklaras under föreläsning, lektion eller av assistent under labtid. OBS! Det är endast tillåtet att i underprogram använda variabler som skickas som parametrar till eller från underprogrammen samt lokala variabler. Annars fås laborationen i retur utan åtgärd. Del A: Du skall skriva ett program som genererar 20 heltal (som skall ligga i intervallet [1, 10]) och lagrar dem i ett endimensionellt fält. Därefter skall talen skrivas ut på skärmen (osorterade), sorteras i stigande ordning (det minsta talet först i fältet) och till sist skrivas ut på skärmen (ett tal per rad). För att underlätta framtida ändringar är det nödvändigt att dela upp programmet i underprogram. Lämpliga underprogram (för denna deluppgift) är Generera_Tal (en parameter, fältet med talen), Byt_Plats (två parametrar, de tal som skall byta plats), Sortera_Tal (en parameter, fältet med talen) och Skriv_Ut (en parameter, fältet med talen). Vilken typ av underprogram det skall vara får du avgöra. Välj det som är lämpligt! Det är skönt att slippa hitta på och skriva in en stor datamängd var gång programmet ska testas. För att åstadkomma den ursprungliga datamängden i fältet kan det därför vara lämpligt att använda en slumptalsfunktion. Om du inte har information om hur detta görs frågar du assistenten. Del B: Du skall nu skriva ett nytt program som genererar 40 slumptal och lagrar dem i ett fält som representerar två dimensioner (den ena dimensionen 20 och den andra 2). Detta fält representerar i programmet 20 data där varje data är två heltal (ett talpar). Lämpligt är att kopiera del A och sen modifiera den kod du redan gjort. Det kommer inte att bli (skall inte bli) speciellt stora modifieringar. Uppgiften är att först skriva ut dessa data (talparen) sedan sortera dem i stigande ordning. Talparen skall vara sorterade i första hand på det första talet och i andra hand på det andra talet. Till sist skall programmet skriva ut de sorterade talparen på skärmen (ett talpar per rad). Här följer ett exempel på utskrift av 4 sorterade talpar (i uppgiften skall det bli 20 talpar): Sida 13

18 Del C: (frivillig) Det sista programmet som skall skivas i denna laboration är en variant av high score -lista med 20 resultat och deras rank. Du skall se till att 20 resultat slumpas fram och samtidigt nollställa den rank som senare skall räknas ut. Därefter skall rank för respektive resultat beräknas. Efter detta skall resultaten (och rank) skrivas ut på skärmen osorterade och därefter sorteras (enligt nedan). Till sist skall resultaten (och rank) skrivas ut på skärmen igen. Utskriften skall se ut enligt exemplen nedan. Även här är det lämpligt att kopiera det som gjorts sen tidigare och modifiera. Det skall inte bli stora ändringar här heller gentemot t.ex. del B. De som tävlar kan optimera sina resultat på två olika sätt och resultatet för en tävlande blir ett talpar (X, Y). Antingen är man bäst på sätt X eller så är man bäst på sätt Y (det går i vissa fall att vara bäst på båda sätten samtidigt). Optimerar man X kan det hända att Y blir lidande och vice versa. När man tävlar rankas man dessutom enligt ett speciellt förfarande och detta går till på följande vis. Den rank en tävlande får är endast beroende på hur många som är bättre än honom/henne. Med bättre menas att antingen både X och Y är mindre eller att antingen X är mindre och Y är lika eller att X är lika och Y är mindre. Ranken den tävlande får är R=antal tävlande som har bättre resultat + 1. Om man antar att man har två resultat (x 1,y 1 ) och (x 2,y 2 ) så kan man uttrycka att (x 1,y 1 ) är bättre än (x 2, y 2 ) om x 1 x 2 och y 1 <y 2 eller x 1 <x 2 och y 1 y 2. Sorteringen skall ske på så sätt att man i första hand sorterar på rank och i andra hand på X-resultatet. Exempel på utskrift (med endast 4 resultat för att visa principen): Rank Resultat (före sortering) Rank Resultat (efter sortering) Ovan ser vi att (7, 3) och (8, 2) inte har några resultat som är bättre => rank 1, talparet (9, 2) är sämre än (8, 2) => rank 2 och till sist har vi (8, 3) som är sämre än både (7, 3) och (8, 2) => rank 3. Ett annat exempel på utskrift (fundera på varför det inte finns med någon med rank 2): Rank Resultat (före sortering) Rank Resultat (efter sortering) För att lagra informationen i programmet denna gång behövs ett fält med 20 x 3 tal (taltripplar kan vi kalla dem). Varje taltrippel består av resultaten (två tal) och en rank (ett tal). Sida 14

19 Tekniska Högskolan i Linköping Institutionen för Datavetenskap (IDA) Torbjörn Jonsson Mål Hantering av poster och enkla paket I denna laboration kommer du att skapa ett paket med rutiner som kan hantera ett datum. För lagring av datum används datatypen post. Du skall efter denna laboration kunna hantera poster samt skapa egna paket med rutiner som senare kan användas i ett större program. Undantag skall kunna hanteras både i och utanför paketet. Uppgift Att lagra ett datum går att göra på många olika sätt. T.ex. kan man lagra datumet som en textsträng eller som tre heltal. I denna uppgift skall du lagra datumet i en post i vilken år, månad och dag lagras som tre heltal. Uppgiften är uppdelad för att du ska undvika alltför många saker på en gång. Man bör alltid försöka dela upp stora problem i mindre. Skriv ett litet testprogram som använder dina rutiner allt eftersom du programmerar. Del A: Skapa den datatyp som skall representera ett datum enligt beskrivningen ovan. Skriv dessutom de två procedurerna Get och Put som läser in ett datum från tangentbordet respektive skriver ut ett datum på skärmen. Ett exempel på kod som skall läsa in ett datum: begin Ada.Text_IO.Put( Ange ett datum: ); Get(Date); -- Detta är anropet till din Get. end...; Inläsningen skall då se ut enligt följande (observera att inläsningen kommer att kräva en sträng för inmatningen och att du sen konverterar innehållet till tre heltal som lagras i posten): Ange ett datum: Utskriften av ett datum skall följa svensk standard, d.v.s. på formen ÅÅÅÅ-MM-DD. Ett exempel på på kod som skall skriva ut ett datum: begin Ada.Text_IO.Put( Ett datum: ); Put(Date); -- Detta är anropet till din Put. end...; Utskriften skall då bli: Ett datum: Observera att du skall skriva procedurerna Get och Put och att dessa får innehålla anrop till de redan färdigdefinerade Get och Put som finns i Ada.Text_IO. Ingen felhantering med undantag (exceptions) i denna del. Detta kommer i först i del F. Sida 15

20 Del B: Skriv funktionerna Next_Date och Previous_Date som får ett datum (t.ex ) som indata och returnerar nästa ( ) respektive föregående ( ) datum. Tänk på att det är olika antal dagar i olika månader. Du behöver inte ta hänsyn till skottår, men om du vill det så är det skottår var fjärde år. Årtalet skall vara jämnt delbart med 4 om det är skottår. Dock finns det några undantag. Det är inte skottår då årtalet är jämnt delbart med 100. Dock är det skottår om årtalet är jämnt delbart med 400. Del C: De olika procedurerna som du nu skapat skulle kunna användas i ett antal olika program och för att man på ett enkelt sätt skall kunna återanvända dessa skapar vi ett paket av alltsammans. När du skapar ditt paket skall du inte ta med huvudprogrammet utan bara de procedurer och funktioner som skall återanvändas senare i andra program. I denna laboration är det alltså Get, Put, Next_Date och Previous_Date som skall finnas med i paketet samt hjälpprocedurer och hjälpfunktioner. Ditt testprogram skall nu inkludera ditt paket och använda sig av de rutiner (procedurer och funktioner) som finns definierade där. Programmet skall givetvis fungera som tidigare. Del D: Skriv (i ditt paket) funktionerna Less_Date, Equal_Date och Greater_Date som jämför två datum (t.ex och ) returnerar sant värde om första datumet är mindre, lika med respektive större än det andra datumet. De två datumen skall vara parametrar till funktionerna. Modifiera dina funktioner så att de heter <, = respektive >. Det du gör nu är att du skapar tre operatorer (du gör en operatoröverlagring) <, = och > som kan användas på samma sätt som motsvarande operatorer för heltal eller flyttal, men i detta fall gäller de för värden av typen datum. Del E: Skriv ett litet separat program som använder ditt paket. Ditt program skall till att börja med läsa in 10 datum i ett fält. Därefter skall programmet sortera dessa datum så att det tidigaste (minsta) datumet kommer först och till sist skall ditt program skriva ut datumen sorterade. Del F: Du skall nu ändra din procedur Get så att den även kan hantera inläsning av felaktiga data. Några exempel på felaktiga data är , AAAA-BB-CC. Du kan säkert hitta på fler testfall (skall göras i del G senare). Din uppgift är att se till att Get upptäcker att det är något fel på datumet som läses in och resa/kasta ett undantag (eng. exception ) som är namngivet relevant för felet. Du skall själv namnge undantagen i ditt paket (exempel på namn på undantag är t.ex. Day_Error och Format_Error för de två fall som finns givna ovan). Observera att Get INTE skall fånga dessa undatag utan att den som anropar skall ta hand om felet och även utföra de åtgärder som behövs för att rätta till det som går. Get skall alltså bara kasta undantaget. I denna del skall programmet alltså krascha när undantaget kastas. Man kan tänka sig två varianter på hur Get beter sig med tangentbordsbufferten. Det ena är att det första tecken som gör att det är fel (samt resten av inmatningen) lämnas kvar i bufferten och det andra är att fler tecken än nödvändigt har lästs in (och därför inte finns kvar i bufferten). Du avgör vilket som är bäst och motiverar ditt val. Det skall även stå med i modulbeskrivningen för Get. Sida 16

21 Del G: Skriv ett nytt program som använder ditt paket. Detta program skall testa om din Get fungerar som den skall. Ett exempel på program som testar Get kan fungera på nedanstående sätt. Fråga din assistent vilket krav som finns i just din kurs. Användaren kommer att mata in data enligt följande. Först tre tecken ( OK eller NO ) som anger om det som följer är en korrekt inmatning eller ej. Till sist det som Get skall läsa in (om de tre första tecknen är OK är det ett korrekt datum som följer, är det NO är det ett felaktigt data som matats in). Om det är ett NO skall nästa rad i inmatningen vara namnet på det undantag som skall kastas. Den sista raden som matas in skall vara END och den anger att programmet skall avslutas. Antag att följande rader matas in (lägg dem i filen INDATA.TXT och starta ditt program enligt programnamn < INDATA.TXT så slipper du mata in dessa varje gång): Det finns två varianter att testa ditt program. Dels med korrekta indata och dels med felaktiga indata. I exempel 1 tar vi fallet med korrekta indata och i exempel 2 tar vi felaktiga indata. Exempel 1 på indatafil: OK NO Day_Error NO AAAA-BB-CC Format_Error END Ditt program skall alltså läsa ett antal rader med testdata. För varje test som verkar vara fel ( OK följs av att Get kastar ett undantag eller NO inte resulterar i ett undantag) skall programmet skriva ut vilket radnummer testdatat hade, vilket förväntat resultat det var samt vilket fel det var. Fall 1: Om din Get fungerar som den skall och de testdata du matat in (i filen INDATA.TXT) skall ditt testprogram inte skriva ut någonting på skärmen. Med ovanstående indata skall alltså programmet inte generera några utskrifter alls. Fall 2: Antag däremot att din Get inte fungerar som den skall och att den för första datat kastar ett undantag (låt säga Day_Error) och i de övriga fallen inte kastar några undantag (maximalt fel alltså). Då skall utmatningen från ditt program bli något i stil med: Rad 1: Borde varit OK, men fick Day_Error. Rad 2: Borde varit NO, men fick inget undantag. Rad 4: Borde varit NO, men fick inget undantag. Om din Get klarar av att kasta ett undantag skall programmet kontrollera att det är rätt undantag (står på raden efter det felaktigt inmatade datumet ) och kontrollera att det var ok. Antag att din Get gör rätt för inmatningarna på rad 1 och 4, men kastar Format_Error (istället för Day_Error) för inmatningen på rad 2. Då skall utmatningen från ditt program bli något i stil med (observera att endast ett felmeddelande skrivs ut): Rad 2: Är NO, men fick Format_Error istället för Day_Error. Sida 17

22 Exempel 2 på indatafil: OK NO Day_Error OK AAAA-BB-CC NO Format_Error END Fall 3: Om din Get fungerar som den skall och de testdata du matat in (i filen INDATA.TXT) skall ditt testprogram skriva ut ett antal felmeddelanden på skärmen. Med ovanstående indata skall programmet generera följande utskrifter. Rad 1: Borde varit OK, men fick Day_Error. Rad 2: Borde varit NO, men fick inget undantag. Rad 4: Borde varit OK, men fick Format_Error. Rad 5: Är NO, men fick Day_Error istället för Format_Error. Det finns fler testfall att hitta på. Det är din uppgift att se till att du har tillräckligt många testfall så att det syns att du förstått hur man testar sina underprogram. Del H: (frivillig) Antag att vi har en variabel Date som innehåller ett datum och en annan variabel Diff som anger hur många år, månader och dagar framåt i tiden vi vill komma (både Date och Diff kan vara av datatypen datum). Det vore då praktiskt att kunna utföra operationen New_Date := Date + Diff;. I Ada kan man överlagra funktioner och procedurer och man kan t.ex. överlagra operatorn + för olika datatyper. Detta ger oss möjlighet att utföra operationen ovan. Skriv funktionen + som tar två argument (Date och Diff) och som ger ett resultat som motsvarar ovanstående. Det kan vara praktiskt att skriva några hjälpfunktioner som utför addera år, månader respektive dagar för att klara av uppgiften. Funktionen + kan ju sen använda sig av dessa för att utföra sin uppgift. OBS! Gräv inte ner dig för djupt i vad som händer när man adderar en eller flera månader till ett datum. Du kan anta att det är 30 dagar som skall adderas för att addera en månad ävan om detta ger ett fel vid månader som inte är 30 dagar. Sida 18

23 Tekniska Högskolan i Linköping Institutionen för Datavetenskap (IDA) Torbjörn Jonsson Enkel listhantering I denna laboration kommer vi att implementera en dynamisk datastruktur, som till skillnad från fält (array) och poster (record) kan växa vid behov, och som till skillnad från filer kan växa i flera dimensioner. Mål Du ska efter denna laboration kunna: använda pekarstrukturer förstå hur rekursion går till förstå hur en privat datatyp fungerar och hur en sådan implementeras förstå hur ett generiskt paket fungerar och hur ett sådant instansieras Tonvikt läggs på: struktureringen av problemet val av underprogram och parametrar samt namn till dessa att göra små elementära operationer istället för komplexa Uppgift Du ska skriva ett paket som hanterar lagringen av en enkel form av dynamiska listor. I del A ska listan lagra ett antal heltal och i del B ska heltalen ersättas med poster som motsvarar personer och i del C utvecklas listpaketet till att klara av i princip vilka datatyper som helst. De data som ska lagras i listan ska lagras sorterade i stigande ordning, d.v.s. det minsta datat först. Alla procedurer och funktioner som kräver genomgång av listor ska göras rekursiva. I uppgifterna står inget om några huvudprogram. Givetvis måste sådana göras för att kunna testa paketen. Dessa huvudprogram behöver i sig inte göra något speciellt utan är till för dig som programmerare för att kunna på något sätt verifiera eller åtminstone göra det troligt att paketen fungerar som de skall. Följ instruktionerna noga i de olika delarna så att du inte ställer till det för dig. Se speciellt till att kopiera de färdiga filerna från en del till nästa för att inte tappa bort en version som fungerar. Var inte rädd bara för att det blir många paket i slutet. Paketen innehåller sina egna delar och det blir på detta sätt lättare att identifiera var olika fel uppkommit om detta händer. Del A I denna del ska du skapa den privata datatypen List_Type som motsvarar en lista och en del operationer för att hantera en sådan. Det paket som du ska skapa ska ligga i filerna sorted_list.ads och sorted_list.adb. När det gäller de procedurer och funktioner som ska implementeras vill vi bara säga att ni ska tänka efter innan ni börjar koda så slipper ni en massa besvär. RITA FIGURER! Den privata datatypen ska implementeras som en pekare till en post, där posten ska innehålla dels själva datat (heltalet) och dels en pekare till nästa post i listan. Hela paketet ska ha förutsättningen att de data som lagras i listan ska vara kopior av det som stoppas in. Sida 19

24 De uppgifter som här följer är de underprogram (metoder) som utgör gränssnittet mellan paketet och ett annat program (som använder paketet). I vissa fall kan det vara bra att införa hjälpoperationer för att underlätta hanteringen av de problem som uppstår. Dessa hjälpoperationer göms då lämpligen undan i filen sorted_list.adb. Du bör läsa igenom alla uppgifter innan du börjar programmera och lösa problemen. Det kan hända att du i tidigare uppgifter har nytta av rutiner som finns specificerade senare. Funktionen Empty Skriv en funktion som kontrollerar om listan är tom eller ej. Returnera ett sanningsvärde. Proceduren Insert Du ska skriva en procedur som stoppar in ett heltal sorterat i stigande ordning i en redan sorterad lista. De parametrar som behövs är en lista och ett heltal (som både är själva datat och det man söker efter, söknyckeln, i del A). Proceduren ska inte stoppa in datat om det redan existerar ett data med samma söknyckel i listan. Proceduren Put Skriv en procedur som skriver ut hela listan på skärmen. Du får själv välja hur utskriften ska se ut. Som indata fås en lista. Observera att listan ska vara opåverkad efter denna rutin. Ett bra test är att skriva ut listan två gånger (från testprogrammet). Funktionen Member Du ska skriva en funktion som går igenom den sorterade listan och letar efter ett data med en viss söknyckel och returnera ett sanningsvärde som talar om ifall datat existerade i listan eller ej. Indata till funktionen är listan och en söknyckel. Proceduren Remove Nu ska du skriva en procedur som plockar bort ett element ur en sorterad lista (d.v.s. listan ska bli ett element kortare ). De parametrar som ska finnas är en lista och den söknyckel som anger vilket data som ska tas bort. Du får förutsätta att alla söknycklar är unika i listan. Om det inte finns något element med denna söknyckel ska ett undantag ( exception ) resas. Dock behöver inte undantag tas om hand (fångas) i ditt program utan det får helt enkelt vara så att programkörningen avbryts. Observera att man måste återlämna minnesutrymmet för de poster man länkar ur listan. I annat fall får man något som kallas minnesläckor och detta gör i värsta fall att datorns minne tar slut. Proceduren Delete Du ska nu skriva en procedur som tar bort en hel lista (återlämnar minnesutrymmet för alla element i listan). Som parameter till proceduren fås en lista. Givetvis ska pekaren till listan vara NULL efter avklarat verk. Sida 20

25 Funktionen Find Du ska skriva en funktion som letar reda på ett element i en lista (ej ta bort elementet ur listan). Som indata fås en lista och en söknyckel. Funktionen ska returnera det data som matchar söknyckeln. Om det inte finns något element med denna söknyckel ska ett undantag ( exception ) resas. Proceduren Find Nu ska du skriva en procedur som motsvarar funktionen ovan. Samma funktionella krav som för funktionen ovan. Tips: Fundera på vad som behöver ändras och hur du på ett enkelt sätt slipper rätta i både funktionen och proceduren om man upptäcker att det är något fel. Att man har samma namn på två underprogram kallas att man överlagrar underprogrammen. Detta innebär dock inte att det ena eller andra underprogrammet försvinner. Det innebär att båda finns tillgängliga samtidigt. Funktionen Length Skriv en funktion som beräknar längden av en lista. Längden definieras som antalet element i listan. Del B Nu ska du göra om ditt paket till ett paket som hanterar listor med data av typen personer. Datatypen som motsvarar en person skall innehålla namn på personen (en sträng med t.ex. 20 tecken), dennes adress (en sträng) och födelsedatum (datumtyp). När man sorterar in en person i listan skall sorteringsnyckeln vara födelsedatum, d.v.s. personerna skall hamna i åldersordning i listan. Den äldsta personen skall vara först. Det paket som du skapar ska ligga i filerna person_sorted_list.ads och person_sorted_list.adb. Det är viktigt att du inte modifierar ditt gamla listpaket för mycket i del B. Du skall t.ex. inte lägga till något data i den post som listan består av utan bara byta typen från heltal till person. Typen som motsvarar en person innehåller ju iallafall söknyckeln. Det vettigaste angreppssättet här är att skapa ett ytterligare paket som hanterar en person. Detta paket bör (läs skall) ha persontypen privat. I detta extra paket tillkommer säkert ett par operationer som behövs för att hantera en person. Att ovanstående är det vettigaste sättet beror på att man i del C senare kommer att ta bort allt som har med persontypen från listpaketet och då är det ju onödigt att lägga in det från början. Dessutom vet man när man är en van programmerare att man skall hålla isär data och skapa så små enheter som möjligt för att lättare kunna felsöka senare. En ytterligare anledning till att man skall hålla persontypen utanför listpaketet är att alla de problem som uppstår när man skall göra listpaketet generiskt (del C igen) kommer i denna del. Detta är positivt då man dels får dessa problem medan man har tillgång till assistent (brukar vara så) och dels slipper blanda ihop den generiska hanteringen med problemlösningsdelen. Observera att du redan har ett paket som hanterar datum. Detta paket skall inte modifieras utan användas rakt av. Det kommer alltså att vara ett datumhanteringspaket, ett personhanteringspaket och ett listhanteringspaket att hålla reda på i denna deluppgift. Förutom detta givetvis ett huvudprogram. Sida 21

26 Del C Om du jämför de två paketen du redan gjort i deluppgifterna A och B så finner du att det är mycket som är samma sak, men vissa saker är olika. Hur kan du modifiera de båda paketen så att de ser likadana ut? Kanske måste huvudprogrammet leverera diverse typer m.m. till paketet för att paketet skall kunna utföra alla listoperationer på generella data? Nu ska du göra om ditt paket till ett generiskt paket, d.v.s. ett paket som klarar av att hantera listor med i princip vilka data som helst (dock med begränsningen att det bara går att ha en datatyp i en och samma lista). I bästa fall blir det ett helt generellt paket som kan användas till listor av vilka datatyper som helst. Det paket som du ska skapa ska ligga i filerna generic_sorted_list.ads och generic_sorted_list.adb. För att paketet ska klara av att hantera generella data måste huvudprogrammet implementera funktionerna < (och/eller > ) samt = för datatypen som motsvarar söknyckeln, en funktion som tar fram söknyckeln ur ett data samt en utskriftsprocedur Put för den datatyp som ska lagras i listan. Om det finns definierade procedurer och/eller funktioner som gör detta behöver du givetvis inte implementera dem igen. Alla dessa underprogram skall vara med som parametrar vid instansieringen av det generiska paketet. Observera att söknyckeln normalt sett är en enkel datatyp, medan datat som lagras normalt sett är en komplex datatyp som innehåller söknyckeln, d.v.s. dessa är normalt sett inte samma datatyp även om det råkar vara så i del A. I del B var t.ex. söknyckeln ett datum. I vissa av dina underprogram (som finns i paketet) kommer små modifieringar att behöva göras för att plocka fram söknyckeln ur datat som är lagrat i listan. Dock räcker det att anropa den funktion som plockar fram söknyckeln ur ett data. Om datat som lagras i listan är en person (se del B) är det lämpligt att den funktion som plockar fram söknyckeln tar emot hela personposten som data och returnerar datumet (om detta är söknyckeln). Är det istället ett enkelt data som lagras i listan (t.ex. ett heltal) kan funktionen direkt returnera talet. Sida 22

27 Tekniska Högskolan i Linköping Institutionen för Datavetenskap (IDA) Torbjörn Jonsson Mål Hantering av poster och externa filer. I denna laboration konstrueras ett minimalt databasprogram som kan söka i en datamängd efter vissa uppgifter. Du ska efter denna laboration: veta vad en binärfil är veta vad en textfil är kunna läsa information från en binärfil med read hantera filslut i binära filer Uppgift På en extern, binär datafil, finns ett litet register över personer och dessa personers intressen. Med hjälp av ett program interest i Ada vill man hitta alla de personer som har åtminstone något av vissa givna intressen. Dessa personer ska listas på en ny extern textfil. Varje post på den befintliga datafilen utgörs av en persons för- resp efternamn, hans gatu- och postadress samt en lista på högst 10 tal ur mängden 1 till 15 som representerar hans/hennes intressen. Dessutom finns förstås också angivet hur många intressen som faktiskt lagrats för personen i fråga. En datapost har då följande uppbyggnad (OBS! Ordningen mellan elementen i posten är i högsta grad relevant): Efternamn: 20 tecken Förnamn: 20 tecken Gatuadress: 20 tecken Postadress: 20 tecken Antal intressen: ett heltal Intressen: ett heltalsfält med 10 element Programmet ska alltså åstadkomma en förteckning över alla de personer i registret som hyser ett eller flera av ett antal efterfrågade intressen. Detta ska gå till på så sätt att programmet på terminalen först frågar efter ett antal önskade intressen och därefter letar efter alla personer som har minst ett av dessa önskade intressen. En genomläsning av filen är alltså nog! Programmet ska också bilda en ny extern textfil 1 där varje funnen person representeras av namn, adress och de överensstämmande intressena. På så sätt blir det enkelt att skriva ut en papperslista över de efterfrågade personerna. Ett program som uppfyller ovanstående specifikationer ska bete sig och användas som i exemplet på nästa sida. Användarens inmatning anges där kursiverad. Datafilen finns på kursbiblioteket och har där namnet REG.BIN. Kopiera denna till ert eget bibliotek. Denna fil är alltså binär! Den textfil som bildas får ha valfritt namn! 1. Då vi arbetar i en Unix-miljö är det normalt att låta programmet skriva texten till output, för att sedan låta användaren dirigera om utmatningen till en fil om han har lust. I det här fallet vill vi dock öva på att öppna externa filer inifrån ett Ada-program! Sida 23

28 TIPS! På kursbiblioteket finns både filen REG.BIN och REG.TXT. Filen reg.bin är den som du ska använda till programmet och filen REG.TXT innehåller samma data fast i läsbar form. Kopiera gärna båda filerna till ditt bibliotek (du måste kopiera filen REG.BIN för att kunna exekvera ditt program). Exempel då programmet körs: Ange en följd av intressen 1 till 15, max 10 st. Avsluta med 0: KLART! Resultat på filen RESULT.TXT I exemplet ovan är namnet på resultatfilen RESULT.TXT. Exempel på vad som skulle kunna hamna på filen RESULT.TXT Kajsa Kverulando Basungången 3 STAD *** Intressen: Gloria Glissando Pianovägen 26:d BY *** Intressen: Hilding Hysterico Gonggången 5 STAD *** Intressen: Kalle A Tempo Basungången 15 STAD *** Intressen: Folke Fortissimo Cembalovägen 9 STAD *** Intressen: Uno Unisono Gigagatan 4 BY *** Intressen: Observera att den dubbla inmatningen av 5:or inte gav dubbla 5:or i utskriften. Det ska inte heller spela någon roll hur många likadana tal som matas in. Programmet ska klara av 10 stycken olika tal oavsett antal inmatade dubletter. Exempel: Inmatning: Resulterande indata: 1 2 Sida 24

29 Tekniska Högskolan i Linköping Institutionen för Datavetenskap (IDA) Torbjörn Jonsson Nätverk och processer I denna laboration kommer vi att implementera ett enkelt konferenssystem (en chat ) i ett antal delsteg. Till att börja med kommer vi att begränsa oss till två personer som pratar med varandra och i slutet skall systemet klara av många personer som pratar samtidigt. Mål Du ska efter denna laboration kunna: använda sockets för enkel kommunikation mellan program på eventuellt olika datorer förstå hur man kan få flera processer att köra samtidigt i ett program förstå hur man kommunicerar mellan processer förstå hur man kan skapa en datatyp som flera processer kan använda utan att data blir inkonsistent (att processerna skriver över varandras information) sätta dig in i ett redan befintligt bibliotek av paket förstå vad klient och server är och hur man bygger upp sådana förstå att det behövs ett kommunikationsgränssnitt (protokoll) mellan olika program Tonvikt läggs på: hanteringen av sockets samt lösning av problem i klient och server förståelse av processer att modularisera problemet/programkoden så att man kan vidareutveckla sitt program när nya problem skall lösas Uppgift Du skall skriva två program. Det ena programmet skall vara en klient som hanterar en användare och ser till att denna kan kommunicera med någon annan användare och det andra programmet skall vara en server som sköter kommunikationen mellan användarprogrammen. Serverprogrammet skall då det är helt färdigt klara av att hantera många samtidiga användare som chattar med varandra. I de första deluppgifterna är servern ganska trivial (bland annat att den bara hanterar två personer) och senare kommer den att utvecklas till att klara mer komplexa saker. Klientprogrammet skall till att börja med klara av att hantera användaren (kunna läsa in text och visa den på skärmen) och skicka den text som matas in till servern samt ta emot text från servern (som någon annan skickat till denna användare) och skriva ut den på skärmen. I detta tidiga skede kan vi anta att användarna alltid måste skriva text varannan gång. I senare delmoment skall klienten klara av att hantera scenariot att alla användare kan mata in text när som helst. Det kan vara bra att se ett meddelande som inte bara texten som skickas utan att även informationen om vem som skickade meddelandet är en del av meddelandet (om inte annat för utskrifterna). Ett tips som kan vara bra att få redan i detta tidiga stadium är att det kan vara bra att göra iordning paket som innehåller rutiner som är bra att ha för både server och klient så att man slipper skriva samma kod på flera ställen (i detta fall i två olika program). Paket har ju den enorma fördelen att man kan inkludera det från olika program och rättar man i paketet är det bara att kompilera om de båda programmet. Mycket skönt alltså. Sida 25

30 Del A Denna övning är i första hand till för att komma igång med hantering av sockets, d.v.s. att hantera kommunikationen mellan två program via nätverk. På kurshemsidan finns lite information och några testprogram som kan vara bra att ha angående detta. Även information om hur man gör för att kompilera sitt program när man skall inkludera socket -paketet finns på hemsidan. Serverprogrammet Till att börja med skall servern klara av att hantera två uppkopplingar via sockets och scenariot är att de två användarna (klienterna) skickar data varannan gång. Servern (vi kallar den S) skall börja med att vänta på två uppkopplingar från två klienter. Därefter skall S tala om för den först uppkopplade klienten (kallar vi för K1) att den får börja kommunicera. S väntar på ett meddelande från K1 och skickar detta vidare till den andra klienten (kallar vi K2). K2 skickar ett meddelande till S och S skickar det vidare till K1. Detta upprepas tills det att K1 eller K2 kopplar ner sin förbindelse. Beskrivningen ovan kan göras på ett mer stilistiskt sätt och detta visar vi i kapitlet Protokoll på nästa sida. OBS! Det är väsentligt att S, K1 och K2 inte kraschar om något av programmen bryter kontakten (kan bero på att programmet avslutas eller att man stänger förbindelsen). Absolut väsentligt är att S inte kraschar. När någon av klienterna kopplar ner förbindelsen skall S meddela detta till den kvarvarande klienten. Ni får själva välja om den kvarvarande klienten också skall kopplas ner. Om någon ny klient kopplar upp sig kan åtminstone två fall vara möjliga. Dels att den nya klienten får chatta med den kvarvarande klienten (om denna inte kopplas ner) och dels att den nya klienten får vänta tills det kommer ytterligare en klient (om det inte finns någon kvarvarande klient). Vi rekommenderar den första varianten. Klientprogrammet Klientprogrammet (vi kallar det K) skall till att börja med vara ganska enkelt. K skall koppla upp sig mot servern (som kallas S) och vänta på besked om att det är dags att börja skicka meddelanden. Om programmet skall börja med att skicka ett meddelande skall K först läsa in en text från tangentbordet skriva ut den på skärmen och skicka den till S. Därefter skall K vänta på ett meddelande från S och skriva ut detta på skärmen. Inläsning av nytt meddelande skall ske och sen är det bara att fortsätta på det sättet tills det att användaren vill avsluta programmet. Just nu tar vi inte hänsyn till hur användaren upplever kommunikationen med programmet utan gör det på enklaste sätt. Ett exempel på hur det skulle kunna se på skärmen är (vi antar att det är den andre användaren, som vi kallar carma, som börjar prata och att du har som namn torjo ): carma: Lite text från den andre användaren. torjo: Ett svar på ovanstående. carma: Ytterligare information. torjo: Nu skriver vi lite mer text som skall skickas. Den text som är markerad med fetstil i ovanstående behöver givetvis inte skrivas så i ert program (det kommer mer om detta i del B i laborationen) utan vi har endast markerat den inmatning du gjort på detta sätt. Det viktiga i dednna del är att komma igång med kommunikationen. Sida 26