C++ Winforms Anleitung

Windows Forms Projekte mit C++ in Visual Studio 2022

In Visual Studio bis Version 2010 sind Vorlagen für Windows Forms Projekte vorinstalliert, aber nicht mehr ab Visual Studio 2012. Für diese neueren Versionen von Visual Studio stehen solche Vorlagen aber nach der Installation einer Erweiterung zur Verfügung.

Diese Anleitung ist für Visual Studio 2022, gilt aber im Wesentlichen auch für andere Versionen von Visual Studio (2019, 2017, 2015 und früher).

Die Installation der Erweiterung für Windows Forms Projekte mit C++

Diese Erweiterung installiert man in Visual Studio 2022 unter Erweiterungen|Erweiterungen verwalten

Nach dem Anklicken von Download bei “C++ Windows Forms for Visual Studio 2022 .NET Framework”

und dem Beenden von Visual Studio erhält man die Meldung

Durch Anklicken von Modify wird die Erweiterung installiert.

Nach dem nächsten Start von Visual Studio stehen unter Datei|Neu|Projekt

Windows Forms Projekte zur Verfügung, die man in C++ schreiben kann. Mit einem solchen Projekt kann man Windows-Anwendungen mit einer grafischen Benutzeroberfläche (Buttons, Menüs usw.) erzeugen, wie zum Beispiel:

Als Programmiersprache wird Standard C++ (einschließlich fast aller Erweiterungen von C++11, C++14, C++17) für die business logic verwendet. Lediglich für den Zugriff auf Windows-Steuerelemente ist C++/CLI notwendig. Das ist ein einfacher C++-Dialekt für das .NET Framework.

Das Buch „C++ mit Visual Studio 2019 und Windows Forms-Anwendungen“

Die folgenden Ausführungen sind ein kurzer Auszug aus meinem Buch

Buchcover C++ mit Visual Studio 2019 und Windows Forms Anwendungen

das auch noch mit Visual Studio 2022 aktuell ist. Alle Beispiele und Projekte können in Visual Studio 2022 wie in Visual Studio 2019 angelegt und kompiliert werden.

Installation von Visual Studio für Windows Forms Projekte

Damit Windows Forms Projekte in Visual Studio erstellt werden können, müssen bei der Installation von Visual Studio bestimmte Komponenten installiert werden.

Falls das bei der Installation vergessen wurde, den Visual Studio Installer entweder unter Windows Start starten

oder in Visual Studio unter Datei|Neu|Projekt|Neues Projekt erstellen (am Ende der Projektliste)

Im Installer muss die .NET-Desktopentwicklung, die Desktopentwicklung mit C++ und die C++/CLI-Unterstützung markiert werden:

Ein Windows Forms Projekt erstellen

Nach dem Neustart von Visual Studio stehen dann Windows Forms Projekte unter Neues Projekt erstellen bzw. unter Datei|Neu|Projekt zur Verfügung:

Nach dem Anklicken des Weiter-Buttons kommt die Aufforderung, den Namen des Projekts und ein Verzeichnis einzugeben:

Nach dem Anklicken des Erstellen-Buttons sieht Visual Studio etwa so aus:

Klickt man jetzt im Projektmappen-Explorer auf Form1.h, wird das Formular angezeigt:

Normalerweise ist damit alles erledigt, und Sie können mit Abschnitt 1.6 weitermachen. Falls Sie aber etwas der Art

erhalten, haben Sie Form1.h zu schnell angeklickt. Schließen Sie dieses Fenster

und klicken Sie dann im Projektmappen-Explorer erneut auf Form1.h.

Visuelle Programmierung: Ein erstes kleines Programm

Bevor wir jetzt mit unserem ersten kleinen Programm beginnen, stellen wir Visual Studio noch ein wenig um, damit wir es leichter bedienen können.

Nach der Installation von Visual Studio wird die Toolbox am linken Rand angeboten.

Damit die Toolbox das Formular nicht verdeckt, ziehen Sie die Toolbox auf das Frame mit dem Projektmappen-Explorer (die linke Maustaste auf der Titelzeile der Toolbox drücken, dann mit gedrückter Maustaste auf die Titelzeile des Projektmappen-Explorers fahren und die Maustaste loslassen).

Ziehen Sie analog das Eigenschaften­fenster auf den Projektmappen-Explorer.

Da wir zunächst nur die Toolbox, den Projektmappen-Explorer und das Eigen­schaftenfenster benötigen, können Sie hier alle weiteren Fenster (z.B. Git Explorer usw.) schließen. Dann sieht das rechte Frame etwa folgendermaßen aus:

Mit dem Windows Forms Projekt aus Abschnitt 1.4 sieht Visual Studio dann so aus:

Als nächstes werden wir jetzt ein erstes kleines Programm schreiben.

Das Formular (hier Form1) ist der Ausgangspunkt für alle Windows Forms Anwendun­gen. Es entspricht dem Fenster, das beim Start des Pro­gramms an­gezeigt wird:

Auf ein Formular kann man Steuerelemente (Con­trols) aus der Toolbox setzen. Die Toolbox enthält praktisch alle unter Windows üblichen Steuerelemente. Diese sind auf ver­schiedene Gruppen verteilt (z.B. Allgemeine Steuerelemente, Container usw.), die auf- und zugeklappt werden können. Die meisten dieser Steuerelemente (wie z.B. ein Button) werden im laufenden Pro­gramm auf dem Formular ange­zeigt. Bleibt man mit dem Maus­zeiger kurz auf einer Zeile der Toolbox stehen, erscheint ein kleiner Hinweis mit einer kurzen Beschreibung:

Um ein Element aus der Toolbox auf das Formular zu setzen, zieht man es ein­fach von der Toolbox auf das Formular. Oder man klickt mit der Maus zuerst auf die Toolbox-Zeile und dann auf die Stelle im Formular, an die die linke obere Ecke kommen soll.

Beispiel:    Nachdem man ein Label (Zeile sieben in Allgemeine Steuerelemente, mit dem großen A), eine TextBox (vierte Zeile von unten, Aufschrift ab) und einen Button (zweite Zeile mit der Auf­schrift ab) auf das Formular gesetzt hat, sieht es etwa folgender­maßen aus:

Durch diese Spielereien haben Sie schon ein richtiges Windows-Programm er­stellt – zwar kein besonders nützliches, aber immerhin. Sie können es folgender­maßen starten:

  • mit Debuggen|Debugging starten von der Menüleiste, oder
  • mit F5 von einem beliebigen Fenster in Visual Studio oder
  • durch den Aufruf der vom Compiler erzeugten Exe-Datei.

Dieses Programm hat schon viele Eigenschaften, die man von einem Windows-Programm erwartet: Man kann es mit der Maus verschieben, vergrößern, ver­klei­nern und schließen.

Bemerkenswert an diesem Programm ist vor allem der im Vergleich zu einem nichtvisuellen Entwicklungssystem geringe Aufwand, mit dem es erstellt wurde. So braucht Petzold in seinem Klassiker „Program­mierung un­ter Windows“ (Petzold 1992, S. 33) ca. 80 Zeilen nichttriviale C-Anweisungen, um den Text „Hello Windows“ wie in einem Label in ein Fenster zu schreiben. Und in jeder dieser 80 Zeilen kann man einiges falsch machen.

Vergessen Sie nicht, Ihr Programm zu beenden, bevor Sie es weiterbearbeiten. Solange das Pro­gramm noch läuft können Sie weder den Compiler neu starten noch das Formular verändern.

Diese Art der Programmierung bezeichnet man als visuelle Programmierung. Während man bei der konventionellen Programmierung ein Programm aus­schließlich durch das Schreiben von Anweisungen (Text) in einer Program­mier­sprache entwickelt, wird es bei der visuellen Programmierung ganz oder teilweise aus vorgefertigten grafischen Steuer­elementen zusammengesetzt.

Mit Visual Studio kann die Benutzeroberfläche eines Windows Forms Programms visuell gestaltet werden. Damit sieht man bereits beim Entwurf des Programms, wie es später zur Laufzeit aus­sehen wird. Die Anweisungen, die als Reaktionen auf Benutzer­einga­ben (Maus­klicks usw.) erfolgen sollen, werden dagegen konven­tionell in einer Pro­grammier­sprache (z.B. C++) geschrieben.

Das Eigenschaftenfenster

Das zuletzt auf einem Formular (bzw. im Pull-down-Menü des Eigenschaften­fensters) angeklickte Steuerelement wird als das aktuell aus­gewählte Steuer­element bezeichnet. Man erkennt es an den kleinen Quadraten an seinem Rand, den soge­nannten Ziehquadraten. An ihnen kann man mit der Maus ziehen und so die Größe des Steuerelements verändern. Ein Formular wird dadurch zum aktuell ausge­wählten Steuerelement, dass man mit der Maus eine freie Stelle im Formular anklickt.

Beispiel:    Im letzten Beispiel ist button1 das aktuell ausgewählte Steuerelement.

