Die Programmiersprache C++ Die Programmiersprache C++

Die Programmiersprache C++
Inhaltsverzeichnis
Die Programmiersprache C++ .............................................................................................................. 1
1
2
3
4
5
6
7
8
Einführung ..................................................................................................................................... 4
1.1
Syntax..................................................................................................................................... 4
1.2
Präcompiler ............................................................................................................................ 4
Variablen, Makros und Konstanten............................................................................................. 6
2.1
Tipps zu den Variablen........................................................................................................... 6
2.2
Makros.................................................................................................................................... 6
2.3
Konstanten ............................................................................................................................. 7
2.4
Präfix ...................................................................................................................................... 7
Datentypen..................................................................................................................................... 9
3.1
der Boolesche Typ ................................................................................................................. 9
3.2
Zeichentypen .......................................................................................................................... 9
3.3
Ganzzahltypen ....................................................................................................................... 9
3.4
Gleitkommatypen ................................................................................................................... 9
3.5
Eigene Datentypen................................................................................................................. 9
3.6
Nicht typisierte Werte – void................................................................................................. 10
3.7
Casting / Typumwandlung.................................................................................................... 10
3.8
Übersicht .............................................................................................................................. 10
3.9
Ratschläge ........................................................................................................................... 11
Zeiger, Felder und Strukturen.................................................................................................... 12
4.1
Arrays / Felder ...................................................................................................................... 12
4.2
Pointer / Zeiger / Adressen................................................................................................... 12
4.3
Referenzen ........................................................................................................................... 13
Bedingte Anweisungen und Schleifen...................................................................................... 14
5.1
Bedingte Anweisungen......................................................................................................... 14
5.2
Schleifen............................................................................................................................... 14
5.2.1
Die while-Schleife ........................................................................................................ 14
5.2.2
Die do-Schleife ............................................................................................................ 15
5.2.3
Die for-Schleife ............................................................................................................ 15
Funktionen................................................................................................................................... 16
6.1
Deklaration einer Funktion ................................................................................................... 16
6.2
Call-by-Reference versus Call-by-Value .............................................................................. 16
6.3
Vordefinierte Funktionen ...................................................................................................... 16
Begriffe, Schlüsselwörter, Zeichen ........................................................................................... 18
7.1
Begriffe ................................................................................................................................. 18
7.2
Schlüsselwörter .................................................................................................................... 19
7.3
Zeichen................................................................................................................................. 21
Programmierstile ........................................................................................................................ 22
9
10
8.1
OOP (Objekt orientierte Programmierung)........................................................................... 22
8.2
Entwicklung .......................................................................................................................... 22
Gedanken zur Programmierung ................................................................................................ 23
9.1
Entwicklungsstadien............................................................................................................. 23
9.2
Codeformatierung................................................................................................................. 23
9.3
Ratschläge: .......................................................................................................................... 23
Quellen ......................................................................................................................................... 24
10.1
Literatur ................................................................................................................................ 24
10.2
Tabellen................................................................................................................................ 24
Einführung in C++
1
____________________________________________________________ 1
Einführung
Das folgende Skript wurde speziell für den Einstieg in C++ entworfen. Es werden nur die Grundlagen
behandelt.
Voraussetzungen. Trotzdem sollte man folgendes Vorwissen haben:
-
was ist eine Programmiersprache / wie funktioniert sie
-
was ist ein Compiler / Präcompiler
-
ich kann mit einem Compiler umgehen
Es ist also von Vorteil, vorher schon mal mit einer Programmiersprache gearbeitet zu haben (z.B.
1
Java oder TopPascal). Die Syntax sieht der von Javaprogrammen sehr ähnlich.
1.1
Syntax
Quellcode steht in dieser Schrift. Kommentare dazu werden durch // oder bei mehreren
Zeilen durch /* eingeleitet (resp. durch */ beendet). Geschweifte Klammern {} werden in C++ zum
Gruppieren benutzt und markieren beispielsweise Anfang und Ende von Funktionsrümpfen.
Jedes Programm hat eine Startfunktion, die da lautet entweder main (für Konsoleanwendungen) oder
aber WinMain (für windowsbasierende Anwendungen).
int main()
{
// 0 wird zurückgegeben (Programm wird somit beendet)
return 0;
}
Alle weiteren (selbst definierten) Funktionen müssen von der Hauptfunktion aus manuell aufgerufen
werden. Hier die Syntax einer Funktion:
Rückgabetyp Funktionsname(Parameter)
{
// lokale Deklarationen
// Funktionsaufrufe
}
1.2
Präcompiler
Schlüsselzeichen (Direktiven) für den Präcompiler:
#include
#ifndef
#define
#endif
Inkludierungen: Alle Dateien, aus denen man Code verwenden möchte, müssen per #include
eingebunden werden. Der Compiler liest dann diese Dateien und fügt sie an der #include-Stelle ein.
Include-Guards: Sie sorgen dafür, dass eine Datei nicht zweimal eingebunden wird. Um IncludeGuards zu verwenden, fügt man folgende Marken in eine Header-Datei ein:
1
Damit meint man den „Satzbau“. In C++ sieht das so aus: Datentyp Variablenname Semikolon
Beispiel: int iTest;
Einführung in C++
____________________________________________________________ 2
#ifndef _TEST
#define _TEST
// hier kommt der Inhalt der Header-Datei hinein…
#endif
Wenn der Compiler die Header-Datei also ein zweites Mal lesen würde, dann wäre die Marke _TEST
bereits definiert und der Compiler würde den gesamten Inhalt der Header-Datei ignorieren. Praktisch,
nicht?
Einführung in C++
2
____________________________________________________________ 3
Variablen, Makros und Konstanten
Was Variablen sind, brauche ich wahrscheinlich nicht zu erklären. Der Unterschied zwischen
Variablen und Konstanten dürfte auch klar sein: Den Konstanten kann im Gegensatz zu den Variablen
2
nur einmal ein Wert zugewiesen werden, und zwar direkt bei der Deklaration . Das heisst, Konstanten
können gar nicht deklariert werden, sie müssen also direkt definiert werden!
2.1
-
Tipps zu den Variablen
das erste Zeichen einer Variable muss ein Buchstabe sein (der Unterstrich _ wird ebenfalls als
Buchstabe betrachtet)
-
Gross- und Kleinschreibung spielen bei der Namensgebung eine Rolle (Vektor ≠ vektor)
-
sehr lange Namen sind zwar erlaubt, machen den Code jedoch unübersichtlich
-
sehr kurze Namen wie x sollten nur innerhalb eines kleinen Gültigkeitsbereiches – z.B. einer
Schleife – vorkommen
-
der Name einer Variable soll also kurz und trotzdem verständlich sein
-
es kann hilfreich sein, die Variablen mit Präfixes zu versehen (vgl. weiter unten)
-
ein Variablenname darf nicht identisch mit einer vordefinierten Konstanten (z.B. NULL) oder
einem Schlüsselwort (z.B. else) sein
-
Zeichen sind ebenfalls zu meiden (z.B. a~)
-
das Namensschema sollte konstant durchgehalten werden
-
es kommt zu Komplikationen, wenn für globale und lokale Variablen dieselben Namen
verwendet werden
-
Deklariere Variablen erst, wenn sie wirklich gebraucht und auch sofort initialisiert werden
können.
-
Globale Variablen sollten gleich bei der Deklaration initialisiert werden, wenn auch bloss mit
ihren Default-Werten (z.B. NULL oder 0).
2.2
Makros
Makros sind eine Art inline-Funktion. Sie werden direkt an der Leseposition eingefügt. Meistens
verwendet man für Makro-Namen nur Grossbuchstaben und den Unterstrich.
Beispiel:
#define PRODUKT(x, y)
(x * y)
Wenn der Compiler im Quelltext auf
PRODUKT(5, 7)
stösst, wird an dieser Stelle 35 eingesetzt.
Trotz der scheinbar komfortablen Funktion der Makros sollten sie nur dort eingesetzt werden, wo es
wirklich sinnvoll ist. Denn der Code wird beim kompilieren geändert, noch bevor der Compiler ihn
2
Beispiel einer Deklaration: int iZahl; Beispiel einer Definition: int iZahl = 1;
Einführung in C++
____________________________________________________________ 4
richtig liest. Wenn das Makro fehlerhaft ist, kann dies zu einer langen Fehlersuche führen. Eine
„sinnvolle“ Anwendung von Makros sind beispielsweise Include-Guards (sorgen dafür, dass eine Datei
nicht zweimal includiert wird).
2.3
Konstanten
Konstanten werden bei der Deklaration gleich Initialisiert. Reinitialisieren, wie wir es bei einer
Variablen kennen, ist bei Konstanten nicht möglich. Ihr Wert bleibt während der ganzen
Programmlaufzeit eben konstant!
Zeilenumbrüche innerhalb von Konstanten sind nicht erlaubt.
Definitionen über #define sind in C++ fast überflüssig. Um Konstanten zu definieren kann man auch
const oder enum verwenden.
Beispiel:
2.4
const float PI = 3.1415926535897932385;
Präfix
Vor Variablen sollte immer ein Präfix (= Vorsilbe) stehen, der angibt, von welchem Typ die Variable ist
und wo im Code die Variable in die Welt gesetzt wurde (Dies trägt wesentlich zur Verständlichkeit des
Codes bei).
Liste der Typen und des entsprechenden Präfixes:
Datentypen
Datentyp
Andere Präfixe
Präfix
Erklärung
Präfix
char, UCHAR
c
Pointer
p
BOOL
b
Array
a
WORD
w
Member
m_
DWORD
dw
Global
g_
int, UINT
i
float
f
double
d
long
l
LONGLONG
ll
Tab. 1: „Präfixe“
Beispiele:
(Pointer auf char)
char *Name
... wird durch Präfixes zu ...
char *pchName
(global, DWORD)
DWORD Name
... wird durch Präfixes zu ...
DWORD g_dwName
Reihenfolge: Global / Member vor Pointer / Array vor Datentyp-Präfix
Global heisst, dass die Variable ausserhalb einer Funktion, Klasse oder Struktur definiert wurde. Als
Member bezeichnet man diejenigen Variablen, welche Attribute einer Klasse.
Einführung in C++
____________________________________________________________ 5
Anmerkung: Die oben genannten Präfixe sind nur Vorschläge und könnten natürlich frei gewählt
werden. Wichtig ist nur, dass man immer dieselben verwendet, nicht einmal i und einmal n für int. Es
spielt also keine Rolle, welches Präfix man für welche Typen benutzt. Wichtig ist nur, dass man das
Schema konstant durchhält.
Einführung in C++
____________________________________________________________ 6
3
Datentypen
3.1
der Boolesche Typ
Für den Booleschen (oder Booleanischen) Typ gibt es zwei Zustände: true und false resp. 1 und 0.
Beispiel:
3.2
bool b = true;
Zeichentypen
Ein Zeichen kann in einer Variable vom Typ char gespeichert werden, eine Zeichenkette (String) in
einem char-Array.
Beispiele:
char ch1 = ″a″;
char ch2[4] = ″hallo″;
3.3
// beginnt bei 0
Ganzzahltypen
Integer (int) gibt es in drei Formen (int, signed int und unsigned int) und drei Größen (short
int, int, long int).
Beispiel:
3.4
int i = 10;
Gleitkommatypen
Es stehen drei Grössen zur Verfügung: float (einfache Genauigkeit), double (doppelte
Genauigkeit) und long double (erweiterte Genauigkeit).
Beispiele:
float f = 10.0f;
double d = 3.14159;
3.5
Eigene Datentypen
Um mehrere Daten zusammenzufassen, bieten sich Strukturen an.
Beispiel:
struct Personalien
{
char Name[36];
int Alter;
int Grösse;
};
Der Unterschied zwischen Klassen und Objekten liegt nur beim Zugriff auf die Daten: alle Elemente
einer Struktur sind public und somit jedem Zugriff schutzlos ausgeliefert.
Einführung in C++
3.6
____________________________________________________________ 7
Nicht typisierte Werte – void
Vom Typ void gibt es keine Objekte. Somit ist es nicht möglich, eine Variable von diesem Typ zu
deklarieren. Void wird auch als Universalzeigertyp für unbekannte Datentypen verwendet, was aber
nur im Notfall zum Einsatz kommen sollte.
Beispiele:
void
// diese Funktion gibt keinen Wert zurück
funktion();
// void Pointer: zeigt auf ein unbekanntes Objekt
void* pv;
3.7
Casting / Typumwandlung
Eine Typumwandlung verwirrt den Compiler und kann zu Datenverlust führen. Deshalb sollte Casting
nur in Notfällen angewandt werden.
Beispiel:
int i;
double d1 = 0.63, d2 = 0.12;
i = (int)(d1 + d2);
Anm.: Das int in der Klammer gibt an, dass (d1 + d2) in int konvertiert werden sollen. Wird es
weggelassen, so spuckt der Compiler eine Warnung aus.
3.8
Übersicht
(Fettgedruckte Einträge gelten nur für 32bit-Systeme)
Name
Kleinster Wert
Grösster Wert
Grösse in Bit
bool
false
true
8
(signed) char
-128
127
8
unsigned char
0
255
8
enum
-2.147.483.648
2.147.483.647
32
(signed) int
-2.147.483.648
2.147.483.647
32
unsigned int
0
4.294.967.295
32
short int
-32.768
32.767
16
(signed) long
-2.147.483.648
2.147.483.647
32
unsigned long
0
4.294.967.295
32
float
3,4E-38
3,4E+38
32
double
1,7E-308
1,7E+308
64
long double
3,4E-4932
1,1E+4932
80
Tab. 2: „Übersicht über die Datentypen“
Vordefinierte Konstanten unter Windows:
Name
TRUE
Äquivalent
true, 1
Anmerkung
Einführung in C++
____________________________________________________________ 8
FALSE
false, 0
NULL
0
UINT
unsigned int
16bit bzw. 32bit
BYTE
unsigned char
8bit
WORD
unsigned short
16bit
DWORD
unsigned long
32bit
LONG
long
32bit
VOID
void
Es gibt keine void-Objekte
LPSTR
char far*
long-Zeiger auf einen String
LPCSTR
const char far*
long-Zeiger auf einen
konstanten String
HANDLE
void*
allg. Handle für div. WindowsElemente
HWND
(nicht anwendbar)
Handle zu einem Fenster
WPARAM
unsigned int
16bit bzw. 32bit
LPARAM
long
32bit
LRESULT
long
32bit
HINSTANCE
(nicht anwendbar)
Handle der Instanz (oder
Kopie)
Tab. 3: „Windows Synonyme“
3.9
-
Ratschläge
int (vor short und long), double (vor float und long double) sowie char (vor signed
und unsigned char)
-
Konvertierungen in andere Typen vermeiden (kann zu Datenverlust führen)
-
Casting (Typumwandlung) ist in den meisten Fällen ein Indiz für einen Designfehler
Einführung in C++
4
____________________________________________________________ 9
Zeiger, Felder und Strukturen
Zeiger und Felder sind sehr ähnlich oder zumindest deren Verwendungszweck. Pointer können
ebenfalls wie ein Array mit Werten gefüllt werden, wenn sie entsprechend initialisiert wurden.
4.1
Arrays / Felder
Darunter versteht man eine Sammlung von Daten des gleichen Typs (kann auch ein selbstdefinierter
Typ sein).
Beachten sie, dass die Indizierung der Feldelemente stets bei Null beginnt.
Beispiele:
int zahl[3] = {5,1,4,9};
// Wertzuweisung
int x[] = {5,1,4,9};
// so geht es auch
zahl[0] = 22;
// oder jedes einzelne Element initialisieren
int a[5.3];
// Falsch! Keine Kommazahlen als Index!
Int b[1] = {1, 2, 3};
// Falsch! Zu viele zugewiesene Werte
char ch[8] = ″012345″
// Zeichenketten können unterbrochen werden
″789″;
int matrix[2][2];
4.2
// Mehrdimensionale Arrays sind erlaubt
Pointer / Zeiger / Adressen
Unter einem Pointer (= Zeiger) versteht man eine Variable, die angibt, wo im Speicher etwas steht.
Ihr Inhalt ist eine Adresse (im Hauptspeicher).
Beispiel:
int a;
int *b = &a;
// dem Pointer b wird die Adresse und somit auch
der Wert von a zugewiesen
Anm.:
a = 5;
// b zeigt auf a und somit auf den Wert fünf
int** c;
// Pointer auf Pointer auf int
-
int** c meint dasselbe wie int **c
-
Mit & greift man auf die Adresse (Position im Speicher) einer Variable zu. Eine
Adresse hat die Form 0x[achtstelliger Hexadezimalwert].
-
Mit einem * vor einem Pointer greift man auf dessen Wert zu.
Der Speicher kann auf Grund des Pointerkonzepts auf eine einfache Art und Weise verwaltet werden.
Dazu bietet C++ die Operatoren new und delete an. Der Speicherplatz kann dadurch dynamisch
allokiert und wieder freigeben werden.
Ratschläge:
-
Benutze statt malloc() den new–Operator. Er ist um einiges flexibler.
-
vermeide Zeigerarithmetik (‚Zeigeroperationen’)
Einführung in C++____________________________________________________________ 10
4.3
Referenzen
Eine Referenz ist nichts anderes als ein Synonym für eine bestehende Variable. Sie werden vom
Compiler als gleichwertige Namen benutzt.
Beispiel:
int a = 5;
int& b = a;
// a und b sind jetzt verschiedene Bezeichner für
ein- und dieselbe Variable
b = 6;
// jetzt gilt: a = b = 6
Anstatt nun einer Funktion als Parameter den Wert einer Variable zu übergeben kann man auch eine
Referenz übergeben.
Beispiel:
int b;
funktion(b);
// b wird als Parameter übergeben
void funktion(int &a)
{
a = 6;
}
// nun hat b auch den Wert 6, denn a und b meinen
// dieselbe Variable
Einführung in C++____________________________________________________________ 11
5
Bedingte Anweisungen und Schleifen
5.1
Bedingte Anweisungen
Die Anweisung wird nur ausgeführt, wenn die Bedingung erfüllt wird (d.h., wenn sie in ihrer
Gesamtheit zutrifft):
Beispiel:
if (Geburtstag)
// ist dasselbe wie if (Geburtstag == true)
Karte_Schreiben();
Beispiel:
if (Geb == heute)
Karte_Schreiben();
else if (Geb == morgen)
Erinnerungsnotiz;
// heute Geburtstag?
// wenn ja, dann Karte schreiben…
// wenn nein, hat er morgen Geburtstag?
// wenn ja, dann eine Notiz machen…
// ansonsten nichts tun
else ;
In bestimmten Fällen kann auch die sogenannte switch-Anweisung genutzt werden:
Beispiel:
switch (Resultat)
// wenn „Resultat“ gleich ...
{
case 10:
// ... 10,
{
// Anweisung
}
case 20:
// ... 15,
{
// Anweisung
}
default:
break;
// wenn keiner der Fälle (‚cases’) zutrifft...
// unterbreche die Abfrage
}
5.2
Schleifen
Eine Schleife enthält mindestens eine Abbruchbedingung. Die nachfolgenden Anweisungen / Befehle
werden solange ausgeführt, bis die Bedingung erfüllt ist. Enthält eine Schleife mehrere Anweisungen,
so müssen diese durch Klammern eingegrenzt werden:
{ Anweisung1; Anweisung2; }
Durch das Schlüsselwort continue wird der aktuelle Schleifendurchgang unterbrochen (bei der forSchleife wird der Schleifenzähler um eins erhöht) und der nächste gestartet. Mit break wird die
Schleife sofort verlassen.
5.2.1
Die while-Schleife
Solange die Bedingung zutrifft, wird die Schleife nicht verlassen.
Syntax:
while(Bedingung)
Befehl;
Einführung in C++____________________________________________________________ 12
Beispiel:
while(Key_nicht_gedrückt)
// Warten auf eine Eingabe des Benutzers
; // tue nichts
5.2.2
Die do-Schleife
Dieser Schleifentyp kommt eher selten zum Einsatz. Der Wesentliche Unterschied zur while-Schleife
besteht darin, dass es mindestens einen Durchgang gibt. D.h. es wird zuerst etwas durchgeführt, erst
dann wird das Abbruchkriterium geprüft.
Syntax:
do{
Anweisung;
} while(Bedingung);
5.2.3
Die for-Schleife
Beispiel:
for(Variable; Abbruchbedingung; Erhöhungsschritt)
Befehl;
Anwendung: z.B. Daten vom einen zum anderen Arrray kopieren:
for(int i=0; i<Anz; i++)
Array1[i] = Array2[i];
// mit Anz ist der grösste Index der Arrays gemeint
Einführung in C++____________________________________________________________ 13
6
Funktionen
6.1
Deklaration einer Funktion
Syntax:
Rückgabetyp Funktionsname (Parameter);
Rückgabetyp: kann ein beliebiger Datentyp (auch ein Pointer) sein
Wenn der Rückgabetyp ungleich void ist, dann muss am Ende einer Funktion das
Schlüsselwort return stehen.
Parameter:
werden übergeben, weil die Funktion diese Werte zum Rechnen benötigt
Beispiele:
int quadrieren(int x)
// ein Integer als Parameter
{
return (x*x);
// ein Integerwert wird zurückgegeben
}
const char* Benutzername() // keine Parameter
{
return
″Rudolf″;
// eine Konstante wird zurückgegeben
}
Synonyme:
Funktion, Methode, Modul, Prozedur (obwohl es geringe Unterschiede zwischen diesen
Begriffen gibt, verwendet man sie meist als Synonyme)
Tipp:
Funktionen sollten nicht zu lang werden, besser in kleine Happen aufteilen, dies macht
den Code übersichtlicher!
6.2
Call-by-Reference versus Call-by-Value
Bei Call-by-Reference wird eine Referenz oder ein Pointer als Parameter übergeben, das heisst, die
Funktion kann den Wert der übergebenen Referenz ändern. Bei Call-by-Value wird mit return
gearbeitet. Der Übergebene Wert ist wirklich nur eine Zahl / eine Zeichenkette, das heisst, wenn die
Werte verändert werden, hat dies keinen Einfluss auf die Variable, die der Funktion übergeben wurde.
Call-by-Value ist einiges Langsamer, da ein Wert (‚Value’) übergeben werden muss. Wenn man zwar
eine Referenz verwenden, den Wert der Referenz von der Funktion aber nicht verändern lassen
möchte, dann kann man das Schlüsselwort const bei der Funktionsdeklaration setzen.
6.3
Vordefinierte Funktionen
Unter Windows stehen einige vordefinierte Funktionen zur Verfügung. Hier eine Auswahl:
main / WinMain
mögliche Startfunktionen eines Windows-Programms
sin / sinf
der Sinus einer (float-) Zahl
cos / cosf
der Cosinus einer (float-) Zahl
tan / tanf
der Tangens einer (float-) Zahl
abs / fabs / fabsf
der absolute Wert einer (ganzen / double- / float-) Zahl
sqrt / sqrtf
die Wurzel
Einführung in C++____________________________________________________________ 14
pow / powf
potenzieren
printf
Textausgabe in das Konsolefenster
sprintf
Text in ein char-Array schreiben
strcmp
vergleicht zwei char-Arrays
sscanf
durchsucht einen String nach einer Zahl
fprintf
Text in eine Datei schreiben
fopen
Datei öffnen (intern)
fseek
schiebt den Lesecursor in der Datei weiter / zurück
fscan
durchsucht die Datei nach einer Zahl
fclose
Datei schliessen
MessageBox
öffnet ein Dialogfeld
DialogBox
öffnet eine Dialog-Box
ShellExecute
öffnet eine Datei (für den Benutzer sichtbar)
CoInitialize
COM registrieren
CoUnitialize
COM beenden
TranslateMessage
Nachricht übersetzen
DispatchMessage
Nachricht verarbeiten (Windows-Standardverarbeitung)
Sleep
legt den Thread schlafen (Prozessorleistung reduzieren)
GetModuleFileName
liefert den Namen der Anwendung inkl. Pfad
mciSendString
diverse Funktionen (z.B. Öffnen des CD-ROM Laufwerks)
Die Parameter dieser Funktionen können in der Dokumentation von Visual C++.NET nachgelesen
werden.
Einführung in C++____________________________________________________________ 15
7
Begriffe, Schlüsselwörter, Zeichen
7.1
Begriffe
Deklaration
Bevor eine Variable benutzt werden kann, muss sie deklariert werden.
Beispiele:
char ch;
int a, b;
// meint dasselbe wie int a; int b;
Definition
Eine Variable zu definieren heisst nichts anderes, als ihr einen Wert zuzuweisen.
Beispiel:
char ch = ″a″;
int i = 1;
Syntax
Definiert die Anordnung von Elementen, also dessen Reihenfolge. Zur Syntax von C++ gehört
beispielsweise das Semikolon am Ende einer Zeile.
Beispiel:
Datentyp Variblenname = Wert;
globale Variablen (globals)
Eine Variable wird als global bezeichnet, wenn sie ausserhalb einer Funktion, einer Struktur oder einer
Klasse deklariert wurde.
Vererbung und Polymorphismus
Unter Vererbung versteht man die Ableitung eines Objekts von einem anderen, wobei alle Merkmale
und Fähigkeiten an das neue Objekt mitgegeben werden.
Beispiel: Die Basisklasse könnte Beispielsweise ‚Waffe’ heissen. Davon könnte man Klassen mit dem
Namen AK-47, M60 oder Thompson ableiten, die alle Grundfunktionen der Basisklasse vererbt
bekommen (z.B. Feuern, Nachladen, …).
Die Polymorphie macht es nun möglich, dass ein Objekt die geerbte Funktion abändern kann, um sie
den eigenen Bedürfnissen anzupassen.
Beispiel: Man lädt ja nicht jede Waffe auf die gleiche Weise nach. So heissen die Methoden zum
Nachladen aller Objekte gleich und bringen auch dasselbe Resultat, aber deren Funktionsweise ist
eine andere.
Weitere wichtige Begriffe
Funktionen, Methoden, Allokierung, Destruktor, Konstruktor, Compiler, compilieren ( kompilieren),
Präcompiler, Direktiven (Anweisungen für den Compiler?), Parameter, Makro, Gültigkeitsbereich,
akquirieren (engl. acquire),
Einführung in C++____________________________________________________________ 16
7.2
Schlüsselwörter
Schlüsselwörter werden in der Programmierebene blau hervorgehoben. Hier sind einige davon erklärt:
class
Eine Klasse definieren.
struct
Eine Struktur definieren
extern
Mit extern definierte Variablen sind bereits an einer anderen Stelle im Quellcode definiert worden. Man
setzt extern davor, damit der Compiler nicht meckert.
include
(‚einbinden’). Durch diesen Befehl werden sozusagen zwei Dateien miteinander verknüpft.
ifndef, endif
Man benutzt die folgenden Direktiven, um auszuschliessen, dass derselbe Code mehrfach kompiliert
wird. Dazu kommt es, wenn in einer Header-Datei alle anderen Header per #include eingebunden
werden. Bei der Zeile #ifndef Test (if not defined „Test“) prüft der Präcompiler, ob das Symbol
Test bereits definiert ist. Ist dies der Fall, so wird der nachfolgende Quelltext (bis zur Marke #endif)
einfach ignoriert. ifndef ist also quasi eine Direktive für die bedinge Übersetzung in die
Maschinensprache. Würde man keine so genannten Include-Wächter (Include-Guards) verwenden,
dann
würden
eventuell
einige
Header-Dateien
mehrmals
eingelesen
und
es
käme
zu
Mehrfachdefinitionen und Kollisionen von Makronamen.
define
Mit #define werden Makros oder Konstanten definiert.
enum
Das Schlüsselwort enum hat eigentlich dieselbe Bedeutung wie #define, nur werden den mit enum
definierten Konstanten keine Werte zugewiesen.
continue
Wird
vor
allem
im
Zusammenhang
mit
Schleifen
verwendet.
Es
bricht
den
aktuellen
Schleifendurchgang ab.
inline
Das Schlüsselwort inline vor einer Funktion bewirkt, dass der Inhalt dieser Funktion beim
Kompilieren (Linker) überall an die Stellen kopiert wird, an denen sie aufgerufen wurde (ähnlich wie
bei einem Makro).
Während der Programmlaufzeit muss diese Funktion dann nicht mehr aufgerufen werden. Dadurch
wird Rechenzeit gespart, dafür aber mehr Speicher verpuffert.
public
Einführung in C++____________________________________________________________ 17
Auf public-Elemente kann von jedem Ort der Engine aus (innerhalb der Klasse, in abgeleiteten
Klassen und von ausserhalb) zugegriffen werden.
private
Bei private kann nur von innerhalb der Klasse auf das Element zugegriffen werden.
protected
Ein protected-Member verhält sich wie ein private Member, mit einer Ausnahme: Abgeleitete Klassen
haben Zugriff auf die protected-Elemente ihrer Basisklassen. Weiterhin kann eine beliebige Klasse mit
dem Schlüsselwort friend Zugriff auf die protected Members bekommen
union
Union verwendet man in Strukturen oder Klassen und bedeutet, dass sich mehrere Variablen den
gleichen Speicherplatz teilen. Daher kann immer nur eine von ihnen gleichzeitig genutzt werden.
Wenn der Wert der einen Variablen verändert wird, so passt sich der Wert des korrespondierenden
Elements automatisch an.
const
Für die Definition einer Konstanten.
operator
Mit dem Schlüsselwort operator können eben Operatoren für Klassen definiert werden. Somit
können zwei Objekte derselben Klasse z.B. mit einem Plus verknüpft werden. Ist dies der Fall, wird
die Methode operator +() dieser Klasse aufgerufen.
new
Damit kann einem Pointer Speicher zugewiesen werden.
delete
Damit wird ein Pointer gelöscht.
break
Bricht eine Schleife oder eine switch-Anweisung ab.
continue
Bricht den aktuellen Schleifendurchgang ab und erhöht den Schleifenzähler.
inline
Per inline definierte Funktionen sind sehr schnell. Sie werden wie Makros beim Kompilieren an der
Leseposition eingefügt, sind aber sicherer als Makros.
static
Von Klassen, die Attribute und Methoden beinhalten, die das Schlüsselwort static tragen, kann nur ein
Objekt erstellt werden.
Einführung in C++____________________________________________________________ 18
7.3
Zeichen
Arithmetische Operatoren
Vergleichsoperatoren
Sonstige
+
Addition
==
gleich
&&
und
-
Subtraktion
!=
ungleich
|
bitweise
kombinieren
*
Multiplikation
!
einen
booleschen
Wert
umkehren
&
bitweise
überprüfen
/
Division
<
kleiner als
\n
Zeilenumbruch
%
Modulo (liefert den
Rest nach Division)
>
grösser als
\a
ASCII-Zeichen
Bel (erzeugt
Piepston)
++
erhöht um eins
<=
kleiner gleich
<<
ein Bit nach
links
+= x
Erhöht um x
>=
grösser gleich
>>
ein Bit nach
rechts
=
Zuweisungsoperator
||
oder
Tab. 4: „Präfixe“
Der Compiler ‚kennt’ die Punkt-vor-Strich Regel. Im Zweifelsfall oder zur Verdeutlichung können
natürlich trotzdem Klammern gesetzt werden.
Einführung in C++____________________________________________________________ 19
8
Programmierstile
8.1
OOP (Objekt orientierte Programmierung)
Eine Klasse enthält Daten (Attribute) und Funktionen (Methoden).
-
public meint öffentlich, also ohne Schutz
-
private oder protected meint, dass diese Daten nur von den innerhalb dieser Klasse
deklarierten Funktionen genutzt werden können.
Eine Funktion, die den gleichen Namen wie die Klasse trägt, heisst Konstruktor genannt.
Der Konstruktor einer Klasse wird beim Erzeugen eines neuen Objekts einer Klasse aufgerufen. Der
Destruktor dient zur Freigabe des Objekts. Von einer Klasse, die nicht als static deklariert wurde,
können beliebig viele Objekte erstellt werden. Über die Objekte kann man auf die public-Elemente der
Klasse zugreifen.
8.2
Entwicklung
-
anfangs nur lineare Programmabläufe (keine Funktionen oder Klassen)
-
danach modulare Programmierung – eine Funktion ruft die andere auf (Codelänge und
Arbeitsaufwand drastisch reduziert).
-
Objekt orientierte Programmierung – Unterteilung des Programms in Klassen (Programme
werden überschaubar)
Einführung in C++____________________________________________________________ 20
9
Gedanken zur Programmierung
9.1
Entwicklungsstadien
Bei der Entwicklung eines Programms wird die Arbeit in folgende Kapitel aufgeteilt:
-
Planung
-
Implementierung (Umsetzung in ein Programm)
-
Optimierung
-
Test (Fehler beheben)
-
Dokumentation
Zur Implementierung kann ich aus eigener Erfahrung sagen, dass sich Trial and Error bewährt. Klar ist
es nicht immer sinnvoll, besonders für fortgeschrittene Programmierer, jeweils nach fünf neuen Zeilen
Code wieder zu kompilieren. Für Anfänger ist diese Taktik jedoch zu empfehlen.
9.2
Codeformatierung
Ohne Codeformatierung geht’s fast nicht. Übersichtlichkeit ist sehr wichtig, besonders in grösseren
Projekten. Hier ein paar Tipps zur Gestaltung.
Kommentare
Halten sie Kommentare kurz und präzise. Sie müssen sinnvoll und auf dem neusten Stand sein.
Kommentare sollen schliesslich helfen, den Code besser zu verstehen. Überflüssige Kommentare
machen den Code nur unnötig unübersichtlich:
int a = 0;
// Variable a wird initialisiert
Klammern
Die geöffnete und die geschlossene Klammer sollten immer auf einer vertikalen Linie sein, sodass
man schnell erkennen kann, wo eine Anweisung beginnt und wo sie aufhört.
9.3
Ratschläge:
-
Gute Planung führt zum Erfolg! Planung ist das A und O eines jeden Programms.
-
achte auf eine konstante Codeformatierung und Namensgebung
-
verpasse verwandten Variablen, Klassen und Funktionen gemeinsame Namensbereiche
-
meide globale Variablen
-
fasse Variablen und Funktionen in Klassen zusammen
-
halte die Kommentare kurz und treffend
-
eine Klasse / eine Funktion soll von einer anderen möglichst unabhängig funktionieren!
-
„Trial and Error“: Mut zum Experimentieren! Nichts gelingt gleich auf Anhieb und ohne
Verbesserungen!
Einführung in C++____________________________________________________________ 21
10 Quellen
10.1 Literatur
Websites:
http://tau.fesg.tu-muenchen.de/~dieter/oop/cppdaten.php [Stand: 04.07.04]
http://html-tut.webmaster-eye.de/javascript/objektorientiert.htm [Stand: 09.10.05]
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/_pluslang_static.asp
[Stand: 09.10.05]
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/csref/html/vclrfStaticPG.asp [Stand:
09.10.05]
http://www.zfx.info [Stand: 09.10.05]
http://www.dpunkt.de/java/Die_Sprache_Java/Objektorientierte_Programmierung/8.html [Stand:
10.10.05]
Bücher
Stroustrup, Bjarne (2000). Die C++ Programmiersprache. München: Addison-Wesley Verlag
(ISBN: 3-8273-2058-5)
10.2 Tabellen
Tab.2 + 3: http://www.datasource.de/programmierung/tab33_cppdatentypen.html [Stand: 03.07.04]
Tab.1 + 4: Eigenproduktion
© 2005 by Reto Da Forno | http://www.keepcoding-development.ch.vu
Der Inhalt des Dokuments basiert auf meinem durch die oben genannten Quellen erworbenen
Wissen. Fehler oder Irrtümer vorbehalten.