Programmieren - GIS-Management

Programmieren
Prof. Dr.-Ing. Franz-Josef Behr
FACHHOCHSCHULE
HOCHSCHULE FÜR
STUTTGART
TECHNIK
Vermessung und Geoinformatik
1 Einleitung
Bisher sind haben wir unsere Klassen nur als einfaches Konsolenapplikationen implementiert. Dabei
haben wir die Möglichkeiten moderner Betriebssystemumgebungen (graphische Benutzeroberfläche)
nicht genutzt. Die Wiederverwendbarkeit blieb ausschließlich auf unsere eigenen Klassen beschränkt.
Bei der Nutzung von Visual C++ haben wir die Funktionalität und den Komfort unserer
Entwicklungsumgebung nur wenig ausgeschöpft. 1
Dies soll in den folgenden Arbeitsschritten geändert werden!
Wo wir uns bislang auf „selbst gebaute“ Klassen beschränkt haben, öffnet sich uns durch die
Verfügbarkeit der Microsoft Foundation Classes (kurz MFC), die uns die Windows-Funktionalität
wiederverwendbar und leicht anpassbar zu Verfügung stellt, eine völlig neue Dimension. Gepaart mit
sehr hilfreichen Funktionen unserer Entwicklungsumgebung gelingt es mit relativ wenig Aufwand,
fensterorientierte Anwendungen zu erstellen, die sich Windows -typisch verhalten.
Man unterscheidet zumindest drei Arten von Anwendungen:
? dialogfeldbasierende Anwendung (ein Fenster, kein Menü)
? SDI-Anwendung (Singe Document Interface, ein Fenster, mit Menüleiste)
? MDI-Anwendung (Multi Document Interface, mehrere Fenster, Menüleiste)
Das Objektklassenmodell der MFC zeigt Abbildung 1.
Die Klasse CObject ist für die meisten Klassen der Microsoft Foundation Class Library (MFC) die
Basisklasse. Die Klasse CObject enthält mehrere nützliche Eigenschaften, die Sie in Ihre eigenen
Programmobjekte übernehmen können, zum Beispiel Unterstützung der Serialisierung (Kap. 4.10),
Laufzeitinformationen über Klassen und Diagnoseausgaben für Objekte. Falls Sie Ihre Klasse von
CObject ableiten, kann die Klasse diese Fähigkeiten von CObject ausnutzen.
CCdmTarget stellt die Basis für die Empfängerlisten-Architektur der Bibliotheksklassen dar, d. h.
bietet die Zuordnung zwischen Nachrichten, Kommandos und den Methoden.
Weitere Klassen, die wir in abgeleiteter Form verwenden werden, sind die Klassen CDocument und
CView.
Hinter vielen Klassen verbergen sich Datentypen und Funktionalitäten des Windows-API. Sie
erkennen das an Klassennamen wie CPaintDC oder CBrush.
1 www.hilf.de/de/site/schulung/kurse/ mfc_programmierung_schulung.pdf
1

Programmieren mit der MFC
Abbildung 1: Objektklassenmodell der MFC-Bibliothek.
2 Erstellen einer einfachen dialogfeldbasierenden
Anwendung
Das nachfolgende Beispiel und der dazugehörige Text beruhen weitgehend auf dem Vorlesungsskript
Einführung in die Windows-Programmierung mit Visual C++ (MFC) von Prof. Schröder.
Im ersten Beispiel soll eine recht einfache Anwendung entwickelt werden.
Bevor Sie an die Code-Erstellung gehen, verschaffen Sie sich zunächst eine Überblick über das
gewünschte Aussehen und die Funktionalität:
Auf einem Dialogfenster befinden sich zwei Eingabeelemente über die die Länge und Breite eines
Rechtecks eingegeben werden kann. Nach Betätigung des Berechnen Knopfs wird die berechnete
Fläche in einem Ausgabeelement ausgegeben.
2

Programmieren mit der MFC
2.1 Projektgerüst erstellen
Abbildung 2: Zu entwickelnde Applikation.
Im ersten Schritt legen Sie ein neues Projekt an, indem Sie einen entsprechenden Pfad und einen
Projektnamen (im folgenden: WinFlaechenBerechnung) festlegen. Wählen Sie als Projektart MFC-
ANWENDUNGS-ASSISTENT (.EXE):
Wenn Sie den Anwendungs-Assistenten verwenden, müssen Sie in einigen Schritten verschiedene
Detailangaben zur Art des Programms machen
3

Programmieren mit der MFC
Im nächsten Schritt kann man sich zwischen verschiedenen Typen von Windows-Programmen
entscheiden. In diesem Beispiel beschränken wir uns auf ein dialogfeldbasiertes Programme, d. h. die
gesamte Applikation besteht nur aus einem Dialogfenster.
?
Welche Windowsapplikation kennen Sie, die nur aus einem Dialog bestehen?
4

Programmieren mit der MFC
5

Programmieren mit der MFC
6

Programmieren mit der MFC
In der Zusammenfassung können Sie nochmals Ihre Projekteinstellungen prüfen, um dann die
Erstellung des Codegerüstes mit OK einzuleiten.
2.2 Arbeitsbereich
2.2.1 Registerkarte Klassen
Die Registerkarte Klassen des Fensters Arbeitsbereich zeigt nach abgeschlossener Erstellung des
Codegerüsts die drei erstellten Klassen und ihre Elemente für alle Projekte des Arbeitsbereichs an. Der
fett gedruckte Ordnername bezeichnet die aktuelle Projektkonfiguration. Wenn Sie den Inhalt des
Projektordners einblenden, werden die zu diesem Projekt gehörenden Klassen angezeigt. Durch
Einblenden einer Klasse werden alle Elemente dieser Klasse angezeigt. Wenn Sie auf ein Element
doppelklicken, öffnet sich, wie Sie bereits aus vorangegangenen Übungen wissen, die entsprechende
Stelle im Quellcode.
7

Programmieren mit der MFC
Abbildung 3: Klassenansicht der erzeugten Applikation.
In unserem Projekt sehen Sie, dass CWinFlaechenberechnungDlg bereits mehrere Methoden besitzt
(Abbildung 3), allerdings noch (fast) keine Attribute. Außerdem gibt es die globale Variable theApp
(der Klasse CWinFlaechenberechnungApp).
2.2.2 Dateien-Ansicht
In der Dateien-Ansicht sehen Sie, das insgesamt bereits 11 Dateien zum Projekt gehören sowie eine
readme-Datei:
8

