Kennenlernen der Entwicklungsumgebung Code::Blocks

Die Entwicklungsumgebung Code::Blocks bietet mehrere Möglichkeiten, eine neue Datei oder ein neues Projekt anzulegen; die für den Anfänger relevanten Möglichkeiten werden vorgestellt. Zudem kann man sehr viel produktiver arbeiten, wenn man die in der Entwicklungsumgebung enthaltenen Helfer kennt (Syntaxhervorhebung, Syntax-Vervollständigung, Code-Refactoring, Code-Schnipsel).

walter
HelloWorld Entwicklungsumgebung C++ Code::Blocks Projekt
Inhaltsverzeichnis

Einordnung des Artikels

Einführung in die Entwicklungsumgebung Code::Blocks

Die folgenden Schritte werden für die empfohlene Entwicklungsumgebung Code::Blocks beschrieben, sie können aber auch auf andere Entwicklungsumgebungen übertragen werden. Von einem pragmatischen Standpunkt aus werden viele der hier beschriebenen Schritte überflüssig erscheinen, es wird dennoch empfohlen, sie in Ruhe durchzuarbeiten. Später werden Sie vielleicht auf eine andere Entwicklungsumgebung umsteigen wollen (oder müssen) und die hier erworbenen Kenntnisse werden es Ihnen erleichtern. Ebenso wird es öfters vorkommen, dass die Entwicklungsumgebung nicht wie gewünscht arbeitet — mit dem hier erworbenen Verständnis wird es Ihnen leichter fallen Fehler zu finden.

TIP:

Stellen Sie sich — gerade wenn Sie die ersten Schritte mit einer neuen Entwicklungsumgebung unternehmen — immer die Fragen:

  1. Was macht die Entwicklungsumgebung für mich?
  2. Was macht der Compiler für mich?
  3. Was muss ich selber machen?

Je besser Sie im Lauf der Zeit die Entwicklungsumgebung und den Compiler kennenlernen, werden sich die Antworten etwas verschieben.

Das erste Projekt: HelloWorld

Workspace vorbereiten

Bevor Sie Code::Blocks starten: Erzeugen Sie einen Ordner, den Sie später als workspace für Ihre C++-Projekte verwenden wollen; dieser Ordner wird im Folgenden mit

<workspace>

bezeichnet.

Neues Projekt anlegen

Nach dem Start von Code::Blocks wird zuerst ein neues Projekt angelegt mit:

File -> Project -> New Project -> Empty Project

Für das erste Projekt ist es ratsam, ein leeres Projekt (empty project) anzulegen, um die Arbeitsweise der Entwicklungsumgebung besser zu verstehen.

Das erste Projekt erhält — wie üblich — den Namen (Project title)

HelloWorld

Man muss im Wizard, der das Projekt anlegt, den Ordner angeben, in dem der Projekt-Ordner erstellt werden soll. Hier verwendet man den oben angelegten workspace.

Im Wizard sieht man auch, dass parallel ein Project filename angelegt wird mit:

HelloWorld.cpp

und es wird ein Resulting filename erzeugt mit:

<workspace>\HelloWorld\HelloWorld.cbp

Die Datei-Endung .cbp steht für code blocks project, in dieser Datei wird das soeben erzeugte Projekt verwaltet. Genauer heißt dies, dass das Projekt hier von Code::Blocks verwaltet wird; Sie sollten daher diese Datei nicht editieren, sondern nur darin lesen. Wenn Sie mit der Arbeitsweise von Code::Blocks besser vertraut sind, werden Sie diese Datei nur noch lesen, wenn Ihr Projekt nicht wie gewünscht arbeitet.

Compiler und Konfiguration für das Projekt

Der nächste Schritt besteht darin, den Compiler auszuwählen und einige Konfigurationen anzugeben.

Als Compiler muss der

GNU GCC Compiler

angegeben werden; hat man Code::Blocks mit MinGW-Compiler installiert, sollte dieser Compiler per default ausgewählt sein.

