Kursavsnitt Innehåll Antal veckor c:a

Innehåll

Antal veckor c:a

Grunderna i C/C++ Programmering

Grundläggande programmering i språket C och C++.

3

Objektorienterad Programmering

Objektorienterad programmering i C++. Klasser och objekt, arv, överlagringar etc.

4

Windowsprogrammering med MFC

Programgeneratorn, klassverktyget, olika resurser och kontroller, samt olika typer av program.

3

Självstudier

På egen hand följa de övningar som Microsoft levererat med utvecklingspaketet. Här finns även utrymme för självstudier inom närliggande områden som Access, Visual Basic, Excel, SQL och Java.

2

Vecka 1:

Grunderna i C/C++ Programmering:

Utvecklingsverktygen, Projektupplägg, Definitioner, Språkets olika komponenter och struktur, Texthantering, In- och utmatning för konsol, Programstyrning.

Vecka 2:

Grunderna i C/C++ Programmering, (fortsättning):

Listor, Pekare (Vektorer), Indexerad pekare, Dynamisk minnesreservation (Allokering), Länkade listor, Referensvariabler, Konstanta variabler, Strukturer och unioner, Funktioner.

Vecka 3:

Grunderna i C/C++ Programmering, (fortsättning):

Makro, Rekursion, Förvalda argument, Funktionsöverlagring, Räckviddsoperatorn, Läsa och skriva filer, Programmering för Windows utan MFC, WinMain(), Meddelanden, Resurser, MessageBox().

Vecka 4:

OOP - ObjektOrienterad Programmering:

Klasser, Objekt, Klassarv, Klasshierarki, Utbyte av medlemsfunktion.

Vecka 5:

OOP - ObjektOrienterad Programmering, (fortsättning):

Klasser och dynamisk minnesallokering, Operatoröverlagring, this-pekaren, Kopieringskonstruktorn, Objekt och referenser till dito som argument eller returvärde, Statiska medlemmar, Statiska metoder, friend-deklarationer, Felhantering, Överlagring av new och delete.

Vecka 6:

OOP - ObjektOrienterad Programmering, (fortsättning):

Arv och polymorfism, Typomvandling, Basklasspekare, Virtuella funktioner, Multipelt arv. Realtids typkontroll (RTTI).

 Vecka 7:

OOP - ObjektOrienterad Programmering, (fortsättning):

Fler operatoröverlagringar, Operatoröverlagring som friend, Konstruktor med förvalt argument för implicit typomvandling, Typomvandlingsoperatorer, Konflikter och tvetydigheter, Undantagshantering, Mallar (Templates), Grunderna i objektorienterad design.

Vecka 8:

Windowsprogrammering med MFC:

AppWizard, Resursredigeraren, AFX-hantering, Projektets klasser, Applikation, MainFrame, Dokument, Vy, ClassWizard, Koppling dokument - vy, Dialogruta, Koppling kontroll - variabel, Enklare kontroller, Kontrollers status.

Vecka 9:

Windowsprogrammering med MFC, (fortsättning):

Mer komplexa kontroller, Rullningslist, Listruta, AfxMessageBox(), Kontrollvariabler, SendDlgItemMessage(), Component Gallery, Olika vyklasser för hantering av kontroller i programfönstret, CArchive, CFile, File-menyn, CFileDialog, CObList.

Vecka 10:

Windowsprogrammering med MFC, (fortsättning):

Dialogbaserat program, dokumenthantering utan CDocument, CBitmap, Bitmapsredigeraren, Bilder i arbetsytan, WM_LBUTTONDOWN, PC-högtalaren, inp, outp, CheckMenuItem(), Bilder som menyval.

Vecka 11 - 12:

Windowsprogrammering med MFC, (fortsättning):

Microsoft självstudier, Scribble, OLE container, OLE server, OLE control, ODBC, DAO, Windows 95 anpassning.

Developer studio

Developer Studio:

Eleven får en första kontakt med utvecklingsverktygen. Vi skapar ett projekt, och anpassar ett verktygsfält, en snabbtangent och lägger till ett verktyg i Tools-menyn.

Debug/Release:

Här berörs skillnaden mellan debug och releaseversion av ett projekt. Att använda felsökningsverktyget lär vi ut individuellt på övningstid, när eleven har ett lämpligt problem.

Consol Application:

Själva programspråket lärs ut genom att tillämpa DOS-applikationer. Eleven får skapa projekt av typen Consol Application. En del av de filtyper som ingår i ett projekt diskuteras.

Definitioner

Definitioner:

Olika termer definieras. Datatyper diskuteras, tillsammans med en första kontakt med strukturer. Kommentarer förordas och de vanligaste reserverade orden för C visas. Eleven uppmanas starkt att söka information i det omfattande hjälpsystem som följer med utvecklingssystemet, och det börjar här, med att eleven själv slår upp de reserverade orden för C++.

Operatorer:

Aritmetiska operatorer, tilldelningsoperatorer, relationsoperatorer, logiska operatorer, pekarrelaterade operatorer, struktur och unionsoperatorer, klassrelaterade operatorer, villkorsoperatorn, storleksoperatorn samt typomvandlingsoperatorn diskuteras.

Programstrukturen:

En första överblick visar var de olika delarna av programmet hör hemma i källkoden. Dock har eleven inte kunskap om alla ingående komponenter än. Vi konstaterar att DOS och Windows inte använder samma teckenstandard, och löser det m.h.a. dosprogrammet Edit. Eleven uppmanas lägga till Edit i Tools-menyn, och ange aktivt dokument som argument. Räckvidd, numreringar, lagringsklasser och länkspecifikationer diskuteras.

 Texter och konsol I/O

Teckensträngar:

Vi diskuterar hur textsträngar hanteras av kompilatorn respektive hur vi kan hantera dem i våra program, eftersom C/C++ inte har någon datatyp för texter.

Konsol:

Vi tittar på olika funktioner för inmatning från tangentbord och utskrift på bildskärm, puts(), gets(), printf(), scanf(), cout, cin.

Programstyrning

Upprepningar:

De olika programinstruktioner som upprepar programkod diskuteras: while, do...while och for. Nästlade slingor diskuteras också.

Villkorlig bearbetning:

De olika instruktioner som villkorligen styr vilka delar av koden som ska utföras diskuteras: if, else, switch och case. Break och continue diskuteras speciellt med avseende på när de är lämpliga att användas, men avrådes i andra fall. Instruktionen goto avrådes helt, men förklaras ändå.

Listor och pekare

Listor:

Listor diskuteras, deklaration, initiering, flera dimensioner. Textsträngen är egentligen en lista. Indexering i listor.

Pekare:

Vi diskuterar vad en pekare egentligen är, och hur kompilatorn hanterar den. Vi ser hur den kan användas till att identifiera enskilda element i en lista i stället för att använda index.

Pekare och minne

Minnesallokering:

Vi diskuterar behovet av att reservera mer minne under programkörningen, och hur detta görs.

Länkad lista:

Länkade listor diskuteras, och de kräver ju att man reserverar minne efterhand som listan utökas.

Pekare:

Indexerade pekare diskuteras, liksom funktionspekare.

Referensvariabler:

En första kontakt med referenser och deras enklare användning.

Konstanta variabler:

Konstanta variabler jämförs med textkonstanter. Konstant pekare jämförs med pekare mot konstant variabel.

 Strukturer och unioner

Strukturer:

Strukturerna diskuteras mer ingående. Hur man använder pekare för att komma åt strukturelement.

Unioner:

Unioner förklaras, men kommer inte att användas direkt under kursen.

Fördefinitioner i headerfiler:

Vi tittar på hur man ofta deklarerar strukturer i headerfiler. Många sådana deklarationer finns tillsammans med konstantdeklarationer, funktionsdeklarationer etc. i de headerfiler som levereras med kompilatorn.

Funktioner

Funktioner:

Grundbegreppen diskuteras. Funktionens returtyp och instruktionen return.

Argument:

Hur man deklarerar argument, mekaniken bakom värdeanropen. Pekare som argument, och eventuellt som returvärde.

Prototyper:

Hur man skapar en funktionsprototyp och varför.

Inlinefunktioner:

Inlinefunktioner diskuteras och jämförs med makron.

Rekursion:

Vi gör ett övningsexempel med en rekursiv funktion, det vill säga en funktion som anropar sig själv.

Förvalda argument:

Vi ser hur man kan ge ett eller flera argument standardvärden, så att dessa värden inte behöver anges vid anrop.

Överlagrade funktioner:

Vi ser hur man kan deklarera flera funktioner med samma namn, och skiljer dem åt endast med hjälp av differenser i argumentlistan.