Programmieren mit der MFC
Abbildung 4: Dateien der erzeugten Applikation.
Der generierte Quellcode bildet bereits ein vollständiges Programm und kann übersetzt und ausgeführt
werden! Bei der Ausführung sehen Sie, dass das Programm sich wie ein übliches Windows-Programm
verhält:
? Sie können das Fenster verschieben
? Sie können mit der Tabulatortaste den Fokus zwischen den beiden Schaltflächen wechseln
? Sie können das Programm wie gewohnt beenden
? Nur, das Programm tut noch nichts! Aber das werden wir noch ändern...
2.2.3 Ressourcen-Ansicht
In der Ressourcen-Ansicht werden die Bildschirmelemente aufgelistet, aus denen das Programm
aufgebaut ist. Angezeigt werden die Identifier dieser Ressourcen:
? IDD_ABOUTBOX
? IDD_WINFLAECHENBERECHNUNG_DIALOG
9

Programmieren mit der MFC
Abbildung 5: Ressourcenansicht.
Die Identifier werden üblicherweise in großen Buchstaben geschrieben, stets beginnend mit ID.
Doppelklicken Sie auf den Identifier IDD_WINFLAECHENBERECHNUNG_DIALOG, so öffnet
sich ein neues Fenster: der Ressourcen-Editor.
Dieser besteht zum einen aus der Arbeitsfläche, auf der das Layout des Formulars entworfen wird (im
10

Programmieren mit der MFC
Moment ein Formular mit einem statischen Text und den beiden Schaltflächen OK und Abbrechen).
Zum anderen finden Sie den Werkzeugkasten mit den Steuerelementen (Abbildung 6).
2.3 Layout des Formulars
Abbildung 6: Verfügbare Steuerelemente.
Im nächsten Schritt werden Sie zunächst das Layout des Formulars zu entwerfen. Das Programm
erfordert folgende Steuerelemente:
? Dialogfenster (vorgegeben, ist zu verändern)
? Minimieren-Schaltfläche
? Maximieren-Schaltfläche
? zwei Schaltflächen (Beenden und Berechnung durchführen)
? statische Texte
? Eingabefelder
? ein Gruppenfeld (Rahmen mit Überschrift)
Passen Sie nun das Layout an. Ändern Sie dabei zunächst nicht die OK-Schaltfläche! Sie sollten
folgendes Ergebnis erzielen:
11

Programmieren mit der MFC
Zur Bearbeitung eines Elementes ist es zunächst durch einen Mausklick auszuwählen. Nun kann es
verschoben werden, seine Größe verändert werden oder durch die Entf-Taste gelöscht werden. Den
Eintrag ZU ERLEDIGEN: DIALOGFELD-STEUERELEMENTE HIER PLATZIEREN können Sie z. B. auf
diese Weise löschen.
Drückt man die ENTER-Taste, erhält man ein Eigenschaftsfenster, das ebenfalls über das Kontextmenü
(rechte Maustaste) zur Verfügung steht. Hier können weitere Eigenschaften verändert werden (z.B. die
Minimieren- und Maximieren-Schaltflächen als Eigenschaften des Dialogfensters). Mit einem
weiteren ENTER wird das Eigenschaftsfenster wieder geschlossen.
12

Programmieren mit der MFC
Beschreibung class = Typ ID
statische Texte CStatic – IDC_STATIC, keine
Änderung nötig –
Rahmen „Ergebnisse“ CStatic – IDC_STATIC, keine
Änderung nötig –
Eingabefeld Breite CEdit IDC_BREITE
Eingabefeld Länge CEdit IDC_LAENGE
Ausgabefeld Fläche CEdit IDC_FLAECHE
Schaltfläche „Berechnung...“ CButton IDC_BERECHNEN
Schaltfläche OK CButton IDOK
Setzen Sie außerdem das Ausgabefeld Fläche auf schreibgeschützt.
!
Experimentieren Sie mit den Funktionen, die über das Menü Layout zur Verfügung stehen!
13

Programmieren mit der MFC
2.4 Variablen hinzufügen
Als nächstes müssen wir dafür sorgen, dass das, was der Benutzer in die Eingabefelder eingibt, auch
beim Programm ankommt. Hierzu sind zwei Schritte erforderlich:
Definition von zwei Variablen, die mit den Eingabefeldern verbunden sind. Eingegeben werden
beliebige Zeichen, daher müssen die Variablen vom Typ „Zeichenkette“ sein. In der MFC gibt es
dafür einen speziellen Typ CString.
Ausgewertet werden sollen dagegen Zahlen. Also benötigen wir zwei weitere Variablen, die die
umgewandelten Zahlenwerte aufnehmen sollen. Diese Variablen sind nicht direkt mit den
Eingabefeldern verknüpft.
Eingabefeld ID Edit-Variable Ziel-Variable
Breite IDC_BREITE m_strBreite m_dBreite
Länge IDC_LAENGE m_strLaenge m_dLaenge
Die erste Art von Variablen lässt sich am schnellsten mit dem Klassenassistenten definieren. Sie
finden ihn unter ANSICHT | KLASSEN-ASSISTENT bzw. mit dem Tastaturkürzel STRG+W.
Wählen Sie die Registerkarte MEMBER-VARIABLEN. Tragen Sie anschließend für Breite
(IDC_BREITE) bzw. Länge (IDC_LAENGE) jeweils eine passende Variable ein:
14

Programmieren mit der MFC
Beachten Sie die Schreibweise der Variablen. Da es sich um Objektvariablen handelt, beginnt der
Name jeweils mit m_ (Objektvariablen werden in C++ auch als Member bezeichnet), gefolgt von einer
Kurzbezeichnung des Datentyps (ungarische Notation). Dann folgt erst der eigentliche Name, str steht
dabei für CString, d für double (später verwendet).
Danach können Sie den Klassen-Assistenten wieder schließen.
Für die zweite Gruppe von Variablen ist eine andere Vorgehensweise erforderlich. Diese können im
linken Klassenansichtsfenster hinzugefügt werden. Expandieren sie zunächst die Klasse
CWINFLAECHENBERECHNUNGDLG. Sie sehen dort die im vorherigen Schritt hinzugefügten Variablen.
Klicken Sie nun mit der rechten Maustaste auf die Klassenbezeichnung
CWINFLAECHENBERECHNUNGDLG. Aus dem Pop-up-Menü wählen Sie MEMBER-VARIABLE
HINZUFÜGEN..., was Ihnen ja von der Implementierung von Objektklassen her bekannt ist.
Geben Sie die Namen für die neuen Variablen ein und ihren Datentyp double. Belassen Sie den
Zugriffsstatus auf public.
Bei der Namensgebung empfiehlt es sich, sich an folgende Konvention zu halten: Der Name beginnt
mit dem Präfix m_, gefolgt vom Buchstaben d für double, gefolgt vom eigentlichen Namen:
15