Im Eigenschaftenfenster (Kontextmenü des Steuer­ele­ments auf dem Formular, oder Ansicht|Eigen­schaften­fenster – nicht mit Ansicht|Eigenschaften­seiten verwechseln)

wer­den die Eigenschaften des aktuell ausgewählten Steuer­ele­ments angezeigt. In der linken Spalte stehen die Namen und in der rechten die Werte der Eigen­schaften. Mit der Taste F1 erhält man eine Beschrei­bung der Eigen­schaft.

Den Wert einer Eigenschaft kann man über die rechte Spalte verändern. Bei manchen Eigenschaften kann man den neuen Wert über die Tastatur eintippen. Bei anderen wird nach dem Anklicken der rechten Spalte ein kleines Dreieck für ein Pull-down-Menü ange­zeigt, über das ein Wert ausgewählt werden kann. Oder es wird ein Symbol mit drei Punkten „…“ angezeigt, über das man Werte eingeben kann.

Beispiel:   

  • Bei der Eigenschaft Text kann man mit der Tastatur einen Text einge­ben. Bei einem Button ist dieser Text die Aufschrift auf dem Button (z.B. „OK“), und bei einem Formular die Titelzeile (z.B. „Mein erstes C++-Pro­gramm“).
  • Bei der Eigenschaft BackColor (z.B. bei einem Button) kann man über ein Pull-down-Menü die Hintergrundfarbe auswäh­len.
  • Klickt man die rechte Spalte der Eigenschaft Font und danach das Sym­bol „…“ an, kann man die Schriftart der Eigenschaft Text auswählen.

Ein Steuerelement auf dem Formular wird nicht nur an seine Eigenschaften im Eigen­schaften­fenster angepasst, sondern auch umgekehrt: Wenn man die Größe durch Ziehen an den Ziehquadraten auf dem Formular ver­ändert, werden die Werte der entsprechenden Eigen­schaften (Location und Size im Abschnitt Layout) im Eigenschaftenfenster automatisch aktualisiert.

Erste Schritte in C++

Als nächstes soll das Programm aus Abschnitt 1.5 so erweitert werden, dass als Reaktion auf Benutzereingaben (z.B. beim Anklicken eines Buttons) Anweisungen ausge­führt werden.

Windows-Programme können Benutzereingaben in Form von Mausklicks oder Tastatur­eingaben entgegennehmen. Alle Eingaben werden zentral von Windows entgegen­genom­men und an das Programm weitergegeben. Dadurch wird im Pro­gramm ein sogenanntes Ereignis ausgelöst.

Einem solchen Ereignis kann eine Funktion zugeord­net werden, die dann aufgeru­fen wird, wenn das Ereig­nis eintritt. Diese Funktion wird auch als Ereignis­behand­lungsroutine (engl. event handler) bezeich­net.

Vorläufig soll unser Programm nur auf das An­klicken eines Buttons rea­gieren. Die bei diesem Ereignis aufgerufene Funktion erhält man am einfachsten durch einen Doppel­klick auf den Button im Formular. Der Cursor steht dann am Anfang der Funk­tion. Dadurch erzeugt Visual Studio die folgende Funktion und zeigt sie im Editor an:

Zwischen die geschweiften Klammern „{“ und „}“ schreibt man dann die Anwei­sungen, die ausgeführt werden sollen, wenn das Ereignis Click eintritt.

Hier sind im Wesentlichen alle Anweisungen von C++ möglich. Im Rahmen dieser einfachen Anleitung sollen nur einige elementare Anweisun­gen vorgestellt werden, die zum Grundverständnis von Visual Studio notwendig ist. Falls Ihnen Begriffe wie „Variablen“ usw. neu sind, lesen Sie trotzdem weiter – aus dem Zusammenhang erhalten Sie sicherlich eine intuitive Vorstellung, die zunächst ausreicht.

Eine beim Programmieren häufig verwendete Anweisung ist die Zuweisung (mit dem Operator „=“), mit der man einer Variablen einen Wert zuweisen kann. Als Variablen sollen zu­nächst nur solche Eigen­schaften von Steuerelementen verwen­det werden, die auch im Eigenschaftenfenster angezeigt werden. Diesen Variab­len können dann die Werte zugewiesen werden, die auch im Eigenschaftenfenster in der rechten Spalte der Eigen­schaften angeboten werden.

Bei der Eigenschaft BackColor werden die zulässigen Werte nach dem Aufklappen des Pull-down-Menüs angeboten:

Diese Werte kann man im Programm verwenden, indem man sie nach Color:: angibt. Schreibt man jetzt die Anweisung

textBox1->BackColor = Color::Yellow;