Räckvidd:

Vi diskuterar lokala och globala variabler och räckviddsoperatorn.

Använda filer

Datatypen FILE:

Vi arbetar med filer via DOS, och diskuterar hur datatypen FILE används till detta.

Öppna och stänga filer:

Vi diskuterar hur man upprättar en 'dialog' med DOS om en fil, och hur man avslutar den när man inte längre vill arbeta med filen.

Läsa filer, skriva filer, positionering:

Vi diskuterar enklare läsning och skrivning i filer, och hur man kan använda seek() till att positionera sig i en fil. Såväl byte-vis bearbetning som radvis dito diskuteras.

Windowsprogrammering

WinMain():

Här presenteras det enklaste tänkbara Windowsprogram, varigenom dess huvudrutin WinMain() presenteras.

Programfönstret:

Grundprinciperna för hur ett Windowsprogram fungerar diskuteras, och vi går igenom de olika stegen för att bygga upp ett enkelt program som har ett fungerande progamfönster och kan reagera på standardmeddelanden.

Muspekaren, Ikonen, Menyn, Koppla menykommando, Tangentbord, Mus:

Vi går igenom en del standardresurser, ser hur man redigerar dem och kopplar in dem i sitt program, samt ser hur man får en respons från en användarinteraktion och i denna ritar och skriver i programfönsterts arbetsyta.

Introduktion

OOP - ObjektOrienterad Programmering, Betydelsen av C++:

En kort presentation av idéerna bakom objektorienterad programmering, där vi jämför med äldre metoder. Vi diskuterar även hur man kommit fram till namnet på den objektorienterade versionen av C nämligen C++.

Klasser och objekt

Objekt, Klasser:

Vi diskuterar hur man deklarerar klasser och skapar objekt. Tre olika klasser används genom kapitlet för att belysa klasser och objekt ur olika aspekter.

Constructor, Destructor:

Vi diskuterar varför man kan behöva konstruktion och destruktion. Enklare former av konstruktorer visas.

Konstanta objekt, Pekare, new och delete:

Vi diskuterar tidigare kända begrepp och vad de får för effekter på objekt. De nämnda begreppen får en större betydelse i samband med klasser och objekt.

Kompilerade klasser, Klassarv, Klassherarki, Utbyte av medlemsfunktion:

Vi provar att kompilera en klass och att sedan använda endast objektkoden och klasshuvudet i ett annat projekt. Vi provar även att ärva från klassen, lägga till metoder i den ärvande klassen samt att byta ut metoder och anropa förälderklassens version av den utbytta metoden. Vi diskuterar klasshierarki i sammanhanget.

 Klasser och dynamisk minnesallokering

Free store:

Jämförelse mellan funktioner i C för minnesallokering och operatorer i C++ för dito, och vad skillnaden har för betydelse för dataintegriteten i de objekt som minne reserveras för.

Pekaren som klassmedlem:

Vi diskuterar de speciella situationer som kan uppstå när ett objekt reserverar extra minne från en av sina metoder, och vad detta får för följder när man kopierar objekt.

Överlagring av tilldelningsoperatorn, this, Kopieringskonstruktorn, Objekt som argument/returvärde:

Vi provar vår första operatoröverlagring. Syftet är att rätta till det problem som uppstår när man kopierar ett objekt som innehåller en pekare mot data som reserverats dynamisk. Ytterligare problem som dyker upp i sammanhanget löses med olika metoder. Vi diskuterar vad som händer när man använder ett objekt som argument eller returvärde.

Referenser till objekt som argument/returvärde:

En vanligare metod är att man använder referenser i stället för att deklarera hela objekt. Här får referenser en större betydelse än när de introducerades i föregående häfte.

Mer om klasser

Statiska medlemmar, statiska metoder:

Nyckelordet static har flera användningar i samband med klasser. Vi diskuterar statiska objekt, statiska medlemmar och statiska metoder.

Vänner emellan:

En första introduktion till begreppet friend. I et förenklat exempel skapar vi två klasser, där den ena har tillgång till de privata medlemmarna i den andra. Även en funktion kan anges som friend till en klass, men nyttan med detta kommer vi att se först i ett senare kapitel där vi gör globala operatoröverlagringar.

Objketlistor:

Vi diskuterar vad som händer när man deklarerar listor med objekt, hur konstruktorn anropas etc. Även dynamisk allokering av lista diskuteras.