Programmieren mit der MFC
2.5 Ereignissteuerung
Um das Zusammenspiel der bisher definierten Elemente zu verstehen, müssen wir einen Blick auf die
Arbeitsweise von Windows werfen:
? Jedes Windows-Programm ist eine Ansammlung von Fenstern und Steuerelementen, wobei selbst
Steuerelemente wie „kleine Fenster“ betrachtet werden können 2 .
? Windows übernimmt komplett die Kommunikation mit der Tastatur und der Maus.
? Auf der Tastatur getippte Zeichen beziehen sich stets auf ein Fenster (oder Steuerelement), man
sagt dieses Fenster hat den Fokus. Sie erkennen den Fokus in einem Eingabefeld am senkrechten
Strich (den Texteingabecursor), bei einer Schaltfläche an der doppelten Umrandung.
? Man kann den Fokus mit Hilfe der Maus oder der Tabulator-Taste auf ein anderes Element
wechseln.
? Jede Aktion des Benutzers wie ein Tastendruck, Ziehen der Maus, Mausklick, etc. löst in Windows
ein Ereignis aus 3 . Windows notiert dabei
o wo das Ereignis ausgelöst wurde (z.B. über der Schaltfläche mit der ID
IDC_BERECHNEN)
o was passiert ist (z.B. linke Maustaste wurde gedrückt: BN_CLICKED)
? Anschließend schaut Windows in einer Tabelle (MESSAGE_MAP) nach, zu welchem Ereignis
(wo, was) welches Unterprogramm aufgerufen werden soll 4 .
Ein Teil dieser Ereignisse und der zugehörigen Unterprogramme ist bereits durch den
Anwendungsassistenten definiert. Man kann Sie sich im Klassenassistenten unter der Registerkarte
Nachrichtenzuordnungstabelle ansehen.
2 vgl. Skript: Windows-Programmierung mit dem Windows-API.
3 Ereignisse (Events) sind also Tastatur-Eingaben, Mausbewegungen, Betätigung einer Maustaste, Zeitgeber-
Ereignisse; vgl. Skript: Windows-Programmierung mit dem Windows-API.
4 In den Beispielen mit Windows-API haben wir diese Zuordnung selbst in der Form von Nachrichtenschleifen
kennengelernt.
16

Programmieren mit der MFC
Diese Registerkarte ist dreiteilig aufgebaut. Links oben werden die IDs der Steuerelemente angezeigt
(das „Wo“), rechts daneben die Liste der möglichen Nachrichten (das „Was“) und im unteren Bereich
die zugeordneten Methoden.
Über den Klassenassistenten können auch weitere Methoden zugeordnet werden. Dies soll an einem
Beispiel gezeigt werden, in dem zunächst einmal das „merkwürdige“ Verhalten unseres Dialogfensters
korrigiert werden soll, auf die Eingabe von Enter mit dem Ende des Programms zu reagieren, auch
wenn der Fokus z.B. auf einem Eingabefeld liegt. Der Grund dafür ist, dass ein Drücken der Enter-
Taste das Ereignis ONOK auslöst, das eigentlich zu unserem OK-Knopf gehört. Der OK-Knopf
beendet jedoch das Programm. Wenn wir dies verhindern wollen, müssen wir eine Methode dazu
schreiben, die nichts tut.
Rufen Sie dazu den Klassen-Assistenten auf, gehen Sie das was (BN_CLICKED) und wo (IDOK) an
und wählen Sie nacheinander FUNKTION HINZUFÜGEN und CODE BEARBEITEN. Den Namensvorschlag
(OnOK) können Sie übernehmen. Nach Auswahl von Code bearbeiten springt Visual C++ in den
Code-Editor zur ausgewählten Methode. Wie Sie sehen, enthält diese Methode nur eine einzige Zeile
ausführbaren Code. Aus der Oberklasse unseres Dialogfensters (CDialog) wird die Methode OnOK()
aufgerufen, die für die Beendigung des Programms sorgt. Diese Zeile kommentieren Sie einfach aus!
17

Programmieren mit der MFC
Wichtig: Danach bearbeiten Sie noch einmal den OK-Button in unserem Dialogfenster. Setzen Sie
18

Programmieren mit der MFC
seine ID auf IDC_BEENDEN und seine Beschriftung auf „Beenden“.
Auf die gleiche Weise fügen Sie mit dem Klassen-Assistenten Methoden für folgende Ereignisse ein,
deren Code im Anschluss eingearbeitet wird:
Objekt-ID Nachricht Name der Methode
IDC_BREITE EN_KILLFOCUS OnKillfocusBreite
IDC_LAENGE EN_KILLFOCUS OnkillfocusLaenge
IDC_BERECHNEN BN_CLICKED OnBerechnen
2.6 Methoden mit Anweisungen füllen
Anschließend müssen die Methoden noch mit Leben, sprich mit Anweisungen, gefüllt werden. Die
einzelnen Methoden können entweder vom Klassen-Assistenten aus oder von der Klassenansicht aus
in den Text-Editor geholt werden.
Die Methode CWinFlaechenBerechnungDlg::OnKillfocusBreite() wird aufgerufen,
wenn das zugehörige Eingabefeld den Fokus verliert, die Eingabe in diesem Steuerelement also
beendet ist.
void CWinFlaechenBerechnungDlg::OnKillfocusBreite()
{
// TODO: Code für die Behandlungsroutine der Steuerelement-
Benachrichtigung hier einfügen
}
Leider sind eingegebene Daten nicht automatisch in die zugehörige Variablen gewandert, sondern
stehen noch unter Kontrolle von Windows. Sie müssen erst durch spezielle Funktionen ausgelesen
werden:
void CWinFlaechenBerechnungDlg::OnKillfocusBreite()
{ GetDlgItemText( IDC_BREITE, m_strBreite); // Wert aus Control
holen
m_dBreite = atof(m_strBreite); // in double-Wert konvertieren
}
m_dBreite = ((long int) (10.0 * m_dBreite)) / 10.0;
m_strBreite.Format("%2.1f", m_dBreite);
SetDlgItemText( IDC_BREITE, m_strBreite);
Die Methode CWindow::GetDlgItemText liest den eingegebenen Text aus dem Eingabefeld aus.
Dieser wird in die Zeichenkettenvariable m_strBreite gespeichert, und dann mittels atol() als
double-Wert in unsere Variable m_dBreite übertragen. Danach wird der Wert auf eine
Nachkommastelle gerundet, zurück in die Zeichenkettenvariable übertragen und in das Steuerelement
gesetzt.
19