Für die anderen Konfigurationen, nämlich Debug Configuration und Release Configuration ist es ratsam, die vorgeschlagenen Einstellungen zu übernehmen. Wichtig wird dies erst, wenn man an größeren Projekten arbeitet. Wie man sieht, werden hier Output directories angelegt, und zwar unter

obj\Debug
obj\Release

Geht man in den Datei-Browser (etwa Windows-Explorer), so sieht man, dass im workspace der Ordner HelloWorld angelegt wurde und dass sich darin nur eine einzige Datei befindet:

<workspace>\HelloWorld\HelloWorld.cbp

Der Inhalt dieser Datei — es handelt sich um eine reine Textdatei, genauer ein XML-File — ist:

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
    <FileVersion major="1" minor="6" />
    <Project>
        <Option title="HelloWorld" />
        <Option pch_mode="2" />
        <Option compiler="gcc" />
        <Build>
            <Target title="Debug">
                <Option output="bin/Debug/HelloWorld" prefix_auto="1" extension_auto="1" />
                <Option object_output="obj/Debug/" />
                <Option type="1" />
                <Option compiler="gcc" />
                <Compiler>
                    <Add option="-g" />
                </Compiler>
            </Target>
            <Target title="Release">
                <Option output="bin/Release/HelloWorld" prefix_auto="1" extension_auto="1" />
                <Option object_output="obj/Release/" />
                <Option type="1" />
                <Option compiler="gcc" />
                <Compiler>
                    <Add option="-O2" />
                </Compiler>
                <Linker>
                    <Add option="-s" />
                </Linker>
            </Target>
        </Build>
        <Compiler>
            <Add option="-Wall" />
        </Compiler>
        <Extensions>
            <code_completion />
            <envvars />
            <debugger />
        </Extensions>
    </Project>
</CodeBlocks_project_file>

Man kann leicht nachvollziehen, dass hier die Konfigurationen kodiert sind, die man beim Anlegen des Projektes ausgewählt hat.

Der erste Quelltext: HelloWorld.cpp

Um ein erstes Programm zu schreiben — hier soll Das Programm HelloWorld.cpp geschrieben werden — gehen Sie zu

File -> New -> Empty File

Bestätigen Sie, dass das neue File zum aktuellen Projekt gehören soll und geben Sie ihm den Namen

HelloWorld.cpp

und nicht den vorgeschlagenen Namen

Untitled1.c

Im Datei-Browser liegen jetzt im Ordner

<workspace>\HelloWorld

zwei Dateien:

In Code::Blocks kann das Projekt HelloWorld ausgeklappt werden: es enthält Sources (also Quelltexte) und darin HelloWorld.cpp; und diese Datei ist im Editor geöffnet.

Kopieren Sie nun folgenden Quelltext in die leere Datei:

#include <iostream>

int main(){
    
    std::cout << "Hello World!";
    return 0;
}

Nach dem Abspeichern der Datei sollte Code::Blocks keinen Fehler anzeigen; genauer: der Quelltext sollte keinen Syntax-Fehler enthalten, was am Rand des Editors an der Farbe des Balkens erkennbar ist (grün = alles ok).

Den Quelltext müssen Sie jetzt noch nicht verstehen: das Programm sorgt lediglich dafür, dass der Text zwischen den Anführungsstrichen auf der Konsole ausgegeben wird.

Jetzt der erste große Augenblick: Gehen Sie zu

Build -> Compile current file

In der (in Code::Blocks integrierten) Konsole sollte keine Fehlermeldung erscheinen. Sie können in der Konsole ablesen, welcher Befehl zum Kompilieren ausgeführt wurde, Sie erkennen:

1. welcher Compiler aufgerufen wurde (sollte g++ sein), genauer

mingw32-g++.exe

2. den (absoluten) Pfad der .cpp-Datei, die compiliert wurde, also

<workspace>\HelloWorld\HelloWorld.cpp