_set_new_handler:

Vi provar att byta ut den vanliga felhanteringen mot en egen dito. I ett exempel allokerar vi minne så lång det går, och sedan meddelar vår egen felhanterare att det inte går längre, varefter den avlutar programmet.

Överlagring av new och delete:

Vi diskuterar olika aspekter på överlagring av operatorerna new och delete. De kan överlagras såväl klasspecifikt som globalt.

Arv och Polymorfism

Hantering av närbesläktade klasser:

Vi bygger en klasshierarki för att se hur man kan hantera vissa uppgifter i en basklass, medan specifika uppgifter hanteras i ärvande klasser. Vi ser hur arvtagarens konstruktor kan anropa förälderklassens dito med en speciell syntax.

Typomvandling på objekt och pekare:

Vi provar olika typomvandlingar för att se vilka som är tillåtna och vilka som är förbjudna. Vi provar även att typomvandla pekare.

Listor och basklasspekare:

Vi ser hur en lista kan använda sig av en pekare av basklassens typ för att använda objekt av olika klasser ur hierarkin, men här bara för att nå uppgifter som finns i basklassen.

Virtuella funktioner:

Man kan förbättra ovanstående så att man även når övriga medlemmar i objektet genom att deklarera virtuella funktioner i basklassen.

 Multipelt arv:

Vi ser hur man kan låta en klass ärva av flera föräldrar, hur detta skapar tvetydigheter för kompilatorn och redundans, samt hur man kan lösa dessa konflikter.

Typkontroll vid programkörning

Operatorn typeid, Klassen type_info:

RunTime Type Information, RTTI, ger oss en mekanism att bestämma vilken typ av objekt en pekare pekar på. Vi ser hur operatorn typeid ger oss ett objekt av typen type_info, vilken informerar oss om objektets typ.

Operatoröverlagring och typomvandlignsfunktioner

Operatoröverlagring:

Vi fördjupar oss i olika aritmetiska operatoröverlagringar i ett övningsexempel med en klass som hanterar bråktal. Vi överlagrar såväl lokalt som globalt, och sre behovet av att använda funktioner som deklarerats som friend.

Konstruktor med förvalt argument för implicit typomvandling:

En annan metod kombinerar förvalt argument i en konstruktor så att ett av kompilatorn skapat temporärt objekt kan omvandla ett heltal till ett bråktal där kompilatorn ser behov av en sådan typomvandlign.

Typomvandlingsoperatorer:

Vi provar med att överlagra en typomvandlingsoperator, nämligen float, så att våra bråktal kan representeras som flyttal.

Tvetydig typomvandling:

Vi ser hur kompilatorn kan finna flera betydelser via våra olika operatorer, och vet inte vilken typomvandling den ska lösa en viss situation med. Övriga tvetydigheter diskuteras.

Exceptions

Undantagshantering i C++:

Undantagshantering ger oss en metod att låta felhantering följa programmets struktur, hur man kan märka fel med en viss datatyp, och hur man kan rapportera fel via för ändamålet avsedda klasser.

Templates

Funktionsmallar, Klassmallar:

Vi ser hur man kan automatisera upplägg av funktioner och klasser med olika datatyper/klasstyper, genom att använda mallar, samt se vilka användningsområden detta kan ha.

 Grunderna i ObjektOrienterad Design

Abstraktion, Inkapsling:

Här läser eleven om hur man lägger upp sitt projekt, vad begreppen abstraktion och datagömning egentligen innebär.

Klasshierarkier:

Här diskuteras hur man ärver, och varför samt i vilka situationer. Man kan ärva för att få tillgång till såväl operationer som gränssnitt.

Konsten att arbeta objektorienterat:

En diskussion om hur man lägger upp ett projet i objektorienterad anda, och hur man arbetar med det under utvecklingen. Komposition ställs mot arv, och multippelt arv diskuteras.

Programguiden

MFC AppWizard:

Vi lär oss använda programgeneratorn för att skapa ett enkelt MFC-projekt.

Project Workspace:

Här är en presentation av ett kraftfullt verktyg som ger programmeraren överblick över sin kod. Fler finesser presenteras under kursens gång.

Menyredigeraren, Dialogredigeraren:

Vi tittar litet på ett par resurser som kan redigeras, menyer och dialoger. Vi lägger till ett menyval och vi redigerar About-dialogen.

Koppla menykommando:

Vårt nya menykommando måste kopplas till en funktion, och i den funktionen skriver vi ut ett meddelande till användaren via funktionen MessageBox().

Programmets beståndsdellar

Applikationen, AFX meddelandehantering:

Vi studerar de filer AppWizard skapat åt oss i föregående kapitel. Vi ser även hur ClassWizard hjälpt till såväl när AppWizard skapade programmet som när vi kopplade vårt menykommando till en funktion. Vi diskuterar programmets uppdelning i applikation och mainframe.

Variablernas plats:

Vi diskuterar dokumentets uppdelning i dokument och vy, och testar med ett enkelt exempel att använda en variabel i dokumentet från vyn.

ClassWizard:

ClassWizard servar programmeraren i bakgrunden, men har även en egen huvuddialog, vilken presenteras här.

Dialogruta

Ny resurs, CDialog:

Vi tittar på olika sätt att skapa en ny resurs, skapar en dialogruta, samt skapar en ny klass till dialogrutan. Vår nya klass ska ärva från klassen CDilaog, vilket ClassWizard hjälper oss med. Vi lär oss två kontroller, textrutan och knappen.

UpdateData():

Vi lär oss koppla variabler till kontroller, och ser hur man kan uppdatera variabler mot kontroller och vice versa med hjälp av funktionen UpdateData().

 DoModal(), Globalt objekt:

Vi skapar ett objekt baserat på vår nya klass, och anropar en metod som heter DoModal() för att aktivera den. Objektets sammanhang är viktigt om man vill att dess ingående variabler ska finnas kvar när man stängt dialogen, och vi provar att flytta det till vyns klassdeklaration.

Kryssrutor

Kryssrutan, variablerna, använda krysset:

Vi tittar på en annan kontroll, nämligen kryssrutan. Den kopplas med en boolsk variabel. Vi ser hur man kan använda kryssets status.

Aktiv/passiv kontroll, Synlig/gömd kontroll:

Vi ser hur man kan ändra status för krysskontrollen, om den ska vara aktiv eller passiv, och hur man kan gömma den helt, och sedan ta fram den igen. Detta gäller alla sorters kontroller.

Initiera kryssruta, Initiera dialog, Initiera synlighet:

Vissa tillstånd kan initieras redan i resursredigeraren, medan andra lämpligare initieras i dialogrutans OnInitDialog(). Här provas olika varianter.

Rullningslister

Tillämpning med rullningslist:

Projektet presenteras med avseende på hur det ska se ut och fungera.

Rubrikobjektet:

Vi manipulerar ett rubrikobjekt, ett så kallat static, och ändrar den text den innehåller till att visa rullningslistens inställning. Här använder vi även itoa(), vilket fanns som tilläggsfunktion i C, men är inbyggd i språket C++.

Meddelanden från CScrollBar:

En rullningslist är en komplex kontroll och hanteras inte på samma sätt som de vi tidigare lärt. De olika meddelanden den genererar diskuteras här, och vi ser hur man kan lägga upp kod som fångar upp händelser.

Bibehålla inställningar mellan anrop:

Vi har en litet annorlunda situation för ingående variabler, vilka håller inställningen, och överlagrar OnOK() för att spara inställningen.

MessageBox(), AfxMessageBox():

Vi ser hur AfxMessageBox() ersätter MessageBox() och lär oss mer om hur man kan göra inställningar via de argument man passerar till dessa funktioner, samt hur man kan avgöra vilken knappa användaren tryckt på när meddelanderutan innehåller fler än en.

Aktiv och Visa:

Här provar vi samma saker som vi gjorde med kryssrutan i föregående kapitel.

Övriga listkoder:

Här får eleven på egen hand resonera sig fram till hur man hanterar övriga meddelanden från CScrollBar.

Att hitta rätt list:

Windows har bara två meddelande för rullningslister, ett gäller de horisontella, och ett gäller de verikala. Med meddelandet förljer det data vi kalla rlistkoder, samt adressen till objektet för den rullningslist som användaren klickat på. Vi lär oss skilja på fler rullningslister av samma typ.

Listrutan

Programmet:

En annan komplex kontroll är listrutan. här presenteras ett program som utnyttjar en dylik. Vi skapar en kontrollvariabel för listrutan, och därigenom har vi direkt tillgång till metoder i objektet.

Variablerna:

Det är bara ett exempel. Data kommer från två CString-listor, en med namn och en med telefonnummer. Vi ser hur man kan fylla listrutan med namnen, och hur dessa sorteras om i bokstavsordning i stället för den ordning de finns i listan, vilket blir den ordning de matas in i.

Använda vald detalj.

Vi ser hur man kan koppla meddelande till radbyte, klick på rad, dubbelklick på rad etcetera. Vi gör så att dubbelklick öppnar en AfxMessageBox() som presenterar namnet tillsammans med motsvarande telefonuppgift. På grund av att listan är sorterad stämmer dock inte rad i listan med rad i CStrin-listorna, och vi får fram fel uppgift.

Att hitta rätt detalj:

Vi lär oss märka raderna med ett index som motsvarar radnummer i CString-listorna, samt att hämta dessa index vi dubbelklickt. Nu hittar vi rätt detalj.

Listrutans inbyggda textvariabler:

I andra applikationer kommer texterna kanske från annat håll, och vi finner kanske ingen anledning att lagra dem i CString-listor. Listrutan innehåller själv texterna, och därför kan vi utnyttja själva listrutan som en lagringsplats för de uppgifter den innehåller.

Component Gallery:

När vi skapar en klass till en ny dialog ser vi en markering som gör att den nya resursen sparas i Component Gallery. Där finns förutom resurser från våra egna projekt även en del resurser som Microsoft skänkt oss.

SendDlgItemMessage():

Före C++ kunde man också skriva windowsprogram. Det gick dock inte att skapa kontrollvariabler. Här tittar vi på den gamla metoden att arbeta med kontroller, via funktionen SendDlgItemMessage().

 Kontroller i programfönstret

CFormView, Olika vyklasser:

Vi tittar på hur man kan använda kontroller i programfönstret. Detta underlättas via ett antal klasser, och här ser vi hur man kan använda CFormView, och ett par sätt att åstadkomma den ändringen. Vi ser även vilka andra vyklasser som finns, samt på ett speciellt sorts projekt, Dialog Based, vilket är dialogbaserat, och inte har något dokument, och därför heller ingen vy.

CArchive

Notisar:

Här presenteras ett enkelt program där vi ser hur man kan spara uppgifter på disken med hjälp av klasser i MFC. Vi utnyttjar de färdiga menyval och funktioner som AppWizard bakat in åt oss, och det enda vi ser är egentligen klassen CArchive i en metod Serialize i dokumentet.

Variabler i dokumentklassen:

Vi deklarerar de variabler som behövs i dokumentklassen, för att dessa ska så att säga utgöra dokumentet. Det kan synas onödigt här, men detta ska likna de större projekten där dokumentet kan vara mycket stort, och vyn bara har variabler för en mindre del av dokumentet, eller refererar direkt till det.

Initiera vyvariabler, Uppdatera dokumentvariabler:

Vi skapar motsvarande variabler i vyn, mest för att vi ska kunna prova hur man uppdaterar mellan dokument och vy.

Spara/Öppna:

Att serialisera är enkelt, eftersom AppWizard redan gjort allt jobbet åt oss. I dokumentets metod Serialize() finns ett objekt 'ar', vilket används på samma sätt som cin och cout.

CFileDialog, CFile:

Vi ser på hur man kan öppna filvalsdialogrutan, och hur den används för att välja filnamn. Vi ser även hur man använder ett CFile-objekt tillsammans med ett CArchive-objekt när man serialiserar. Vi kommer att vidareutveckla detta i ett senare kapitel.

Att arbeta med listor

Telefonlistan:

Vi gör ett program liknande det i förra kapitlet, men i detta exempel arbetar vi med en lista i stället.

Klassen CTeleObjekt:

Här skapar vi en klass utan att använda ClassWizard. Detta på grund av att ClassWizard inte kan ärva från CObject, vilket vi måste göra för att få tillgång till serialisering.

 Klassen CObList:

Det finns ett antal färdiga listklasser i MFC, och den som passar bäst här heter CObList. Vi behöver inte ärva, utan skapar ett listobjekt direkt från denna klass, varvid vi har ett objekt som är en länkad lista med färdiga metoder för våra behov.

DeleteContents(), Vyklassens variabler, Koppla uppdateringar, Variablerna - en överblick:

Här är dokumentet för första gången kanska komplext, och vi går i flera steg igenom de variabler som finns i dokumentet respektiver vyn, inklusive listobjektet i dokumentet och de variabler som behövs i vyn för att hantera listan.

