1. Daten

Inhalt:

1.1 helloworld++

Vorab sie auf die Geschichte der diversen Programmiersprachen verwiesen, C++ stammt dabei von C ab.

Das von C bekannte HelloWorld-Programm:

#include <stdio.h>

int main(void)
{
        printf("hello world!\n");
        return 0;
}

Compilieren: cc hallo.c -o hallo

Das gleiche Programm in C++:

#include <iostream>

using namespace std;   // cout bekanntmachen

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

Compilieren: c++ hallo.cc -o hallo

Unterschiede zwischen C und C++:

Anstatt der stdio-Bibliothek wird die iostream-Bibliothek verwendet
Die "using namespace std" Anweisung wird bei Namensräumen näher erklärt
Bei C ist "()" als Funktionsparameter undefiniert (K&R C: beliebige Parameter), bei C++ ist dies äquivalent mit "(void)"
Kommentare können in /* und */ eingeschlossen werden, oder mit // eingeleitet werden. Letztere gelten bis ans Ende der Zeile
Das Hauptprogramm heisst nach wie vor "main"
Anstatt des stdio-Aufrufs printf() wird mit dem iostream-Operatoren cout, << und endl gearbeitet
stdio (printf, scanf, ...) kann auch in C++ verwendet werden, ist jedoch bei Benutzung von Objekten etwas weniger elegant.
Das Hauptprogramm liefert nach wie vor einen Integer-Wert zurück

Dateiendungen für C++: .cc, .cpp, .hpp

1.2 Variablen

Datentypen:

Aus C bekannt:

char	Ein Zeichen, 8 Bit, ASCII-codiert
short int = short	16bit Ganzzahl mit Vorzeichen
int	32bit Ganzzahl mit Vorzeichen
long int = long	32 oder 64bit Ganzzahl mit Vorzeichen
float	Fließkommazahl für einfache Genauigkeit
double	Fließkommazahl für doppelte Genauigkeit
unsigned short int	16bit-Zahl ohne Vorzeichen
unsigned int	32bit-Zahl ohne Vorzeichen
unsigned long int	32 oder 64bit Ganzzahl ohne Vorzeichen
char *	Adresse einer char-Variable (32/64bit)
void	Kein Wert (für Funktionen)

Neu in C++: "bool" für Wahrheitswerte, kann Werte "true" und "false" annehmen. Beispiel:

     bool b;

     b = a < b;     // Zuweisung - entweder "true" oder "false"
     b = true;
     b = false;
     b = 1;         // == true
     b = 0;         // == false

     if (b) ...     // Benutzen als Wahrheitswert

     printf("b = %d\n", b);           // b = 1
     cout << "b = " << b << end;      // b = 1

Deklaration:

Allgemein: [modifier] typ name [= konstante];
Bei Namen wird zwischen Gross- und Kleinschreibung unterschieden
Gueltige Zeichen sind a-z, A-Z, 0-9 und _. Keine Umlaute!
Modifier sind: unsigned, short, long, static, volatile, const, auto ...
Bei Angabe einer Konstante wird die angegebene Variable initialisiert, ansonsten ist der Wert undefiniert

Konstanten:

wie in C
für bool: "true", "false"

1.3 Speicher

Speicheraufbau
Statische Speicherverwaltung:
- Variablen gelten ab dem Punkt im Programm an dem sie deklariert werden
- Gültigkeit ist entweder global oder lokal
- Im Gegensatz zu C können Variablen auch mitten in einem Code-Block deklariert werden
```
int i=1;
i++;

int j = i;
j++; 
```
- Statisch belegte Variablen (bzw. ihr Speicher) wird am Ende des umfassenden Blocks freigegeben.
```
int main()
{
  int i;

  for (int j=0; j<10; j++) {
    int k;

    {
      double l;
      ...
      
    } // l freigeben
    
  } // j und k freigeben
  
} // i freigeben
	  
```
- Wie bisher auch ist Vorsicht beim Umgang mit Zeigern auf statischen Speicher geboten, falls dieser Freigegeben wurde.
```
int *p;
if (1) {
    int i;
    p = &i;
}
*p = 17;   // Speicherschutzverletzung 
```

Dynamische Speicherverwaltung: malloc/free, new/delete (spaeter)

Dynamische Anforderung von Speicher mit malloc(3), Rückgabewert ist die Adresse eines Speicherbereichs der angegebenen Größe
Freigeben mit free(3)
Nach Freigabe ist ein Zugriff auf den Speicher nicht mehr definiert

Beispiel:

int *p;
p = malloc(10 * sizeof(int));
if (p == NULL) {
    cerr << "Kein Speicher mehr da!" << endl;
    exit(1);
}

...
*p = 1;      // Zugriff mit Pointer-Schreibweise
*(p+1) = 2;  // Zugriff mit Pointer-Schreibweise
p[2] = 3;    // Zugriff mit Array-Schreibweise

p++;         // XXX Ganz schlechte Idee!

...
free(p);

*p = 42;     // XXX Speicher ist nicht mehr definiert!

1.4 Zeiger

Genau wie in C
Zeiger stellen Adressen von Variablen dar
Deklaration wie in C
Arithmetik wie in C
Speicherverwaltung mit malloc/free etc. wie in C

1.5 Felder

Deklaration: typ name[groesse];
"name" ist dabei ein "const typ *", d.h. ein konstanter Zeiger auf eine oder mehrere Variable vom Typ "typ". Konstant ist dabei der Zweigerwert (== die Adresse), jedoch nicht der Inhalt -- dieser kann durchaus verändert werden.
Der Zugriff geht von Element 0 bis Element "groesse-1"
Wie C geschieht auch in C++ keine Pruefung der Größe
Ohne Initialisierung sind die einzelnen Werte undefiniert.

Wahlweise kann sofort eine Initialisierung stattfinden:

int a[5] = { 0, 1, 2, 3, 4 };

int b[]  = { 0, 1, 2, 3, 4 };

char hallo[] = { 'H', 'a', 'l', 'l', 'o', '\0' };
char welt[] = "Welt!";

int c[2][3] = { { 11, 12, 13}, {21, 22, 23} };

Zugriff:

Array-Schreibweise:

int name[5];

name[0] = 17;         // L-Wert
int i = name[0];      // R-Wert

Pointer-Schreibweise:

int name[5];

*name = 42;           // L-Wert
int i = *name;        // R-Wert

*(name + 1) = i;      // mit Pointerarithmetik
int j = *(name + 1);

Mehrdimensionale Arrays sind zeilenweise orientiert, d.h. bei int f[5][10]; ist f[0] die Adresse eines Feldes von 10 int-Werten
Wie einzelne Variablen können auch Felder (Arrays) mit malloc(3) angefordert und mit free(3) freigegeben werden. Für mehrdimensionale Felder ist entsprechender Aufwand zu betreiben.

1.6 Beispiele

Einlesen eines Cent-Betrags und fals nicht ganzzahlig aufrunden zum nächsten ganzzahligen Betrag (vgl. Jobst Blatt 2.2a; Java-Lösung)
Reihe der Fibonacci-Zahlen iterativ berechnen (Lösung)
Feld mit 10 jeweils nur einmal vorhandenen Zufallszahlen generieren (Lösung)
Beispiel zu Strings und Arrays

1.7 Übungen

C++ Code analysieren (Sauer Test Nr. 6)
C++ Code analysieren (Sauer Test Nr. 7)
Wochentag berechnen (Jobst 3.3)
Pascal'sches Dreieck zeichnen (Schicker Blatt 1.3 / Jobst Blatt 6.3)
Lottoziehung: 6 aus 49 (Jobst Blatt 6.1)