zwischen die geschweiften Klammern

private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e)
{
 textBox1->BackColor = Color::Yellow;
}

erhält die Eigenschaft BackColor von textBox1 beim Anklicken von button1 während der Ausfüh­rung des Programms den Wert Color::Yellow, der für die Farbe Gelb steht. Wenn Sie das Programm jetzt mit F5 starten und dann button1 anklicken, erhält die TextBox tatsächlich die Hintergrundfarbe Gelb.

Auch wenn dieses Programm noch nicht viel sinnvoller ist als das erste, haben Sie doch gesehen, wie mit Visual Studio Anwendungen für Windows entwickelt wer­den. Die­ser Ent­wicklungsprozess besteht immer aus den folgenden Aktivitäten:

  1. Man gestaltet die Benutzeroberfläche, indem man Steuerelemente aus der Toolbox auf das Formular setzt (drag and drop) und ihre Eigenschaften im Eigenschaftenfenster oder das Layout mit der Maus anpasst (visuelle Programmierung).
  2. Man schreibt in C++ die Anweisungen, die als Reaktion auf Benut­zereinga­ben erfolgen sollen (nichtvisuelle Programmierung).
  3. Man startet das Programm und testet, ob es sich auch wirklich so verhält, wie es sich verhalten soll.

Der Zeitraum der Programmentwicklung (Aktivitäten 1. und 2.) wird auch als Ent­wurfszeit bezeichnet. Im Unterschied dazu bezeichnet man die Zeit, wäh­rend der ein Programm läuft, als Laufzeit eines Programms.

Eine einfache Winforms-Anwendung

Als nächstes soll auf der Basis der bisherigen Ausführungen eine einfache Winforms-Anwendung erstellt werden, die einen Button und TextBoxen zur Eingabe- und Ausgabe enthält:

Sie müssen dieses Projekt aber nicht selbst erstellen. Wenn Sie die Visual Studio Erweitererung

installieren, steht in Visual Studio eine Projektvorlage mit genau diesem Projekt zur Verfügung:

Sie können dieses Projekt als Grundlage für viele Anwendungen verwenden, indem Sie weitere Steuerelemente und Funktionen hinzufügen.

Dieses Projekt soll vor allem zeigen, wie die Anwendungslogik von der Benutzeroberfläche getrennt wird:

  • Die Funktionen, Klassen usw. der Anwendungslogik werden in Standard C++ geschrieben und sind in einer Header-Datei enthalten, die dem Projekt hinzugefügt wird.
  • Die Anweisungen für die Benutzeroberfläche sind dagegen vor allem in C++/CLI geschrieben und oft in der Formularklasse in Form1.h enthalten.
  • Die Funktionen der Header-Datei werden beim Anklicken eines Buttons aufgerufen.

Die folgenden Ausführungen sind eine vereinfachte Version des Kapitels 2.11 aus meinem Buch „C++ mit Visual Studio 2019 und Windows Forms-Anwendungen“. Dort wird ein solches Projekt für die Lösungen der Übungsaufgaben empfohlen. In die Header-Datei eines solchen Projekts kann man die Lösungen von mehreren Übungsaufgaben aufnehmen, bzw. diese auf verschiedene Header-Datein verteilen. Für jede Teilaufgabe setzt man einen Button (oder Menü-Optionen) auf das Formular. So muss man nicht für jede Teilaufgabe ein neues Projekt anlegen.

Natürlich ist die Auslagerung der eigenen Anweisungen in eine extra Datei (wie in 3.) und der Zugriff auf die Steuerelemente über Funktionsparameter etwas um­ständlich: Sie führt aber zu übersichtlicheren Programmen als wenn alle Anwei­sungen in der Formulardatei innerhalb der Klasse Form1 stehen. Das erspart viele Programmierfehler, die zu undurch­sichtigen Fehlermeldungen führen, und er­leichtert die Suche nach Fehlern.

1. Das Projekt anlegen

Mit Datei|Neu|Projekt|Visual C++|CppCLR_WinformsProjekt (siehe Abschnitt 1.1) ein neues Projekt anlegen.

Bei den folgenden Beispielen wird ein Projekt mit dem Namen CppCLR_Winforms_GUI angenommen.

2. Die Benutzeroberfläche (das Formular) gestalten

Das Formular wird dann so gestaltet, dass es alle Steuerelemente enthält, die für die Ein- und Ausgabe von Informationen und den Start von Aktionen notwendig sind. Dazu zieht man entsprechende Steuerelemente aus der Toolbox auf das Formular.