3. den (relativen) Pfad für die Objekt-Datei

obj\Debug\HelloWorld.o

4. einige weitere Compiler-Optionen, die Sie jetzt noch nicht verstehen müssen.

Falls beim Compilieren Fehler aufgetreten sind, wurde vermutlich der falsche Compiler aufgerufen.

Wenn Sie jetzt wieder im Datei-Browser den workspace betrachten, sehen Sie, welche Ordner und Dateien beim Compilieren angelegt wurden — es sind genau die Dateien, die bei der Konfiguration des Projektes festgelegt wurden, nämlich die HelloWorld.exe-Datei in:

<workspace>\HelloWorld\bin\Debug\HelloWorld.exe

und die Objekt-Datei HelloWorld.o in

<workspace>\HelloWorld\obj\Debug\HelloWorld.o

Und jetzt der zweite große Moment: Führen Sie das Programm aus mit:

Build -> Run

Es öffnet sich eine Konsole, in der

Hello World!

stehen sollte sowie die Aufforderung:

Press any key to continue

Folgen Sie dieser Aufforderung; wenn Sie die Konsole schließen, kann es sein, dass Sie den Compiler nicht mehr aufrufen können.

Erzeugen Sie nun einen Syntax-Fehler im Quelltext, etwa indem Sie einen Strichpunkt entfernen. Compilieren muss jetzt zu einer Fehlermeldung führen.

Anlegen einer Konsolen-Anwendung (console application)

Am Beispiel des HelloWorld-Projektes wurde erklärt, wie man zuerst ein leeres Projekt (empty project) und dann eine leere Datei (empty file) anlegt. Man kann den Vorgang bei Code::Blocks auch deutlich abkürzen, indem man sofort eine Konsolen-Anwendung (console application) anlegt:

New -> Project -> Console application

Es wird dann im Projekt-Ordner neben der üblichen Projekt- Datei (.cbp) ein C++-Programm namens main.cpp angelegt; der Quelltext ist gerade der eines HelloWorld-Programmes:

#include <iostream>

using namespace std;

int main()
{
    cout << "Hello world!" << endl;
    return 0;
}

Bis auf die Feinheit, dass hier

using namespace std;

verwendet wird, ist hier alles bekannt. Ausführlich erklärt werden die Konzepte, die in dem HelloWorld-Programm verwendet werden, im nächsten Kapitel Elementare Syntax: Ein- und Ausgaben über die Konsole.

Tip:

Für die nächsten Projekte können Sie die Konsolen-Anwendung einsetzen.

Anlegen einer Klasse

Tip:

Hier wird schon beschrieben, wie Sie später neue C++-Klassen anlegen.
Solange Sie noch nicht mit objektorientierter Programmierung vertraut sind, sollten Sie diese Variante noch nicht nutzen.

Anlegen des ersten C++-Klasse mit:

New -> File -> Class

Es erscheint ein Wizard mit zahlreichen Einstellungen; es werden alle default-Einstellungen übernommen und nur der Dateiname (classname) wird gesetzt. Parallel dazu erscheint als Filename:

HelloWorld.cpp

Das File wird angelegt und es erscheint die Frage, ob es zum aktuellen Projekt hinzugefügt werden soll: ja!

Im Editor erscheint als Quelltext von HelloWorld.cpp:

#include "HelloWorld.h"

    HelloWorld::HelloWorld()
    {
        //ctor
    }

    HelloWorld::~HelloWorld()
    {
        //dtor
    }

Geht man jetzt wieder in den Datei-Browser, hat sich einiges verändert:

1. Im Ordner

<workspace>\HelloWorld

wurden zusätzlich zwei Ordner angelegt:

<workspace>\HelloWorld\include
<workspace>\HelloWorld\src

2. Im Ordner include liegt die Datei

HelloWorld.h

3. Im Ordner src liegt die Datei

HelloWorld.cpp

Öffnet man beide Dateien mit dem Text-Editor sieht man:

//HelloWorld.h
    
    #ifndef HELLOWORLD_H
    #define HELLOWORLD_H


    class HelloWorld
    {
        public:
            HelloWorld();
            virtual ~HelloWorld();

        protected:

        private:
    };

    #endif // HELLOWORLD_H

Und die Datei HelloWorld.cpp ist gerade der Quelltext, der oben gezeigt wurde.

Weiter sieht man, dass sich die Projekt-Datei HelloWorld.cbp verändert hat, sie enthält zusätzliche Einträge für diese beiden Files.

<Unit filename="include/HelloWorld.h" />
<Unit filename="src/HelloWorld.cpp" />

Dieser Aufbau für ein C++-Projekt ist für einen Anfänger deutlich zu schwierig, weil hier zahlreiche Elemente enthalten sind, für die man ein Verständnis der objektorientierten Programmierung benötigt — um die entsprechenden Schlagworte zu nennen:

Vermeiden Sie vorerst, Klassen über

New -> File -> Class

anzulegen; später — wenn Sie obige Schlagworte verstehen — werden Sie neue Klassen immer so anlegen. Erzeugen Sie Quelltexte zunächst immer mit

File -> New -> Empty File

oder mit

File -> Project -> New Project -> Empty Project

oder als Konsolen-Anwendung mit

New -> Project -> Console application

C++-Spezifikationen

Die Sprache C++ entwickelt sich natürlich weiter, im Lauf der Zeit werden zum Beispiel neue Programme in die Standard-Bibliothek aufgenommen. Unter

Settings -> Compiler -> Compiler Flags -> General

kann ausgewählt werden, nach welchem Standard ein Programm compiliert werden soll. Die Angabe führt dazu, dass der (schon bekannte) Compile-Befehl eine weitere Option erhält, wie etwa

mingw32-g++.exe -std=c++11 ...

Der aktuelle Sprachstandard ist C++17, im MinGW-Compiler sind aber nur C++14 und C++11 enthalten; für die meisten hier vorgestellten Programme wird C++11 ausreichen.

C++ Dokumentation

Leider ist die Sprache C++ nicht so gut dokumentiert wie Java, einige Dokumentationen finden sich unter:

http://www.cplusplus.com/reference/
https://msdn.microsoft.com/de-de/library/hh875057.aspx

Von der cplusplus-Dokumentation ist auch eine offline-Version verfügbar (Html book):

http://en.cppreference.com/w/Cppreference:Archives

Wie wertvoll der Umgang mit einer Dokumentation ist, werden Sie erst im Lauf der Zeit zu schätzen lernen.

Tip:

Lesen Sie zu allen Konzepten, die hier besprochen werden, die zugehörigen Informationen in der Dokumentation nach. Am Anfang wird Ihnen dies sehr schwer fallen; aber Sie lernen so schneller, die wichtigen Informationen aus der Dokumentation zu entnehmen. Insbesondere unter Language werden die grundlegenden Sprach-Konzepte beschrieben.

Sie werden sehen, dass Sie ein Lehrbuch nur noch als Leitfaden benötigen, das Ihnen eine Reihenfolge vorschlägt, in der man sich die Konzepte aneignet.

Einige kleine Helfer in Code::Blocks

Quelltext-Formatierung

Code::Blocks besitzt ein Plugin, mit dessen Hilfe der Quelltext formatiert werden kann. Aufrufbar ist es unter

Plugins -> Source code formatter (AStyle)

Wenn man dieses Plugin anklickt, wird der aktuelle Quelltext nach bestimmten Regeln formatiert (Einrückungen, Setzen der Klammern nach bestimmten Regeln und so weiter). Die dabei verwendeten Regeln kann man gemäß seinen Wünschen anpassen unter:

Settings -> Editor... -> Source formatter

Einige empfehlenswerte Regeln für Padding:

1. Leerzeilen erzwingen mit:

Pad empty lines around header blocks