Programmieren mit der MFC
Implementieren Sie nun die entsprechende Methode für das Längeneingabefeld.
In die Methode CWinFlaechenBerechnungDlg::OnBerechnen() fügen wir den eigentlichen
Berechnungscode ein:
void CWinFlaechenBerechnungDlg::OnBerechnen()
{
double flaeche = m_dBreite * m_dLaenge;
CString ergebnis;
}
ergebnis.Format( "%4.2f", flaeche);
SetDlgItemText( IDC_FLAECHE, ergebnis);
Jetzt können Sie das Programm übersetzen und ausführen. Bis auf einige „Macken“ sollte das
Programm seine Aufgabe erfüllen.
2.7 Verbesserungen des ersten Beispielprogramms
Das erste Beispielprogramm funktioniert zwar, weist aber noch einige Mängel auf:
? Nach einer Berechnung lassen sich die Eingabefelder ändern, wodurch ein völlig falscher
Zusammenhang entstehen kann
? Obwohl am Anfang noch keine Daten eingegeben sind, lässt sich der Berechnungsknopf anklicken
? ...
2.7.1 Standardaktion für ENTER setzen
Das Programm reagiert auf zwei Aktionen in gleicher Weise:
• Das Drücken der ENTER-Taste löst das Signal OK aus
• Das Anklicken des Beenden-Knopfes löst ebenfalls das Signal OK aus
Dies liegt daran, dass als Eigenschaft der Schaltfläche Beenden, auf der Registerkarte Formate, diese
als Standardschaltfläche definiert ist. Beseitigen Sie diese Einstellung!
2.7.2 Reihenfolge der Felder festlegen
Mit der Tabulator-Taste kann man die einzelnen Elemente des Dialogs durchlaufen. Die Reihenfolge
der einzelnen Elemente kann man im Menüpunkt LAYOUT -> TABULATORREIHENFOLGE festlegen.
Man ruft den Menüpunkt auf und klickt die einzelnen Elemente mit der Maus an.
20

Programmieren mit der MFC
Man beendet diese Arbeit mit der ENTER- oder der ESC-Taste.
2.7.3 Der Fokus und zugehörige Ereignisse
Wie erwähnt, besitzt stets genau ein Steuerelement den Fokus, d.h. es ist virtuell mit der Tastatur
verbunden. Ist es ein Eingabefelder, so enthält es den Cursor und alle Tastendrücke gehen als Zeichen
in dieses Feld. Ist es eine Schaltfläche, so ist dieser durch eine doppelte Linie gekennzeichnet und
reagiert eigentlich nur auf die ENTER-Taste.
In beiden Fällen sagt man, das betreffende Element habe den Fokus. Windows generiert nun zwei
Ereignisse in Bezug auf den Fokus eines jeden Elements:
? Das Ereignis EN_SETFOCUS wird erzeugt, wenn ein Element den Fokus erhält,
? Das Ereignis EN_KILLFOCUS wird erzeugt, wenn ein Element den Fokus abgibt.
Will man, dass das Programm auf diese Ereignisse reagiert, so muss man für jedes Steuerelement und
jedes Ereignis mit Hilfe des Klassenassistenten eine Methode erzeugen. Dabei schlägt der Klassen-
Assistent passende Namen, die man i.a. akzeptiert.
Beispiel:
Element Identifier Methode für
EN_SETFOCUS
Methode für
EN_KILLFOCUS
Breite IDC_BREITE OnSetfocusBreite OnKillfocusBreite
Länge IDC_LAENGE OnSetfocusLaenge OnKillfocusLaenge
Hier haben wir eine Möglichkeit, das Problem der nachträglich geänderten Eingabewerte zu lösen:
Jedes Mal, wenn Länge oder Breite den Fokus erhält, wird das Rechenergebnis gelöscht:
void CWinFlaechenBerechnungDlg::OnSetfocusBreite()
{
21

Programmieren mit der MFC
// TODO: Code für die Behandlungsroutine der Steuerelement-
Benachrichtigung hier einfügen
SetDlgItemText(IDC_FLAECHE, "");
}
2.7.4 Eingabeprüfung
Fehlerhafte Eingaben sollten möglichst auf die Eingaberoutine beschränkt bleiben. Um fehlerhafte
Eingaben abzufangen, verwendet man in der prozeduralen Programmierung eine annehmende
Schleife, die solange durchlaufen wird, bis die Eingabe akzeptiert wird.
Hier wird ähnlich vorgegangen. Die Überprüfung der Eingabe erfolgt in der Killfocus-Methode. Ist sie
nicht korrekt, so setzen wir den Fokus zurück auf dasselbe Steuerelement. Dazu modifizieren wir die
Methode CWinFlaechenBerechnungDlg::OnKillfocusBreite()
void CWinFlaechenBerechnungDlg::OnKillfocusBreite()
{
GetDlgItemText(IDC_BREITE, m_strBreite);
m_dBreite = atof(m_strBreite);
m_dBreite = ((long int) (10.0 * m_dBreite)) /10.0;
if (m_dBreite SetFocus();
}
else
{ m_strBreite.Format("%2.1f", m_dBreite);
SetDlgItemText(IDC_BREITE, m_strBreite);
}
}
Die Methode Setfocus() ist eine Memberfunktion der Klasse CWnd. Alle Steuerelemente der MFC
haben diese Klasse als Basisklasse, d.h. alle Steuerelemente erben die Methode Setfocus() und können
sie jederzeit benutzen. Um sie aufrufen zu können, brauchen wir jedoch einen Zeiger auf das
Steuerelement, welchem wir den Fokus geben möchten. Wir definieren dafür einen Zeiger pF vom
Typ Cwnd *, den Wert für den Zeiger liefert uns der Aufruf der Funktion GetDlgItem.
Der dann folgende Aufruf von Setfocus() bewirkt, dass der Fokus auf das Steuerelement mit dem
Identifier IDC_BREITE zurückgesetzt wird.
Passen Sie nun in die Methode CWinFlaechenBerechnungDlg::OnKillfocusHoehe()
entsprechend an!
Wenn wir diese Methode auf beide Eingabefenster anwenden wollen, erhalten wir jedoch ein recht
verwirrendes Ergebnis, bitte probieren Sie es aus! Für ein wirklich benutzerfreundliches Programm
müssen wir uns daher etwas anderes einfallen lassen.
?
Wie können Sie es sicherstellen, dass die Benutzereingabe sinnvoll funktioniert?
22