Für viele Projekte (z.B. die Übungsaufgaben aus meinem Buch) reichen die folgenden Steuerelemente aus:

  • Eine mehrzeilige TextBox (siehe Abschnitt 2.3.2 in meinem Buch) zur Anzeige der Ergeb­nisse.
  • Eine einzeilige TextBox zur Eingabe von Daten
  • Ein oder mehrere Buttons (bzw. Menüoptionen usw.) zum Start der Anweisungen

Eine TextBox wird durch den Wert true der Eigenschaft MultiLine mehrzeilig. Die TextBox zur Anzeige soll den Namen out_textBox erhalten:

Die TextBox zur Eingabe von Daten soll den Namen in_textBox erhalten:

Da beim Anklicken des Buttons die Funktion plus_1 aufgerufen wird, erhält er die Aufschrift „plus 1“ und den Namen button_plus1:

3. Eine Header-Datei mit der Anwendungslogik

Die Funktionen, Deklarationen, Klassen usw. der sogenannten Anwendungslogik kommen in eine eigene Header-Datei, die dem Projekt mit Projekt|Neues Element hinzufügen|Visual C++|Code als Headerdatei(.h) mit dem Namen Header1.h hinzuge­fügt wird. In der Praxis sollte man aber in einer Header-Datei Funktionen und Klassen zusammenfassen, die inhaltlich zusammengehören, und dann der Header-Datei einen aussagekräftigeren Namen als Header.h geben.

In einem C++ Windows Forms Projekt besteht die Anwendungslogik vor allem aus in C++ geschriebenen Funktionen, Klassen usw., ohne C++/CLI Sprachelemente. In unserem ersten Beispiel soll das eine Funktion mit dem Namen plus_1 sein, die den um 1 erhöhten Wert des Arguments zurückgibt:

int plus_1(int x)
{
  return x + 1;
}

Diese Datei wird dann vor dem namespace des Projekts mit einer #include-Anweisung in die Formulardatei (z.B. Form1.h) aufgenommen:

#pragma once
#include "Header1.h" // <-- manuell einfügen. nach dem Eintippen von 
                     // "#include " bietet Visual Studio die Datei an.
namespace CppCLRWinFormsProject {
  using namespace System;
    ...
}

4. Die Funktionen aufrufen

Durch einen Doppelklick auf den Button auf dem Formular erzeugt Visual Studio die Funktion (den Eventhandler), die beim Anklicken des Buttons aufgerufen wird, wenn das Programm läuft:

private: System::Void button_plus_1_Click(System::Object^ sender, System::EventArgs^ e) 
{
}

In diesem Eventhandler ruft man dann die entsprechende Funktion auf. In dieser einfachen Anleitung ist das die Funktion plus_1 aus der Datei Header.h.

  • Falls diese Funktion Benutzereingaben verwendet, liest man diese über eine TextBox ein. In dieser einfachen Anleitung soll das eine Zahl sein, die aus der in_TextBox eingelesen wird.
  • Falls ein Parameter der aufgerufenen Funktion nicht den Datentyp String (der Datentyp der Eigenschaft in_textBox->Text) hat, muss der String in den Datentyp des Parameters konvertiert werden. Das ist mit einer der Convert::-Funktion möglich.
  • Die Ergebnisse sollen in der out_textBox angezeigt werden. Das ist mit der Funktion out_textBox->AppendText möglich. Den String, den AppendText erwartet, kann man mit String::Format erzeugen. Dabei gibt man im ersten Argument (ein String) {0} für den ersten Wert nach dem String an, {1} für den zweiten usw.
private: System::Void button_plus_1_Click(System::Object^ sender, System::EventArgs^ e) 
{
int n = Convert::ToInt32(in_textBox->Text);
int result = plus_1(n);
out_textBox->AppendText(String::Format("plus_1({0})={1}\r\n",n,result));
}

Gibt man nach dem Start dieses Programms mit F5 in das Eingabefeld eine Zahl ein und klickt man dann auf den Button, wird in der Ausgabe-TextBox der um 1 erhöhte Wert angezeigt:

Für jede weitere Funktion, deren Ergebnis angezeigt werden soll, wird ein Button auf das Formular gesetzt und mit einem passenden Namen (Eigenschaft Name) und einer passenden Aufschrift (Eigenschaft Text) versehen. In der zugehörigen Ereignisbehandlungsroutine wird dann diese Funktion aufgerufen.

Damit sind alle relevanten Teile der ??? CppCLR_Winforms_GUI vorgestellt. Sie können diese beliebig um weitere Steuerelemente (Buttons, Menüs usw.) erweitern. Siehe dazu Kapitel 2 meines Buchs.