2. Operatoren mit Leerzeichen umgeben mit:

Insert space paddings around operators.

Konfiguration des Editors, insbesondere Syntaxhervorhebung (Syntax Highlighting)

Um den Editor zu konfigurieren gibt es unter:

Settings -> Editor...

zahllose Einstellungen, die Sie im Lauf der Zeit besser verstehen und nutzen werden.

Für den Anfänger ist es oft schwierig, die Bedeutung der C++-Befehle schnell zu erkennen. Hilfreich dabei ist Syntaxhervorhebung, die unter

ettings -> Editor... -> Syntax highlighting

verändert werden kann.

TIP:

Kommentare sind per default meist in einer sehr schwer lesbaren Farbe dargestellt, die ihrer Wichtigkeit nicht gerecht wird. Sorgen Sie für auffallende Farben für Kommentare, die sich vom Rest des Quelltextes abhebt.

Kontext-Menü, insbesondere Code Refactoring

Durch Rechts-Klick auf eine Variable (oder Funktion) öffnet sich das Kontext-Menü, das viele hilfreiche Einträge besitzt.

Der wichtigste Eintrag im Kontext-Menü ist Code Refactoring. Damit kann eine Variable umbenannt werden — was sich zunächst nicht sehr spannend anhört. Der Clou dabei ist, dass die Variable an allen Stellen im Quelltext verändert wird. Somit ist das Refactoring deutlich mehr als ein Suchen/Ersetzen.

Allerdings besteht die Gefahr, dass Variable mit gleichem Namen auch umbenannt werden — auch wenn sie syntaktisch gesehen nichts miteinander zu tun haben.

Warnung: Vergeben Sie niemals Variablen-Namen doppelt. Dies macht die Quelltexte nur schwer lesbar, erzeugt unnötige Verwirrung und verhindert sinnvolles Refactoring.

Leider gibt es bei Code::Blocks noch keine weiteren Refactoring Tools, andere Entwicklungsumgebungen bieten hier mehr Unterstützung.

Syntax-Vervollständigung

Sie werden bald feststellen, dass die wichtigsten shortcuts die Tastenkombinationen

Strg Leerzeichen
Strg j

sind (sie können mit den Einstellungen des Editors auch verändert werden). Fängt man an ein Wort zu tippen, so erhält man damit Vorschläge, wie man des Wort vervollständigen kann. Dies umfasst dann sogar umfangreichere Konstrukte (wie Schleifen, if else und so weiter).

Code-Schnipsel (code snippets)

Code::Blocks bietet die Möglichkeit, häufig benutzte Code-Schnipsel strukturiert abzuspeichern. Unter

View -> Code snippets

lässt sich ein Fenster öffnen (das per default den Text-Editor überdeckt, aber man kann es zum Beispiel unten neben der Konsole andocken), mit dem sich die Schnipsel verwalten lassen.

Dazu überlegt man sich eine Baum-Struktur, wie man die Schnipsel organisieren möchte; das ist gar nicht so einfach, da man mit zunehmenden Lernerfolg diese Anordnung immer wieder umbauen möchte. Mit Hilfe von (Rechtsklick auf All Snippets)

Add SubCategory

kann eine neue Unterkategorie angelegt werden. Und mit (Rechts-Klick auf eine SubCategory)

Add Snippet

kann ein Schnipsel abgespeichert werden. Vergibt man sowohl für die Unterkategorien als auch für die Bezeichnungen der Schnipsel treffende Namen, lassen sie sich schnell auffinden.

Vorschläge für Unterkategorien sind:

Da es sich um eine Baum-Struktur handelt, können innerhalb der Unterkategorien weitere Unterkategorien angelegt werden. So kann das Code Snippets-Fenster zu einem Nachschlagewerk für die Syntax von C++ ausgebaut werden. Insbesondere sollten Sie es nutzen für Konstrukte, die man sich nur schwer merken kann und die durch die Syntax-Vervollständigung nicht abgedeckt sind.