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