Høgskolen i Gjøvik Avdeling for informatikk og medieteknikk E K S A M E N EMNENAVN: EMNENUMMER: Grunnleggende programmering IMT 1031 (F) EKSAMENSDATO: 2.desember 2014 KLASSE(R): 14HBIND*, 14HBPUA, 14HBDRA, 14HBISA, 14HBSPA, 14HBINE*, 14HÅRINFA TID: 09.00-13.00 EMNEANSVARLIG: Frode Haug ANTALL SIDER UTLEVERT: TILLATTE HJELPEMIDLER: 7 (inkludert denne forside) Alle trykte og skrevne (kalkulator er ikke tillatt) Kontroller at alle oppgavearkene er til stede. Innføring med penn, eventuelt blyant som gir gjennomslag. Pass på så du ikke skriver på mer enn ett innføringsark om gangen (da det blir uleselige gjennomslag når flere ark ligger oppå hverandre). Ved innlevering skilles hvit og gul besvarelse, som legges i hvert sitt omslag. Oppgavetekst, kladd og blå kopi beholder kandidaten til klagefristen er over. Husk kandidatnummer på alle ark.
Eksamenssettet består av to ulike oppgavetyper: Oppgave 1 omhandler hva som blir utskriften fra/av to ulike programmer. Oppgave 2 omhandler et litt større programmerings-case. NB: Oppgavene 1a, 1b og 2 er totalt uavhengige og kan derfor løses separat. Oppgave 1 (30 %) a) Hva blir utskriften fra følgende program (litt hjelp: det blir 5 linjer): #include <iostream> #include <cstring> using namespace std; char txt[] = "FRODE-DRAR-TIL-LONDON-OM-TRE-DAGER-UTEN-AA-SE-ARSENAL!!!"; int main() { int i = 18, j = i % 5, k = i / j; do { cout << txt[i] << ' ' << txt[i+j] << '\n'; i += k; j *= 2; while (i <= 30); i = j = k = 12-3 * 2; while (k < i * j) { cout << txt[k] << ' ' << txt[k*5/3] << '\n'; k += 15; return 0; b) Hva blir utskriften fra følgende program (litt hjelp: det blir 5 linjer): #include <iostream> #include <cstring> using namespace std; class Lag { private: char navn[20]; char bane[30]; int kapasitet; public: Lag(char n[], char b[], int k) { strcpy(navn, n); strcpy(bane, b); kapasitet = k; void skriv() { cout << navn << ": " << bane << " (" << kapasitet << ')'; bool mindre(lag l) { return (kapasitet < l.kapasitet); void skjot(char t[]) { strcat(bane, t); bool finnes(char t[]) { return (strstr(bane, t)); Lag mix(lag l) { return Lag(navn, l.bane, kapasitet + l.kapasitet); ; int main() { Lag lag1("ipswich", "PortmanRoad", 30300), lag2("leeds", "EllanRoad", 39460), lag3("westham", "BoleynGround", 35300); lag1.skriv(); cout << " "; lag3.skriv(); cout << '\n'; if (lag2.mindre(lag3)) cout << "Arsenal\n"; else cout << "Chelsea\n"; cout << lag1.finnes("road") << ' ' << lag3.finnes("road") << '\n'; lag3.skjot("/uptonpark"); lag3.skriv(); cout << '\n'; Lag lag4 = lag3.mix(lag1); lag4.skriv(); cout << '\n'; return 0; 2
Oppgave 2 (70 %) Les hele teksten for denne oppgaven nøye, før du begynner å besvare noe som helst. Studer vedlegget, som inneholder mange viktige opplysninger som du trenger/skal bruke. Legg spesielt merke til conster, enum, klassen, ferdiglagd constructor, dens datamedlemmer og tre ferdiglagde funksjoner, globale variable, main og de tre les( )ene. Bruk alt dette aktivt. (Antagelig er oppgavene 2a og 2f enklest, mens 2e er mest vrien.) Det skal lages et program som holder orden på deltagende tomannslag i en cupturnering. To og to lag spiller/konkurrerer mot hverandre. Det ene laget slås ut av turneringen (er ikke lengre med), og det andre laget forsetter videre i turneringen. Datastrukturen Et lag er representert av klassen Lag. I vedlegget kan du se: hvilke datamedlemmer som inngår i objekter av denne klassen, hvordan slike objekter ligger i arrayen lagene, hvor lang denne arrayen er, samt at indeksene 1 til og med sistelag er i bruk (vi bruker ikke indeks nr.0). Dette skal være alt du trenger av klasser, datamedlemmer og globale variable for å løse denne eksamensoppgaven. Oppgaven a) Lag funksjonene void nyttlag() og void Lag::lesData() Den første funksjonen sjekker først om det er plass til flere lag. Om så ikke er tilfelle, kommer det en melding. I motsatt fall telles antall lag opp med en, og det nye laget leser selv inn data til sine tre tekster/strenger (de to andre datamedlemmene forblir foreløpig urørt). Vi har ingen sjekk på om duplikate lagnavn forekommer. b) Lag funksjonene void skrivlagene() og void Lag::skriv(, ) Den første funksjonen leser først ett tegn (bruk aktuell les-funksjon). Om dette tegnet ikke er A eller M, kommer det en melding. I motsatt fall gås det gjennom alle lagene som er i bruk. Ut fra om brukeren skrev A for «alle», eller M for «de som fortsatt er med», så kalles den andre funksjonen med relevante data (her får du bruk for enum-verdier). Den andre funksjonen vil skrive objektets data om parameteren er Alle eller om parameteren er Med og laget fortsatt er nettopp det. Det som skrives er: lagets navn, deltagernes navn, om fortsatt med eller ei (i form av tekstene «MED» og «IKKE MED»), og evt. (om laget fortsatt er med) neste motstanders nummer. (Dette nummeret kan også være 0-null, om laget er med, men ikke har motstander for øyeblikket.) c) Lag funksjonen void oppsettavkamp() Funksjonen leser først (fra brukeren) numrene/indeksene for to lag. Er disse to numrene like kommer det en melding, og resten av funksjonens innmat ignoreres. Det samme skjer om minst ett av lagene har en motstander allerede (bruk ferdiglaget funksjon), eller om minst ett av lagene ikke er med lengre (bruk ferdiglaget funksjon). Har alt gått bra i testene hittil, så registreres det at lagene er hverandres motstandere (bruk også her ferdiglaget funksjon). 3
d) Lag funksjonene void kampferdig() og void Lag::endreStatus( ) Den første funksjonen spør (brukeren) først om indeksene for laget som vant og laget som tapte (ingen oppgjør kan ende uavgjort). Har disse lagene ikke konkurrert mot hverandre (bruk ferdiglaget funksjon), kommer det en melding. I motsatt fall endres lagenes status vha. den andre funksjonen (bruk her også enum-verdier). Uansett om laget vant eller tapte, så settes lagets motstander til nr.0 (null). For det tapende laget markeres det at de ikke lengre er med. e) Lag funksjonen void kampoppsettet() Funksjonen skriver (til skjermen) en oversikt over alle kampene som skal spilles. Den nummererer kampene fortløpende fra 1 og oppover. Det skrives bare lagenes indeks (ikke deres navn og deltagere). Men, ingen kamper skal skrives dobbelt, dvs. konkurrerer lag nr.3 mot nr.6, skal det ikke skrives: «3 6» og «6 3», men bare «6 3». Dvs. laget med høyest indeks skal alltid komme først. Dessuten skal i den stigende kampnummerrekkefølgen det første lagets nummer komme i avtagende rekkefølge. Eks. på utskrift blir derfor: Kamp nr.1: 6-4 Kamp nr.2: 5-1 Kamp nr.3: 3-2 f) Lag de to void skrivtilfil( ) -funksjonene Funksjonene sørger til sammen for at hele datastrukturen blir skrevet til filen PROSKONK.DTA. Formatet bestemmer du selv, men angi dette som en del av besvarelsen. g) Lag de to void lesfrafil( ) -funksjonene Funksjonene sørger til sammen for at hele datastrukturen blir lest inn fra filen PROSKONK.DTA, som du selv bestemte formatet på i forrige deloppgave. Klargjøring og forutsetninger Programmet brukes på følgende måte: Kommandoen N utføres først alene mange ganger, slik at alle deltagende lag blir registrert. Deretter utføres de fire andre kommandoene ( S, O, F, K ), alt ettersom det måtte passe brukeren. Det er ikke programmets oppgave å f.eks. foreta trekning av kamper (motstanderlag), holde orden på antall lag fortsatt igjen eller at det er bare ett igjen (og dermed en vinner av hele turneringen). Det er brukeren som holder orden på alt dette. Programmet skal bare registrere lag ( N ), holde orden på motstandere ( O ), kampresultat (hvem som fortsatt er med i turneringen/blir utslått) ( F ), vise kampoppsettet ( K ), samt gi oversikt over alle lagene eller bare de som fortsatt er med ( S ). På hvert lag er det alltid to deltagere (hverken mer eller mindre). Gjør dine egne forutsetninger dersom du finner oppgaveteksten upresis eller ufullstendig. Gjør i så fall rede for disse forutsetningene først i besvarelsen din. Lykke til med konkurransen om en (god) karakter! FrodeH 4
Vedlegg: Halvferdig programkode (.tpl-fil) // INCLUDE: #include <fstream> // ifstream, ofstream #include <iostream> // cin, cout #include <cstring> // strcpy_s, strlen #include <cctype> // toupper using namespace std; // CONST og ENUM: const int STRLEN = 60; // Max. tekstlengde. const int MAXLAG = 100; // Max. antall lag enum status { Alle, Med, Utslaatt ; // Styrer handlinger noen steder. class Lag { // KLASSE: private: char navn[strlen]; char deltager1[strlen]; char deltager2[strlen]; bool fortsattmed; int motstander; // Lagets navn. // Navnet til 1.deltager. // Navnet til 2.deltager. // Laget fortsatt med eller utslått. // Indeksen til motstanderlaget, // eller 0 (null). public: // Deklarasjon av medlemsfunksjoner: Lag(); // Ferdiglaget nedenfor. void lesdata(); // Oppgave 2A void skriv(int n, status amu); // Oppgave 2B void endrestatus(status amu); // Oppgave 2D void skrivtilfil(ofstream & ut); // Oppgave 2F void lesfrafil(ifstream & inn, char b[]); // Oppgave 2G // NB: 3x ferdiglagde - brukes aktivt(!): bool deltarfortsatt() { return fortsattmed; void konkurrerermot(int n) { motstander = n; int harspiltmot() { return motstander; ; // DEKLARASJON AV FUNKSJONER: void skrivmeny(); char les(); int les(const char t[], const int min, const int max); void les(const char t[], char s[], const int LEN); void nyttlag(); // Oppgave 2A void skrivlagene(); // Oppgave 2B void oppsettavkamp(); // Oppgave 2C void kampferdig(); // Oppgave 2D void kampoppsettet(); // Oppgave 2E void skrivtilfil(); // Oppgave 2F void lesfrafil(); // Oppgave 2G Lag lagene[maxlag+1]; int sistelag; // GLOBALE VARIABLE: // Array med Lag-objekter. // Indeks for siste Lag hittil brukt. 5
int main() { char kommando; // HOVEDPROGRAM: lesfrafil(); // Oppgave 2G skrivmeny(); cout << "\nønske: "; kommando = les(); while (kommando!= 'Q') { switch (kommando) { case 'N': nyttlag(); break; // Oppgave 2A case 'S': skrivlagene(); break; // Oppgave 2B case 'O': oppsettavkamp(); break; // Oppgave 2C case 'F': kampferdig(); break; // Oppgave 2D case 'K': kampoppsettet(); break; // Oppgave 2E default: skrivmeny(); break; cout << "\nønske: "; kommando = les(); skrivtilfil(); // Oppgave 2F cout << "\n\n"; return 0; // ***************** DEFINISJON AV KLASSE-FUNKSJONER: ***************** Lag::Lag() { // Constructor initierer alle datamedlemmer: strcpy_s(navn, ""); strcpy_s(deltager1, ""); strcpy_s(deltager2, ""); fortsattmed = true; motstander = 0; void Lag::lesData() { // Leser ALLE TEKST-data: // Oppgave 2A: Lag innmaten // Skriver ALLE data om laget når alle skrives void Lag::skriv(int n, status amu) { // eller de som fortsatt er med: // Oppgave 2B: Lag innmaten // Endrer når er utslått, og resetter motstanderen: void Lag::endreStatus(status amu) { // Oppgave 2D: Lag innmaten void Lag::skrivTilFil(ofstream & ut) { // Oppgave 2F: Lag innmaten // Skriver ALLE data til fil: void Lag::lesFraFil(ifstream & inn, char b[]) { // Leser alle egne data fra fil: // Oppgave 2G: Lag innmaten 6
// ********************** DEFINISJON AV FUNKSJONER: ********************* void skrivmeny() { // Presenterer lovlige menyvalg: cout << "\n\nf ØLGENDE KOMMANDOER ER LOVLIG:\n"; cout << "\tn = Nytt lag\n"; cout << "\ts A = Skriv Alle lagene\n"; cout << "\ts M = Skriv lagene som fortsatt er Med\n"; cout << "\to = Oppsett av kamp\n"; cout << "\tf = Ferdig med kamp/konkurranse\n"; cout << "\tk = Kampoppsettet\n"; cout << "\tq = Quit/avslutt\n"; char les() { // Henter ett ikke-blankt upcaset tegn: char ch; cin >> ch; cin.ignore(); // Leser ETT tegn. Forkaster '\n'. return (toupper(ch)); // Upcaser og returnerer. // Leser et tall i et visst intervall: int les(const char t[], const int min, const int max) { int n; do { // Skriver ledetekst: cout << '\t' << t << " (" << min << '-' << max << "): "; cin >> n; cin.ignore(); // Leser inn ett tall. while(n < min n > max); // Sjekker at i lovlig intervall. return n; // Returnerer innlest tall. // Leser en ikke-blank tekst: void les(const char t[], char s[], const int LEN) { do { cout << '\t' << t << ": "; cin.getline(s, LEN); // Ledetekst og leser. while (strlen(s) == 0); // Sjekker at tekstlengden er ulik 0. void nyttlag() { // Legger (om mulig) inn et nytt lag: // Oppgave 2A: Lag innmaten void skrivlagene() { // Skriver lagene (ALLE eller kun de som fortsatt er MED: // Oppgave 2B: Lag innmaten // Legger inn (om mulig) hvilke to void oppsettavkamp() { // lag som skal konkurrere mot hverandre: // Oppgave 2C: Lag innmaten // Registrerer (om mulig) resultatet void kampferdig() { // av konkurrranse/kamp (hvem vant/tapte): // Oppgave 2D: Lag innmaten void kampoppsettet() { // Skriver alle kampene (med høyeste lagnummer først): // Oppgave 2E: Lag innmaten void skrivtilfil() { // Skriver HELE datastrukturen til fil: // Oppgave 2F: Lag innmaten void lesfrafil() { // Leser inn HELE datastrukturen: // Oppgave 2G: Lag innmaten 7