Programmieren mit der MFC
2.7.5 Fehlermeldungen ausgeben
Bei der obigen Eingabeüberprüfung haben wir auch kennen gelernt, wie man eine einfache
Fehlermeldung ausgeben kann. Die Funktion MessageBox() hat wahlweise 1, 2 oder 3 Parameter.
Der erste Parameter gibt den auszugebenden Text an, der zweite den Titel des Fensters. Der dritte
Parameter bewirkt, dass in der Messagebox noch ein Icon erscheint. Zugelassene Parameter sind
hierfür:
• MB_ICONHAND
• MB_ICONQUESTION
• MB_ICONEXCLAMATION
• MB_ICONINFORMATION
Probieren Sie die verschiedenen Optionen aus!
3 Die Ausführung eines Dialogprogramms
Vom klassischen C her, bzw. von den bisher verwendeten Konsolenprogramm her, wissen wir, dass
die Ausführung eines Programms immer mit der main-Funktion beginnt. Bei Windows-Programmen
ist es etwas komplizierter.
Jedes Programm, das Sie mit Hilfe der MFC erstellt haben, enthält ein einziges Anwendungsobjekt,
dass von der Klasse CWinApp abgeleitet ist.
Abbildung 7: Ableitungshierarchie unserer Anwendungsklasse .
Dieses Objekt muss global deklariert sein und darf in einem Programm nur ein einziges Mal
vorkommen. Die Header-Datei unseres Projektes enthält die Klassendefinition für unser
Anwendungsobjekt, die als Member-Funktion aber nur den Konstruktor enthält.
// CWinFlaechenBerechnungApp:
// Siehe WinFlaechenBerechnung.cpp für die Implementierung dieser
Klasse
//
23