5. GUI und Anwendungslogik nicht so streng getrennt

In der unter 1. bis 4. erstellten Version wird die Anwendungslogik streng von der Benutzeroberfläche getrennt: Der Zugriff auf die Benutzeroberfläche mit C++/CLI erfolgt ausschließlich in Form1.h. In Header1.h wird dagegen nur Standard-C++ verwendet. Das hat inbesondere den Vorteil, dass man diesen Header auch in anderen Plattformen (z.B. Konsolen-Anwendungen, Qt, Mac) verwenden kann.

In der Anfangsphase eines Projekts, in der noch viel experimentiert wird, kann es aber etwas umständlich sein, wenn man nach jeder Änderung einer Parameterliste die Aufrufe in einer anderen Datei ändern muss. Und bei Anwendungen, die gar nicht für andere Plattformen verwendet werden sollen. Das gilt oft auch bei Übungsaufgaben.

Dieses Hin- und Herspringen zwischen verschiedenen Dateien kann man vermeiden, wenn man die strenge Trennung zwischen der Anwendungslogik und der Benutzeroberfläche auflockert und auch in der Header-Datei einen Zugriff auf die Steuerelemente aufnimmt.

Ein Zugriff auf Steuerelemente in einer Header-Datei wird dadurch ermöglicht, dass man in die Header-Datei am Anfang

using namespace System;
using namespace System::Windows::Forms;

aufnimmt. Dann kann man in der Header-Datei auch die Datentypen der Steuerelemente verwenden (z.B. als Parameter) und die Anweisungen, die unter 4. in der buttonClick-Funktion in Form1.h waren, in die Header-Datei aufnehmen.

Diese Vorgehensweise ist in der Datei Header2.h implementiert:

#pragma once
using namespace System;
using namespace System::Windows::Forms;

int plus_2(int x)
{
  return x + 2;
}

void plus_2_Click(TextBox^ in_textBox, TextBox^ out_textBox)
{
int n = Convert::ToInt32(in_textBox->Text);
int result = plus_2(n);
out_textBox->AppendText(String::Format("plus_2({0})={1}\r\n", n, result));
}

Hier übergibt man der Funktion einen Parameter für das Steuer­element. Beachten Sie bitte, dass Sie nach dem Namen eines .NET-Datentyps (z.B. TextBox, Button) ein ^ angeben müssen. In der Funktion spricht man dann das Steuerelement unter dem Namen des Parameters an.

Diese Funktion kann man dann beim Anklicken eines Buttons so aufrufen:

private: System::Void button_plus_1_Click(System::Object^ sender, System::EventArgs^ e) 
{
plus_2_Click(in_textBox, out_textBox);
}

6. Analogie zu Konsolenanwendungen

Ein Vergleich dieses Windows Forms Projekts mit einer entsprechenden Konsolen-Anwendung zeigt die Analogie den beiden Projekttypen. Diese Analogie zeigt, wie man eine Konsolen-An­wendung in eine Formularanwendung konvertieren kann: Falls Sie ein Kon­solenprogramm wie

#include<iostream>
int main()
{
int n;
std::cin >> n;
int result = plus_2(n);
std::cout << "plus_2(" << n << ") = " << result << std::endl;
return 0;
}

haben, können Sie es mit relativ wenig Aufwand in eine Formular-Anwendung portieren. Sie müssen nur die I/O-Anweisungen ersetzen und die Funktionen als Reaktion auf einen ButtonClick usw. aufrufen:

private: System::Void button_plus_1_Click(System::Object^ sender, System::EventArgs^ e) 
{
int n = Convert::ToInt32(in_textBox->Text);
int result = plus_1(n);
out_textBox->AppendText(String::Format("plus_1({0})={1}\r\n",n,result));
}

Vorwort zum Buch „C++ mit Visual Studio 2019 und Windows Forms-Anwendungen“

Das Vorwort zu meinem Buch

Buchcover C++ mit Visual Studio 2019 und Windows Forms Anwendungen

beschreibt die Möglichkeiten von C++ mit Windows Forms Anwendungen noch etwas genauer.

Vorwort

Der Ausgangspunkt für dieses Buch war der Wunsch nach einem C++-Lehrbuch, in dem von Anfang an Programme für eine grafische Benutzeroberfläche (Windows) entwickelt werden, und nicht wie meist üblich Konsolen-Anwendungen. Programme, in denen Ein- und Ausgaben über eine Konsole erfolgen, sind für viele Anfänger weltfremd wie steinzeitliche DOS-Programme und schrecken davon ab, sich überhaupt mit C++ beschäftigen zu wollen.

