Kursavsnitt

Innehåll

Antal veckor c:a

Nybörjarkurs i C++ programmering

Enklare objektorienterad programmering, OOP.

9

Nybörjarkurs i Windowsprogrammering med MFC

Om programmering för Windows, först utan, sedan med MFC, Microsoft Foundation Classes.

3

System:

Vi definierar system i en allmän bemärkelse och ser på några av dess egenskaper, varefter vi ställer systemet i en datorprogrammerares synvinkel. Vi definierar systemering i allmänna termer och konkretiserar i en steg-för-stegmetod. Utan att gå in på programmering analyserar vi ett exempel på ett system.

Strukturerad programmering:

Eleven får lära sig de enkla reglerna i JSP, Jacksons Structured Programming, och tillämpa dessa på allmänna övningsuppgifter som inte innefattar programmering.

Därefter definieras begreppet 'Pseudokod', varvid eleven får genomföra ett par av JSP-diagrammen i sådan kod.

Developer Studio:

Här får eleven en första kontakt med utvecklingsverktyget 'Developer Studio'. I hela första häftet arbetar vi endast med konsolprogram, och eleven får här skapa ett sådant projekt, och skriva av ett program som står i häftet.

Vi tittar litet på hur man ger kommandon i Windows och hur man kan anpassa verktygsfält i Developer Studio (vilket är ett standardiserat sätt för alla nyare Microsofts Windowsprogram).

En speciell version av vårt program, Debug-versionen, är avsedd för felsökning, och vi ser hur denna version och originalversionen lagras i två separata mappar, Debug respektive Release.

Till sist tittar vi på en del av de filtyper som används vid programmering i C++.

Programkod:

Vi tittar på vad programmet vi skrev av i föregående kapitel innehåller, och konstaterar att vissa delar lämnas till senare studier, medan en rad innehåller en så kallad utskriftssats. Eleven får sedan på egen skriva ett program som skriver ut elevens namn.

Därefter ägnar vi oss åt en första kontakt med variabler, vi tilldelar dem värden, skriver ut dem på skärmen och studerar enklare uttryck. Till sist ser vi hur man kan göra snygga utskrifter genom att göra utskriftssatserna sammansatta, det vill säga innehålla såväl ledtexter som variabler i den ordning dessa ska skrivas ut.

Vi studerar programkodens logik, vilken är beroende av bland annat programsatsernas inbördes ordning. Nu kan vi göra något mer komplexa program och provar även inmatning från tangentbordet.

Windows arbetar med ANSI-tecken medan konsolfönstret använder ASCII-standard. Eleven får prova en ny anpassning av Developer Studio där DOS-Edit ansluts till ett menykommando för redigering av aktuell fil. Därigenom blir det lätt att korrigera de svenska bokstäverna å, ä och ö.

Vi tittar vidare på variablerna genom att prova andra datatyper, diskuterar behovet av dem och hur de fungerar. Vi ser även behovet att kunna byta datatyp, typomvandla, och vad detta får för konsekvenser.

Därefter utvecklas deklarationssatsen med flera samtidiga deklarationer och med initiering vid deklaration.

Några av C++ alla förkortningar demonstreras när vi lär oss fem nya tilldelningsoperatorer samt upp- och nedräkningsoperatorerna.

Texter:

Programspråket C++ har ingen datatyp som hanterar texter, endast enstaka tecken. Här visas hur denna brist kan vändas till fördel.

Vi ser även hur man kan infoga kommentarer i sitt program, för att underlätta förståelsen för hur programmet fungerar. Kommentarerna påverkar inte själva programmet, och ingår inte alls i .exe-filen.

Vi provar såväl inmatning från tangentbord av texter, vilka lagras i variabler, som utskrift av dessa texter på bildskärm, efter viss bearbetning.

Objekten cin respektive cout, vilka används vid inmatning från tangentbord respektive utskrift på bildskärm, behöver ibland användas på speciella sätt, och här går vi igenom cin.getline(), cin.ipfx() samt cout.width().

Programstyrning:

Programmets logik är inte endast principen ett steg i taget. Man kan även styra så att vissa delar utförs endast om vissa villkor är uppfyllda, eller att vissa delar utförs upprepade gånger så länge vissa villkor är uppfyllda, eller tills de blir uppfyllda.

Först tittar vi på vad villkor är för något, och hur vi skapar enkla villkor samt hur flera villkor kan sättas samman till sammansatta villkor. Därefter testar vi att tillämpa villkor med 'if' och 'else'.

En variant på satser som utförs beroende på villkor är en så kallad 'switch', vilket vi också tittar på.