Programmieren mit der MFC
class CWinFlaechenBerechnungApp : public CWinApp
{
public:
CWinFlaechenBerechnungApp();
// Überladungen
// Vom Klassenassistenten generierte Überladungen virtueller
Funktionen
//{{AFX_VIRTUAL(CWinFlaechenBerechnungApp)
public:
virtual BOOL InitInstance();
//}}AFX_VIRTUAL
// Implementierung
//{{AFX_MSG(CWinFlaechenBerechnungApp)
// HINWEIS - An dieser Stelle werden Member-Funktionen
vom Klassen-Assistenten eingefügt und entfernt.
// Innerhalb dieser generierten Quelltextabschnitte
NICHTS VERÄNDERN!
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
In der dazu gehörigen Implementierungsdatei wird das globale Anwendungsobjekt deklariert.
///////////////////////////////////////////////////////////////////
// Das einzige CWinFlaechenBerechnungApp-
ObjektCWinFlaechenBerechnungApp theApp;
Das von CWinApp abgeleitete,a mit globalem Gültigkeitsbereich angelegte Objekt kümmert sich um
die Initialisierung der Anwendung und um die Hauptereignisschleife des Programms. Die Klasse
enthält eine Reihe von Eigenschaften und Methoden, die meisten sind jedoch eher uninteressant für
den normalen Programmierer. Hier in unserem Beispiel wurde nur die Methode InitInstance()
überschrieben.
Warum wird dieses Objekt global angelegt?
Jedes MFC Programm muss eine von CWinApp abgeleitete Klasse deklarieren und ein
entsprechendes globales Objekt definieren. Durch diese globale Definition des Objektes wird dessen
Konstruktor (und der der übergeordneten Klasse CWinApp) noch ausgeführt bevor die WinMain()
Funktion im MFC-Rahmen aufgerufen wird. Dadurch erhält das Objekt die Möglichkeit seine Daten
vor dem Eintritt in die WinMain() Funktion zu initialisieren. Die WinMain() Funktion im MFC-
Rahmen (eigentlich heißt die Funktion AfxWinMain(...)) ruft nach der Initialisierungsphase
irgendwann die Methode InitInstance(...) des Anwendungsobjektes auf. Und innerhalb
dieser Methode wird dann das Hauptfenster der Anwendung erstellt 5 .
Die Aufgabe des Anwendungsobjektes ist es, die Anwendung zu initialisieren und zu kontrollieren. Da
Windows es erlaubt, dass mehrere Instanzen der selben Anwendung laufen, ist die Initialisierung in
5 Quelle: http://www.cpp-tutor.de/mfc/mfc/kap3/lektion2.htm
24

Programmieren mit der MFC
der MFC in zwei Methoden aufgeteilt - InitApplication() und InitInstance(). Hier bei
unserem einfachen Beispiel wird nur die Methode InitInstance() verwendet. Sie wird jedes Mal
aufgerufen, wenn eine neue Instanz der Anwendung erzeugt wird.
In dieser Methode laufen verschiedene Dinge ab.
Es wird ein Objekt unseres (Haupt-) Dialogs erstellt.
CWinFlaechenBerechnungDlg dlg;
Dieses Objekt wird der Objektvariablen – einem Zeiger – zugewiesen:
m_pMainWnd = &dlg;
Diese Membervariable, die von der Klasse CWinThread geerbt wurde, enthält das Hauptfenster
unserer Applikation. Sie ist von Typ „Zeiger auf CWnd“, wobei CWnd wiederum von CCmdTarget
abgeleitet ist..
Die Klasse CWnd enthält die Grundeigenschaften aller Fenster. Von CWnd ist unter anderem die
Klasse CFrameWnd abgeleitet. CFrameWnd – hier nicht verwendet! - erweitert CWnd um
Eigenschaften wie z.B. die Menüleiste.
CCmdTarget verleiht den von ihr abgeleiteten Klassen die Eigenschaft Nachrichten verarbeiten zu
können.
Das Dialogfenster wird angezeigt, indem für das dlg-Objekt die DoModal()-Funktion aufgerufen
wird. Dieser Aufruf bewirkt bereits die gesamte Ausführung des Dialogs:
int nResponse = dlg.DoModal();
if (nResponse == IDOK)
{
// ZU ERLEDIGEN: Fügen Sie hier Code ein, um ein
Schließen des
// Dialogfelds über OK zu steuern
}
else if (nResponse == IDCANCEL)
{
// ZU ERLEDIGEN: Fügen Sie hier Code ein, um ein
Schließen des
// Dialogfelds über "Abbrechen" zu steuern
}
Nach Beendigung des Dialogs liefert der ganzzahlige Rückgabewert Auskunft darüber, ob der Dialog
mit OK oder mit Cancel verlassen wurde (IDOK bzw. IDCANCEL).
Dabei ist zu beachten, dass das OK-Ereignis normalerweise auch vom Drücken der ENTER-Taste
ausgelöst wird (von uns abgeklemmt), das Cancel-Ereignis dagegen auch vom Drücken der ESC-Taste
und des Cancel-Kreuzes rechts oben im Fenster.
25

Programmieren mit der MFC
4 Eine SDI-Anwendung
4.1 Dokumente und Ansichten
Windows-Anwendungen sind vielfach durch ein Zusammenspiel von Doc- und View-Klassen geprägt.
Während der Begriff Ansichten (View) einen Hinweis auf die bildhafte Darstellung von Daten gibt, ist
die Bezeichnung Dokumente (Doc) vielleicht nicht selbsterklärend. "Doc" enthält die Daten (Zahlen,
Texte, ...), die "View" bildlich darstellt. "Doc" stellt auch einen Mechanismus zur Verfügung, der für
das Schreiben und Lesen der Daten in Dateien sorgt – die sogenannte Serialisierung.
Dafür bietet "View" die Möglichkeit, die Ansicht der Daten nicht nur auf den Bildschirm, sondern
auch z.B. auf einen Drucker auszugeben. "View" stellt darüber hinaus den Kontakt mit den
Benutzereingaben her (Maus-, Tastatureingaben, ...).
Für den Rahmen um "Doc" und "View" sorgt eine Rahmenfensterklasse, z.B. CFrameWnd.
"Doc" beruht auf der Klasse CDocument und "View" auf der von CWnd abgeleiteten Klasse CView
(vergleichen Sie dazu nochmals Abbildung 1). Der Wirkmechanismus der Dokumentvorlagen ist in
der abstrakten MFC-Klasse CDocTemplate enthalten. Diese Klasse wird nicht direkt benutzt,
sondern die davon abgeleiteten Klassen CSingleDocTemplate für SDI und
CMultiDocTemplate für MDI.
Zusätzlich benötigt man eine von CWinApp abgeleitete Anwendungsklasse.
Durch diese Architektur wird die Trennung von Dokument und Ansicht erreicht.
26

Programmieren mit der MFC
Nachfolgend ist die Klassenhierarchie (von links nach rechts) für eine SDI-Anwendung dargestellt:
4.2 Beispielprogramm
Das folgende Beispiel entstammt weitgehend Gurewich (1997). Wir legen dazu ein neues Projekt
namens WinCircle an. Wie im vorausgegangenen Beispiel ist es wieder ein Projekt des Typs MFC-
ANWENDUNGSASSISTENT (EXE). Allerdings wählen wir nun Einzelnes Dokument (SDI) mit
UNTERSTÜTZUNG DER DOKUMENT-/ANSICHT-ARCHITEKTUR.
Wir verzichten auf Datenbankunterstützung...
27

Programmieren mit der MFC
und auf die Unterstützung für Verbundinstrumente
28

Programmieren mit der MFC
29

Programmieren mit der MFC
In Schritt 6 zeigt der Assistent dann die zu erstellenden Klassen: Sie erkennen die vier Grundlagen,
auf denen die Anwendung beruht:
? Ansicht (View),
? Daten (Doc),
? Fenster (MainFrame) und
? Anwendung (App).
Es ist wichtig, sich diese Unterteilung gut einzuprägen, damit Sie beim Programmieren die Übersicht
behalten!
30

Programmieren mit der MFC
Die Anwendung ist erzeugt und bereits lauffähig. Der Assistent hat seine Arbeit geleistet. Inspizieren
Sie das Ergebnis im Arbeitsbereichsfenster!
31

Programmieren mit der MFC
Sie haben aber vielleicht mehr oder etwas anderes als Sie wirklich brauchen oder wollen. Führen Sie
das Programm aus! Welche Funktionalitäten sind bereits darin enthalten?
32

Programmieren mit der MFC
4.3 Der Source im Detail
Sie können gedanklich das Rahmenfenster von oben nach unten in fünf Zonen einteilen:
1. Systemmenü (auch Fenstermenü genannt)
2. Menü
3. Symbolleiste (Tool Bar)
4. Client-Bereich
5. Statusleiste (Status Bar)
Suchen Sie nun dazu den Bezug im Sourcecode!
Beginnen wir mit der Klassendefinition unserer von CFrameWnd 6 abgeleiteten Klasse CMainFrame.
Dort entdecken wir unsere Statusleiste und Symbolleiste in folgenden Member-Variablen: 7
protected: // Eingebundene Elemente der Steuerleiste
6 CFrameWnd erweitert CWnd um Eigenschaften wie z.B. die Menüleiste, die wie ja beim Anlegen des
Projektes angefordert hatten..
7 Quelle: http://www.henkessoft.de/mfc_einsteigerbuch_kapitel7.htm
33

Programmieren mit der MFC
CStatusBar m_wndStatusBar;
CToolBar m_wndToolBar;
Darüber hinaus gibt es dort auch folgende Struktur für unser Rahmenfenster:
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
In den nachfolgenden Abschnitten sehen wir, wie Änderungen
4.3.1 Änderung der Toolbar
Das ist leicht, da müssen wir einfach die drei Zeilen, wie angegeben, durch einen Kommentar (im C-
Stil) streichen. Kommentieren Sie auf jeden Fall aus, also nicht wirklich wegstreichen, es sei denn Sie
kennen die drei Zeilen auswendig.
/* m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
EnableDocking(CBRS_ALIGN_ANY);
DockControlBar(&m_wndToolBar);*/
4.3.2 Entfernen der Toolbar
Auch die Erzeugung der Toolbar wird auskommentiert.
4.3.3 Keine Statusleiste
Wir wollen keine Statusleiste, jedoch eine Symbolleiste: Dazu "streichen" wir nur den nachstehenden
Block. Die Teile für die Symbolleiste belassen wir aktiv.
/*
if (!m_wndStatusBar.Create(this) ||
!m_wndStatusBar.SetIndicators(indicators,
sizeof(indicators)/sizeof(UINT)))
{
TRACE0("Statusleiste konnte nicht erstellt werden\n");
}
*/
return -1;
4.3.4 Kein Menü
// Fehler bei Erstellung
Um das Menü zu entfernen, ergänzen Sie die Methode
CMainFrame::PreCreateWindow(...):
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
if ( cs.hMenu != NULL )
{
::DestroyMenu( cs.hMenu ); // Geladenes Menü entfernen
cs.hMenu = NULL; // Rahmenfenster hat kein Menü
34

Programmieren mit der MFC
}
if( !CFrameWnd::PreCreateWindow(cs) )
return FALSE;
// ZU ERLEDIGEN: Ändern Sie hier die Fensterklasse oder das
Erscheinungsbild, indem Sie
// CREATESTRUCT cs modifizieren.
}
return TRUE;
4.3.5 Ändern der Fenstergröße
Ergänzen Sie die Methode CMainFrame::PreCreateWindow(...):
cs.cx = 300; // Breite
cs.cy = 200; // Höhe
4.3.6 Systemmenü modifizieren
Fügen Sie in die Methode CMainFrame::OnCreate(...) den folgenden Code ein, um den Eintrag
Schließen zu disablen:
CMenu* pSystemMenu = GetSystemMenu(FALSE);
pSystemMenu->EnableMenuItem( SC_CLOSE, MF_GRAYED );
4.3.7 Ändern der Statusleiste
Das Objekt "Statusleiste" ist eine Instanz der Klasse CStatusBar. In der Klasse CMainFrame wird
dieses Objekt als Member-Variable definiert.
protected: // Eingebundene Elemente der Steuerleiste
CStatusBar m_wndStatusBar;
In der Datei MainFrm.cpp finden wir das globale statische UINT-Array indicators, das die Inhalte der
Statusleiste definiert:
35