Windows Forms Anwendungen sind ein idealer Rahmen für C++-Programme mit einer attraktiven Benutzeroberfläche: Der Zugriff auf Windows Steuer­elemente (Buttons, Text­Boxen usw.) ist einfach. Der Unterschied zu einem Standard C++ Programm ist meist nur, dass Ein- und Ausgaben über ein Windows-Steuer­element (meist eine TextBox) erfolgen

textBox1->AppendText("Hello World");

während in Standard-C++ die Konsole mit cout verwendet wird:

cout << "Hello world" << endl;

Aber nicht nur Studierende können von C++ mit einer grafischen Benutzeroberfläche profi­tieren. Mit Windows Forms Projekten können bestehende C oder C++-Programme ohne großen Aufwand mit einer grafischen Benutzeroberfläche ausgestattet werden. Und wer C oder C++ kann und keine neue Sprache für eine GUI lernen will, kann seine bestehenden Programme mit einfachen Mitteln schöner und leichter bedienbar machen.

C++ hat sich in den letzten Jahren rasant entwickelt: Die Neuerungen von C++11, C++14, C++17 und C++20 haben viele Verbesserungen und neue Möglichkeiten gebracht. Vieles, was 2010 noch gut und empfehlenswert war, kann heute besser und sicherer gemacht werden.

Das merkt man als Buchautor und Trainer, der diese ganze Entwicklung begleitet hat, besonders deutlich: Vieles, was man früher einmal geschrieben hat, sollte man heute anders machen. Zwar würde es immer noch kompiliert werden. Aber es ist kein modernes C++ mehr, das dem aktuellen Stand der Technik entspricht und alle Vorteile nutzt.

Dieses Buch stellt C++ auf dem Stand von Visual Studio 2019 im Mai 2020 vor. Das ist der Umfang von C++17.

Dieses Buch entstand einerseits aus meinen Vorlesungen an der Dualen Hochschule Lörrach und andererseits aus zahlreichen Seminaren für Firmen, die sich an Software-Entwickler richten, die C++ professionell einsetzen. Dementsprechend richtet es sich einerseits an Studierende ohne Vorkenntnisse. Die Lernziele für diese Gruppe sind:

  • Modernes C++ auf dem Stand von 2020 zu lernen. C++ ist nach wie vor eine der am häufigsten eingesetzten Programmier­sprachen.
  • Programmieren zu lernen, d.h. Programme zu schreiben, die konkrete, vorgegebene Auf­gaben lösen. Das ist nur mit viel Übung möglich. Programmieren lernt man nur, indem man es tut. Deshalb enthält dieses Buch auch viele Übungsaufgaben. Es ist unerlässlich, zahlreiche Aufgaben selbständig zu lösen (das müssen nicht die aus diesem Buch sein).

Der Schwie­rigkeitsgrad der Aufgaben reicht von einfachen Wiederholungen des Textes bis zu kleinen Projektchen, die ein gewisses Maß an selbständiger Arbeit erfordern. Die Lösungen der Aufgaben findet man auf https://www.rkaiser.de.

  • Eine moderne Entwicklungsumgebung kennen- und einsetzen lernen. Visual Studio ist das in der Industrie wohl am häufigsten eingesetzte Werkzeug zur Software-Entwicklung.
  • Ein C++-Lehrbuch anzubieten, in dem Programme für eine grafische Benutzeroberfläche (Windows) entwickelt werden, und nicht wie meist üblich Konsolen-Anwendungen. Solche Programme sind für viele Anfänger abschreckend und weltfremd.
  • Man hört immer wieder, dass C++ zu schwierig ist, um damit das Programmieren zu lernen. Dieses Buch soll ein in vielen Jahren erprobtes Gegen­argument zu dieser Meinung sein. Damit will ich die Komplexität von C++ nicht ab­streiten. Aber wer C++ kann, findet sich leicht mit C#, Java usw. zurecht. Der umgekehrte Weg ist meist schwieriger.