Sedan går vi igenom olika upprepningar, och tittar på 'while', 'do...while' och 'for'.

Till sist ser vi på 'break', 'continue' samt 'goto'. Samtliga dessa instruktioner avrådes, dock finns en naturlig plats för 'break' i en 'switch'. Ett par 'dåliga' exempel visar eleven olämpligheten i att använda dessa instruktioner där man kan lösa uppgiften på ett mer välstrukturerat sätt enligt JSP i stället. I JSP finns inte utrymme för dessa instruktioner.

Listor och pekare:

Här ser vi hur man kan använda en lista för att lagra ett flertal värden av samma datatyp under ett gemensamt variabelnamn, samt hur man anger specifika element i listan.

Vi ser hur man kan initiera listans alla värden, eller en del av dem, i deklarationssatsen, samt konstaterar att vi redan använt oss av listor när vi lagrade texter. Dessa lagras som en lista av typen 'char', tecken.

Eleven uppmanas att konstruera ett enkelt schackbräde, och ser därigenom hur en lista kan ha mer än en dimension, och därmed använder fler än ett index för att identifiera de olika elementen i listan.

I en första kontakt med pekare får eleven prova att låta en pekare ange element i en lista. Grundprinciperna för hur man använder en pekare presenteras.

Nu har eleven tillräckligt med grundkunskaper för att skapa mera avancerad programlogik. I fyra steg-för-steguppgifter lär sig eleven att från en lösningsidé gå via JSP till färdig lösning. Det är två uppgifter som går ut på att söka ett värde i en lista med tal, och två uppgifter som går ut på att sortera listor med tal enligt olika principer. För varje uppgift får eleven lösa en allt större bit själv. Sökningarna är av typen sekventiell respektive binär sökning, och sorteringarna av typen urvalssortering respektive bubbelsortering.

Funktioner:

Vi experimenterar med enkla funktioner som endast skriver ut texter på bildskärmen, för att se hur man skapar dem och hur man kan anropa dem.

Därefter tittar vi på hur en funktion kan lämna ett svar, hur man tar emot svaret vid funktionsanrop, och hur detta motiverar att man anser att funktionen är av en viss datatyp.

Vi följer upp med att använda argument vid funktionsanropen, så att en funktion kan uppträda på olika sätt vid olika anrop beroende av argumentens värde. Här observerar vi att varje funktion har ett eget datautrymme, vilket gör att man slipper namnkollisioner. Man talar om att varje funktion deklarerar sina variabler i sitt lokala sammanhang, varvid dessa inte finns tillgängliga för andra funktioner.

Vi tittar även på hur man kan använda pekare som argument, för att låta denna peka ut data som hör till anropande funktions sammanhang.

Eleven får stifta bekantskap med de olika lagringsklasser som finns, och hur dessa kan ändra reglerna för lokala och globala variabler, varvid naturligtvis globala variabler först definieras.

Slutligen tittar vi litet på den uppsjö av funktioner som andra programmerare redan skrivit, och vilka levererats med utvecklingspaketet. Detta kallas API, 'Application Programming Interface'. Vi provar en del av dessa funktioner i ett par övningsuppgifter.

Strukturer:

Vi definierar strukturer och ser hur man med dessa kan skapa nya, komplexa datatyper. Genom dessa datatyper kan man deklarera en hel uppsättning variabler i en enda deklarationssats, och under ett gemensamt namn.

Vi ser sedan hur man kan använda detta namn i kombination med namnet på de olika elementen i strukturen för att komma åt dess data. Elementoperatorn används här, men vi ser även hur man via den indirekta operatorn kan komma åt de olika elementen när man har en pekare som pekar på strukturvariabeln.

Använda filer:

Det finns flera olika nivåer på vilka man kan hantera filer. Jag har valt att arbeta på den nivå som gäller vid klassisk C-programmering av två orsaker: Klassen CFile gör det litet för abstrakt, och vi ännu inte är bevandrade i klasser och objekt, så den nivån är inte den bästa. Att arbeta med lågnivå filhantering är alldeles för tekniskt och onödigt omständligt.

Först ser vi hur de funktioner vi kommer att använda kommunicerar med DOS via ett datablock, och vi behöver deklarera en pekare av typen FILE för att hålla reda på var detta datablock finns i minnet.

Vi ser sedan hur man kan öppna och stänga filer, det vill säga etablera en kommunikation med DOS om filen, varvid ovannämnda datablock deklareras av funktionen fopen(), och att terminera denna kommunikation och därmed göra filen tillgänglig för andra program. Vi ser även på den felhantering som kan var lämplig i sammanhanget. Det är ju rätt ofta som man efterfrågar en fil som inte finns, försöker skriva i en fil som är skrivskyddad, försöker skapa en fil när disken är full etcetera.