Knapparna '<' och '>', Knapparna 'Ny' och 'Ta Bort':

Vi fortsätter med att bläddra i listan, lägga till och ta bort poster. Detta sker från vyn, medan lista och poster finns i dokumentet.

Serialisering:

Vi ser hur klassen CObList är speciellt förberedd för att anropa metoden Serialize() i vart och ett av de objekt som lagrats i listan.

Tele utan dokument

Telefonlistan utan CDocument:

Vi löser samma problem som i föregående kapitel, men denna gång skapar vi ett dialogbaserat projekt. Ett dylikt har inget dokument och följaktligen heller ingen vy. I huvuddialogen skapar vi en gruppruta med knappar som ersätter arkivmenyn.

Klassen 'CTeleobjekt', Klassen 'CObList', DeleteContents():

Vi skapar samma klasser och objekt som i föregående kapitel, men vi kan inte lita till dokumentet längre, utan får lägga till diverse saker själva.

Koppla uppdateringar:

Allt finns i samma klass, programmets huvuddialogruta, så vissa hanteringar blir lättare, när man slipper hålla kontakten mellan dokument och vy.

Serialosering av lista:

Serialiseringen sker lika lätt genom ett arkivobjekt, men vi har inte objektet skapat och klart som fallet var när det fanns ett dokument. Vi måste själva öppna en filvalsdialogruta, CFileDialog, skapa ett filobjekt, CFile samt ett arkivobjekt, CArchive.

SetWindowText():

Dokumentets namn ska synas i titelraden. Tidigare skötte dokumentet detta, men nu måste vi göra det själva. Funktionen SetWindowText() hjälper oss här.

 CBitMap

Merlin:

I detta kapitel använder vi bitmapsbilder såväl i programfönstret som i menyvalen. Tillämpningen är ett enkelt spel, och eleven måste själv skriva en hel del logik, och slå upp ett och annat ihjälpen.

Bitmapsredigeraren:

Resursredigeraren klarar även bitmapsbilder. Här kan eleven välja mellan att rita själv, eller att prova resursredigerarens förmåga att 'stjäla' resurser, i det här fallet bilderna, från en .exe-fil. Programmet finns nämligen tillgängligt för såväl demonstration som just möjligheten att kopiera resurser.

Initiering, Visa bitmap:

Vi går igenom de steg som behövs för att visa en bild i programfönstret, eller egentligen vyns arbetsyta, och att se till så att den uppdateras när den varit skymd.

Fönstrets storlek och placering:

I det här programexemplet testar vi att tvinga programfönstret att ha en storlek som passar spelplanen. Om användaren försöker maximera fönstretså anpassas det igen. Om denne försöker att ändra storlek så återställs den rätta storleken.

Knapparna, Musknapp och position:

Vi placerar ut en upsättning tryckknappar på spelplanen. Dessa är inte objekt, utan bara bilder. När användaren klickar med höger musknapp i arbetsytan måste programkoden avgöra vilken knapp som tryckts.

PC-högtalaren:

Inget spel utan hacking. I det här fallet provar vi att direktadressera två hårdvaruenheter, den ena är en timerkrets, och den andra är PC-högtalaren. Resultatet blir att vi skapar en funktion som kan spela toner av olika längd och tonhöjd i PC:ns högtalare.

Menyerna, Bitmappar som menyval:

Vi lägger upp menyerna och lär oss bocka för respektive ta bort bock för menyval. Därefter byter vi de menyer som väljer lösningsmönster till bilder.

 Microsoft självstudier

Självstudier:

Microsoft har levererat ett antal mycket bra självstudier vilka belyser olika aspekter av Windowsprogrammering. Här finns mycket att göra och eleven arbetar med de han hinner med, och prioriterar själv vilken ordning studierna genomförs.

Scribble tutorial:

Eleven följer Microsofts självstudie steg för steg och lär sig följande moment: Använda listklass, multiple document, verktygsfält, statusrad, split-view samt implementera hjälp.

OLE Tutorials:

Eleven får skapa en egen OLE container-applikation, OLE Automation server, samt en OLE-kontroll, i tre olika självstudier.

ODBC/DAO:

Eleven provar i två olika självstudier att arbeta gentemot en databas via ODBC respektive DAO.

Windows 95:

Eleven provar i denna självstudie att utnyttja nya finesser i Windows 95.