Dieses Buch richtet sich aber ebenso an professionelle Software-Entwickler mit einer jahre­langen C++-Praxis. Viele C++-Neuerungen machen elementare Sprachkonzepte einfacher und sicherer. Dazu kommen anspruchsvollere Neuerungen, die bessere und effizientere Lösun­gen ermög­lichen, die so vor einigen Jahren noch nicht möglich waren. Sowohl die einfachen als auch die anspruchsvolleren Möglichkeiten haben sich in der industriellen Praxis oft noch nicht herumgesprochen. Oft wird mit C++ noch wie vor 30 Jahren mit C program­miert. Das ist fehleranfällig, unnötig aufwendig und verschenkt Vorteile und Möglichkeiten.

  • Für professionelle Entwickler soll dieses Buch einen nahezu vollständigen Überblick über C++17 geben und die Sprachelemente so vorstellen, dass sie in der praktischen Arbeit eingesetzt werden können. Die Erfahrun­gen aus meinen Firmenseminaren geben mir die Hoffnung, dass die aller­meisten Themen abgedeckt sind, die im industriellen Einsatz notwendig sind.
  • Da fast ausschließlich Standard-C++ behandelt wird, ist dieses Buch nicht auf Visual Studio beschränkt. Praktisch alle Ausführungen gelten für jeden standardkonformen C++-Compiler (gcc, Intel, Embarcadero usw.).
  • Das moderne C++ bietet auch Programmierern von eingebetteten Anwendungen viele Vor­teile gegenüber dem in diesem Anwendungsbereich verbreiteten C. Mit dem moder­nen C++ gibt es noch weniger Gründe als vorher, solche Anwendungen in C zu schreiben.
  • Professionelle Entwickler sollen sich nicht an den Übungsaufgaben stören. Sie haben schon genügend Aufgaben gemacht, sonst wären sie keine Profis geworden. Und außer­dem bietet das Tagesgeschäft genügend Übungsaufgaben.

Ich habe nicht nur versucht, die Sprachelemente anschaulich zu be­schreiben, sondern auch Kriterien dafür anzugeben, wann und wie man sie sinnvoll einsetzen kann. Viele Empfehlun­gen aus style guides (z.B. der C++ Core Guidelines, siehe Abschnitt Fehler! Verweisquelle konnte nicht gefunden werden.) sind in den Text eingearbeitet, ohne dass explizit darauf hingewiesen wird.

Dieses Buch erscheint in zwei weitgehend identischen Ausgaben:

  • In der anderen Ausgabe „C++ mit Visual Studio 2019“ werden reine Standard-C++-Programme geschrieben, d.h. ohne graphische Benutzeroberfläche. Alle Ein- und Aus­gaben erfolgen über die Konsole.

Der Unterschied zwischen den beiden Ausgaben ist meist nur, dass in „C++ mit Visual Studio 2019 und Windows Forms Anwendungen“ Ein- und Ausgaben über ein Windows-Steuer­element (meist eine TextBox) erfolgen, während in „C++ mit Visual Studio 2019“ die Konsole verwendet wird.

Dazu kommen noch etwa 100 Seiten mit unterschiedlichen Inhalten, da diese in Visual Studio nur für den jeweiligen Anwendungstyp verfügbar sind. Die folgenden Themen sind nur in „C++ mit Visual Studio 2019“ enthalten: Multithreading (Kapitel 17), 15.10 parallele Algo­rithmen der Standardbibliothek, 2.13 C++ Core Guideline Checks, 11.2 polymorphe Memory Ressourcen (pmr,), Sprachele­men­te von C++20: 2.14 Module, 14.6 concepts, 4.2.4 std::span , 8.2.5 der dreifache Vergleichs­operator <=> usw.

Dagegen sind diese Themen nur in der Ausgabe für Windows Forms Anwendun­gen enthal­ten: „Steuerelemente für die Benutzeroberfläche“ und „C#/.NET Interoperabi­lität“ (Kapitel 2 und 19).

Die vorliegende Ausgabe ist eine umfassende Überarbeitung meiner Bücher über C++ mit Visual Studio 2017. Obwohl sich die beiden Jahreszahlen im Titel nur um 2 unter­scheiden, ist über die Hälfte komplett neu:

  • Große Teile, die heute nicht mehr aktuell sind, wurden entfernt. Vieles wurde auf den aktuellen Stand des modernen C++ gebracht. Wichtige Erweiterungen kamen dazu.
  • Eigentlich wollte ich den Umfang wieder auf ca. 800 Seiten begrenzen, um potenzielle Leser nicht schon allein durch das Gewicht und die Fülle des Stoffs abzuschrecken. Das ist mir aber trotz intensivster Bemühungen nicht gelungen.

Anregungen, Korrekturhinweise und Verbesserungsvorschläge sind willkommen. Bitte senden Sie diese an die Mail-Adresse auf meiner Internetseite www.rkaiser.de.

Bei meinen Seminarteilnehmern und Studenten bedanke ich mich für die zahlreichen Anregun­gen. Dem Team vom Springer-Verlag danke ich für die Unterstützung und Geduld.

Tübingen, im Juni 2020   Richard Kaiser