Därefter ser vi hur man kan läsa och skriva i filen. Vi provar såväl teckenvis läsning och skrivning som radvis dylik.

Objektorienterad programmering:

I resten av första häftet tittar vi på det som är specifikt för C++. Vi har tidigare i stort sett hållit oss till sådant som går att göra i C, förutom 'cin' och 'cout'. I detta kapitel finns en kort presentation om vad OOP, ObjektOrienterad Programmering är för något, och förklarar hur man kommit fram till programmeringsspråkets C++ namn.

Dynamisk minnesallokering:

Vi tittar på de operatorer som handhar dynamisk minnesallokering i C++, utan att gå alltför djupt in på de klassrelaterade aspekterna på varför man skapat dessa nya operatorer.

Vi ser hur pekare får en naturlig användning när man reserverar minne dynamiskt, och ser på ett exempel där vi skapar en enkel länkad lista.

Mer om funktioner:

När funktioner ingår i klasser finner flera av de nya finesserna i C++ sin plats. Vi tittar på prototyper i detta kapitel, men det kommer mer senare.

Vi ser även på konstanter och makro.

Till sist ser vi hur man kan överlagra funktioner, något som vi får nytta av i klasser och objekt.

Klasser och objekt:

Vi diskuterar objekt ur en allmän synvinkel, definierar dess attribut och metoder. I ett par exempel identifierar vi attribut och metoder för några vardagliga objekt.

Därefter ser vi hur man kan skapa en mall som kan användas när man deklarerar objekt. En sådan mall kallas en klass.

När vi går över till programmering ser vi hur klasser och objekt får en naturlig plats. Vi skapar ett par enkla klasser och gör objekt på dessa. Här ser vi att man ibland behöver speciella metoder vilka används när objekten skapas respektive förstörs.

Vi överlagrar den metod som används när objektet skapas, constructor, varigenom vi får ett nytt sätt att skapa objektet.

I ett enkelt exempel ser vi hur man kan kompilera en klass, för att senare använda den i kompilerad form. Då har man tillgång till endast klasshuvudet och den kompilerade koden, inte själva källkoden.

Till sist provar vi att låta en klass ärva från en vi redan skapat, och byter ut en av de ärvda metoderna. Vi definierar därmed även begreppet klasshierarki.

Windowsprogrammering:

I en första kontakt med Windowsprogrammering får eleven steg för steg bygga upp ett Windowsprogram från grunden. I och med att vi inte använder den programgenerator som finns får vi en grundläggande förståelse för hur Windowsprogrammet fungerar.

Vi provar att skapa några resurser, en muspekare, en programikon samt en meny. Vi kopplar två menykommandon, ett till att visa en meddelanderuta, och ett till att avsluta programmet.

Till sist testar vi att låta inmatning med mus respektive tangentbord resultera i utskrift på bildskärmen i form av ritade streck respektive text.

Programguiden:

Vi lär oss använda programgeneratorn, AppWizard, till att skapa ett Windowsprogram. Vi studerar hur projektet ser ut, och vad vi fick tillverkat åt oss. ClassWizard hjälper oss att koppla kommandon till funktioner, och lär oss att Class Wizard utnyttjar ett meddelandesystem kallat AFX, Application Framework eXchange, för att lösa uppgiften åt oss.

Därefter studerar vi de filer som skapats, och vilka delar programmet består av. Trots det ringa arbetet att skapa detta program är det mycket mer omfattande än det program vi med mycket möda skapade i föregående kapitel.

Dialogruta:

Här får vi veta hur klassen CDialog assisterar oss i att hantera ett speciellt fönster, kallat dialogruta, vanligen avsedd att göra olika inställningar i ett program, samt att begära upplysningar från användaren. Vi ser även hur man får fram dialogrutan på bildskärmen.

Dialogrutan beskrivs i en klass och skapas som ett objekt. Vi ser hur man kan låta dialogobjektet existera hela programkörningen genom att deklarera det globalt i den klass där den hör hemma. Därigenom bevaras de inställningar man gjort även när dialogrutan är stängd.

Kalkylatorn:

Äntligen får vi göra ett 'riktigt' program. Här lägger vi till möjligheten att göra dialogbaserade program, det vill säga enkla program som ser ut som en dialogruta. En kalkylator är ett utmärkt exempel på ett program som kan göras på detta sätt. Eleven får viss hjälp med programkoden, men skriver en del själv. Slutresultatet blir en fungerande kalkylator, som inte på minsta vis ser ut som något skrivet av en nybörjare.