Programmieren mit der MFC
// CMainFrame
...
static UINT indicators[] =
{
ID_SEPARATOR,
ID_INDICATOR_CAPS,
ID_INDICATOR_NUM,
ID_INDICATOR_SCRL,
};
// Statusleistenanzeige
Für japanische Tastaturen gibt es zusätzlich die Kana-Taste ( ID_INDICATOR_KANA,
Anzeige:"KANA" ).
Wir bauen dies zur Verdeutlichung in unsere Anwendung ein:
static UINT indicators[] =
{
ID_SEPARATOR,
ID_INDICATOR_CAPS,
ID_INDICATOR_NUM,
ID_INDICATOR_SCRL,
ID_INDICATOR_KANA,
};
Somit haben wir ein weiteres Indikatorfeld!
In der Funktion CMainFrame::OnCreate(...) wird die Statusleiste mittels CStatusBar::Create(...)
erzeugt, und die Funktion CStatusBar::SetIndicators(...) ordnet das Array indicators der Statusleiste
zu.
if (!m_wndStatusBar.Create(this) ||
!m_wndStatusBar.SetIndicators(indicators,
sizeof(indicators)/sizeof(UINT)))
{
TRACE0("Statusleiste konnte nicht erstellt werden\n");
return -1; // Fehler bei Erstellung
}
In der Statusbar steht links das Wort „Bereit“. Sie können ihn auf individuelle Bedürfnisse anpassen,
in dem Sie diesen Text in der String Table unter der Bezeichnung AFX_IDS_IDLEMESSAGE
modifizieren.
4.4 Die Datenelemente der Dokumentklasse deklarieren
Die Dokumentklasse ist für Ihre Daten zuständig, einschließlich ihrer Speicherung des des
Wiedereinlesens.
36

Programmieren mit der MFC
class CWinCircleDoc : public CDocument
{
protected: // Nur aus Serialisierung erzeugen
CWinCircleDoc();
DECLARE_DYNCREATE(CWinCircleDoc)
// Attribute
public:
// Operationen
public:
// Überladungen
// Vom Klassenassistenten generierte Überladungen virtueller
Funktionen
//{{AFX_VIRTUAL(CWinCircleDoc)
public:
virtual BOOL OnNewDocument();
virtual void Serialize(CArchive& ar);
//}}AFX_VIRTUAL
// Implementierung
public:
virtual ~CWinCircleDoc();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected:
// Generierte Message-Map-Funktionen
protected:
//{{AFX_MSG(CWinCircleDoc)
// HINWEIS - An dieser Stelle werden Member-Funktionen
vom Klassen-Assistenten eingefügt und entfernt.
// Innerhalb dieser generierten Quelltextabschnitte
NICHTS VERÄNDERN!
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
Erweitern Sie den public-Bereich um die zwei Member-Variablen, die zur Speicherung der
Koordinaten eines Kreises benötigt werden.:
int m_PosX;
int m_PosY;
4.5 Die Datenelemente der Viewklasse deklarieren
Die Definition der Klasse CWinCircleDOC wird als nächstes um zwei Attribute erweitert:
37

Programmieren mit der MFC
int m_PosX;
int m_PosY;
Diese Datenelemente sind ein Spiegelbild der Datenelemente, die Sie der Dokumentklasse
hinzufügten. Legt das Dokument fest, dass ein Kreis an einer bestimmten X- / Y-Position zu zeichnen
ist, zeigt der Code der Viewklasse den Kreis an der spezifizierten Position an.
4.6 Die Datenelemente der Dokumentklasse initialisieren
Datenelemente sind immer entsprechend zu initialisieren. Öffnen Sie dazu die Datei
WinCircleDoc.cpp und ergänzen Sie darin die Funktion CCircleDoc::OnNewDocument():
BOOL CCircleDoc::OnNewDocument()
{
if (!CDocument::OnNewDocument())
return FALSE;
// ZU ERLEDIGEN: Hier Code zur Reinitialisierung einfügen
// (SDI-Dokumente verwenden dieses Dokument)
////////////////////////
// EIGENER CODE, ANFANG
////////////////////////
// Die Datenelemente des Dokuments initialisieren
m_PosX = 200;
m_PosY = 100;
////////////////////////
// EIGENER CODE, ENDE
////////////////////////
}
return TRUE;
4.7 Die Datenelemente der Viewklasse initialisieren
Wir werden diese Member-Variablen der Dokumentenklasse nun initialisieren. Öffnen Sie dazu den
Klassenassistenten:
38

Programmieren mit der MFC
Fügen Sie für die Objektklasse CWinCircleView und die Objekt-ID CWinCircleView für die
Nachricht OnInitialUpdate eine Funktion hinzu. Visual C++ fügt daraufhin die Funktion
OnInitialUpdate() hinzu.
Drücken Sie die Schaltfläche CODE BEARBEITEN. Erweitern Sie die Methode gemäß nachfolgendem
Beispiel:
// CWinCircleView Nachrichten-Handler
void CWinCircleView::OnInitialUpdate()
{
CView::OnInitialUpdate();
// TODO: Speziellen Code hier einfügen und/oder Basisklasse
aufrufen
////////////////////////
// EIGENER CODE, ANFANG
////////////////////////
// Einen Zeiger auf das Dokument ermitteln
CWinCircleDoc* pDoc = GetDocument();
// Die Datenelemente der Viewklasse mit den
// entsprechenden Dokument-Werten aktualisieren
m_PosX = pDoc->m_PosX;
m_PosY = pDoc->m_PosY;
// EIGENER CODE, ENDE
}
39

Programmieren mit der MFC
Wie der Name deutlich macht, ist diese Elementfunktion für die Initialisierung der Datenelemente in
der Viewklasse zuständig. Wies Sie sehen, werden diese mit den aktuellen Werten der Datenelemente
der Dokumentklasse über die pDoc-Zeigervariable initialisiert, dessen Wert zuvor über die
GetDocument-Funktion gewonnen wurde.
4.8 Code zur Anzeige des Kreises
Nun werden wir den Code schreiben, der für die Bildschirmausgabe eines Kreises zuständig ist.
Öffnen Sie die Datei WinCircleView.cpp und suchen Sie die Funktion OnDraw(). Ergänzen Sie den
nachfolgenden Sourcecode:
// CWinCircleView Zeichnen
void CWinCircleView::OnDraw(CDC* pDC)
{
CWinCircleDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
// ZU ERLEDIGEN: Hier Code zum Zeichnen der ursprünglichen
Daten hinzufügen
///////////////////////
// EIGENER CODE, ANFANG
///////////////////////
// Den rechteckigen Umriß des zu zeichnenden
// Kreises definieren
RECT rect;
rect.left = m_PosX -20;
rect.top = m_PosY -20;
rect.bottom = m_PosY + 20;
rect.right = m_PosX +20;
// Den Kreis zeichnen
pDC->Ellipse(&rect);
///////////////////////
// EIGENER CODE, ENDE
///////////////////////
}
Ein Kreis wird in Visual C++ als eine Ellipse mit gleichen Achsenlänge definiert. In unserem Fall
wird die Größe der Ellipse durch ein einhüllendes Rechteck definiert. Das Ergebnis sehen wir in
Abbildung 8.
40

Programmieren mit der MFC
Abbildung 8: Unser erster Kreis.
4.9 Zeichnen an beliebigen Positionen
Bis jetzt wird ein Kreis immer an der gleichen Stelle gezeichnet. Im Folgenden soll, verknüpft mit
dem Drücken der Maustaste, das Zeichnen an beliebiger Position möglich werden.
41

Programmieren mit der MFC
Visual C++ fügt nun die Methode CWinCircleView::OnLButtonDown(UINT nFlags,
CPoint point) hinzu. Klicken Sie auf die Schaltfläche CODE BEARBEITEN und nehmen Sie die
entsprechende Ergänzung vor:
void CWinCircleView::OnLButtonDown(UINT nFlags, CPoint point)
{
// TODO: Code für die Behandlungsroutine für Nachrichten hier
einfügen und/oder Standard aufrufen
////////////////////////
// EIGENER CODE, ANFANG
////////////////////////
// Die Datenelemente m_PoxX und m_PosY der Viewklasse
// mit den XY-Koordinaten des Punktes aktualisieren,
// an dem mit der Maus geklickt wurde
m_PosX = point.x;
m_PosY = point.y;
// Einen Aufruf der Funktion OnDraw() auslösen
Invalidate();
// Einen Zeiger auf das Dokument ermitteln
CWinCircleDoc* pDoc = GetDocument();
// Die Datenelemente des Dokuments mit den neuen
42

Programmieren mit der MFC
// Werten der Datenelemente aus der Viewklasse
// aktualisieren
pDoc->m_PosX = m_PosX;
pDoc->m_PosY = m_PosY ;
// Signalisieren, daß das Dokument geändert wurde
pDoc->SetModifiedFlag(TRUE);
////////////////////////
// EIGENER CODE, ENDE
////////////////////////
}
CView::OnLButtonDown(nFlags, point);
4.10 Speichern und Laden von Dateien
Öffnen Sie die Datei CWinCircleDoc.cpp und gehen Sie zur Methode
CWinCircleDoc::Serialize(CArchive& ar). Diese Methode wird automatisch
ausgeführt, wenn Sie in einem SDI-Programm die Funktionen SPEICHERN, SPEICHERN UNTER oder
ÖFFNEN aus dem Menü DATEI aktivieren.
Der Code dieser Funktion besteht im wesentlichen aus einer einfachen if ... else-Anweisung:
void CWinCircleDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring())
{
// ZU ERLEDIGEN: Hier Code zum Speichern einfügen
}
else
{
// ZU ERLEDIGEN: Hier Code zum Laden einfügen
}
}
Der einzufügende Code ist für Sie vielleicht überraschend einfach:
void CWinCircleDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring())
{
// ZU ERLEDIGEN: Hier Code zum Speichern einfügen
//////////////////////
// EIGENER CODE, ANFANG
//////////////////////
43

Programmieren mit der MFC
// m_PosX und m_PosY in der Datei speichern
ar m_PosX;
ar >> m_PosY;
//////////////////////
// EIGENER CODE, ENDE
//////////////////////
}
}
Das Ergebnis ist in der nachfolgenden Abbildung dargestellt.
Beachten Sie:
? Die Titelleiste der Applikation wird automatisch dem aktuellen Dateinamen angepasst.
? Die zuletzt verwendeten Dateien werden im DATEI-Menü automatisch verwaltet.
44

Programmieren mit der MFC
In dieser Übung haben wir in sehr mächtiges und wichtiges Konzept der MFC-Bibliothek kennen
gelernt: Die Serialisierung.
Sie legt die von CObject abgeleiteten Objekte beständig ab, beispielsweise durch Speichern in einer
Datei mit nachfolgendem Laden. Derartige Objekte können über die Serialisierung ebenfalls in die
Zwischenablage oder über OLE an andere Applikationen übertragen werden (Toth 1997). Die MFC-
Bibliothek verwendet CArchive-Objekte für die Serialisierung.
5 Literatur
Toth, Viktor, 1997: Visual C++ 5. Das Kompendium. Markt und Technik, Haar bei München, 1184 S.
Gurewich, Ori, Gurewich, Nathan, 1997: Visual C++ in 21 Tagen. SAMS, Haar bei München, 864 S.
Dr. Erhard Henkes (e.henkes@gmx.net) - C++ und MFC - Stand: 06.08.2002 :
http://www.henkessoft.de/mfc_einsteigerbuch_kapitel7.htm
Schröder, W., 2004: C++-Tutor, http://www.cpp-tutor.de/mfc/mfc/kap4/lektion1.htm, letzter Zugriff:
19.11.2004
45