Einführung in C++ (Erinnerungen an C)

Basisdatentypen

Außerdem sind Arrays und Pointer mit diesen Typen möglich.

Typmodifikatoren ändern Bedeutung

Vorangestellte Modifikatoren ändern Bedeutung:

1. Länge im Speicher

   short	Speicher: halbe Wortlänge
   long	Speicher: doppelte/dreifache Wortlänge

2. Vorzeichen

   signed	mit Vorzeichen (Default bei Zahlen)
   unsigned	ohne Vorzeichen

Anwendung auf ganze Zahlen:

• short und long sind Synonyme für short int und long int
• long long ist typischerweise eine ganze Zahl mit 8 Byte
• unsigned char sind Zahlen von 0, ..., 255 (1 Byte)
• zusätzlich: long double (nur diese Form)

Sie können short, long und long long nur für ganze Zahlen (int) nutzen, mit der Ausnahme long double. Dagegen können signed und unsigned sowohl für char als auch für int benutzt werden.

vgl. en.wikipedia.org/wiki/C_data_types

Größe eines Datentyps ist maschinenabhängig

• Zahlenbereiche für konkrete Implementierung in Header-Files definiert

  limits.h und float.h: Konstanten INT_MAX, INT_MIN, ...

• Alternativ Herausfinden der Größe in Bytes: Operator sizeof

  Syntax: sizeof(Typ)

Es gilt in C/C++:

• sizeof(unsigned char) $=$ 1
• sizeof(short int) $=$ 2
• sizeof(short int) $\le$ sizeof(int) $\le$ sizeof(long int)
• sizeof(float) $\le$ sizeof(double) $\le$ sizeof(long double)

Hinweis Arrays: sizeof gibt immer die Anzahl der Bytes für einen Typ oder eine Variable zurück. Bei Array ist das nicht unbedingt die Anzahl der Elemente im Array!

Beispiel:

char a[10];
double b[10];

sizeof(a) würde den Wert 10 als Ergebnis liefern, da ein char in C/C++ immer exakt ein Byte benötigt und entsprechend 10 char 10 Byte. sizeof(b) ist maschinenabhängig und liefert die Anzahl der Bytes, die man für die Darstellung von 10 Double-Werten benötigt.

Wenn man die Anzahl der Elemente im Array mit sizeof herausfinden will, muss man den Gesamtwert für das Array noch durch den Speicherbedarf eines Elements teilen, also beispielsweise sizeof(b)/sizeof(b[0]).

(Beispiele für) Schleifen und Kontrollstrukturen in C/C++

int x=5, y=1;


if (x>5) {
    x++;
} else if(y<=1) {
    y = y-x;
} else {
    y = 2*x;
}


while (y>0) {
    y--;
}


for (x=0; x<10; x++) {
    y = y*y;
}

Funktionen in C und C++

• Funktionen sind mit Methoden in Java vergleichbar

  => sind aber unabhängig von Klassen bzw. Objekten

• Syntax:

  Rueckgabetyp Funktionsname(Parameterliste) {
      Anweisungen (Implementierung)
  }

• Aufruf: Nennung des Namens (mit Argumenten) im Programmcode

  int x = foo(42);

Anmerkung: Unterschied "Parameter" und "Argument":

• Funktion hat "Parameter" in ihrer Parameterliste, auch "formale Parameter" genannt
• Beim Aufruf werden "Argumente" übergeben, auch "aktuelle Parameter" genannt

In der Praxis verwendet man beide Begriffe i.d.R. synonym.

Funktionen: Deklaration vs. Definition

• Deklaration: (Funktions-) Prototyp: Festlegen von Signatur (d.h. Funktionsname und Anzahl, Typ, Reihenfolge der Parameter) u. Rückgabetyp

  void machWas(int, int);

• Definition: Implementierung der Funktion

  void machWas(int a, int b) {
      cout << "a: " << a << ", b: " << b << endl;
  }

• Compiler "liest" Quellcode von oben nach unten

• Funktionen müssen (wie alle anderen Symbole auch) vor ihrer Verwendung zumindest deklariert sein, d.h. es muss zumindest ihre Signatur bekannt sein (siehe nächste Folie)

• Deklaration: Variablennamen können weggelassen werden

One Definition Rule (für Funktionen)

Funktionen und Parameter

• Funktionen "ohne" Parameter:

  Leere Parameter-Liste[^1] oder Schlüsselwort void

  void fkt();
  void fkt(void);

• Funktionen mit Parameter:

  • Deklaration: Variablennamen können weggelassen werden
  • Definition: Variablennamen müssen angegeben werden

  void fkt(int, char);
  void fkt(int a, char b);
  
  void fkt(int a, char b) { ... }

Leere Parameterliste in C

Wenn eine Funktion keine Parameter hat, können Sie wie in C die Parameterliste entweder einfach leer lassen (int fkt();) oder das Schlüsselwort void nutzen (int fkt(void);).

Betrachten Sie folgendes Beispiel:

// Legal in C
int wuppie();                   // Deklaration: "Ich verrate Dir nicht, wieviele Parameter wuppie() hat."
int wuppie(int x) { return x; } // Aufruf mit Argumenten => ist okay

// Fehler in C
int fluppie(void);               // Deklaration: fluppie() hat KEINE Parameter!
int fluppie(int x) { return x; } // Aufruf mit Argumenten => Compiler-Fehler

Wenn Sie eine mit leerer Parameterliste deklarierte Funktion definieren bzw. aufrufen, akzeptiert der C-Compiler dennoch alle übergebenen Parameter. Dies kann zu schwer verständlichen Fehlern führen! Sobald eine Funktion explizit mit dem Schlüsselwort void in der Parameterliste deklariert wird, muss diese dann auch ohne Parameter aufgerufen werden.

=> Bevorzugen Sie in C die Variante mit dem Schlüsselwort void!

Leere Parameterliste in C++

Keine Parameter: Leere Liste und Schlüsselwort void gleichwertig

void fkt();
void fkt(void);

Defaultparameter in C++

• Parameter mit Defaultwerten am Ende der Parameterliste
• Bei Trennung von Deklaration und Definition: Defaultparameter nur in Deklaration

// Deklaration
void f(int i, int j=1, int k=2);

// Definition
void f(int i, int j, int k) { ... }

Überladen von Funktionen

• Funktionen im gleichen Gültigkeitsbereich können überladen werden
• Zu beachten:
  1. Funktionsname identisch
  2. Signatur (Anzahl, Typen der Parameter) muss unterschiedlich sein
  3. Rückgabewert darf variieren

=> Warnung: Überladene Funktionen sollten gleichartige Operationen für unterschiedliche Datentypen bereitstellen!

Probleme beim Überladen von Funktionen

1. Defaultparameter

   int maximum(int, int);
   int maximum(int, int, int=10);

2. Identische Signatur, Unterschied nur im Rückgabewert

   int maximum(int, int);
   double maximum(int, int);

3. Überladen nur für Funktionen des selben Gültigkeitsbereichs!

   #include <iostream>
   using namespace std;
   
   void f(char c) {
       cout << "f(char): " << c << endl;
   }
   void f(int i) {
       cout << "f(int): " << i << endl;
   }
   
   
   int main() {
       void f(int i);  // f(char) nicht mehr sichtbar!
       f('a');
   
       return 0;
   }

Parameterübergabe in C/C++: Call-by-Value

int add_5(int x) {
    x += 5;
    return x;
}

int main() {
    int erg, i=0;
    erg = add_5(i);
}

 Aufrufer-Sicht
              i                      erg
           +-----+                 +-----+
           |     |                 |     |
           +--+--+                 +--^--+
              |                       |
              |                       |
--------------+-----------------------+-----
  Kopie bei   |                Kopie  |
  Aufruf      |                bei    |
              |                return |
           +--v--+                    |
           |     +--------------------+
           +-----+
              x
 Funktionssicht

• Default in C/C++ ist die call-by-value Semantik:
  • Argumente werden bei Übergabe kopiert
  • Ergebniswerte werden bei Rückgabe kopiert
• Folgen:
  • Keine Seiteneffekte durch Verändern von übergebenen Strukturen
  • Negative Auswirkungen auf Laufzeit bei großen Daten

Ausnahme: Übergabe von C++-Referenzen oder Pointern (wobei Pointer streng genommen auch kopiert werden, also per call-by-value übergeben werden ...)

Unterschiedliche Variablenarten

Lokale Variablen ("automatische Variablen")

int b = 1;

void f() {
    int b = 42;
}

int main() {
    int b = 3;

    {
        int b = 7;
    }
}

• Innerhalb einer Funktion (oder Blockes) definierte Variablen

• Gilt auch für Variablen aus Parameterliste

• Überdecken globale Variablen gleichen Namens

• Sichtbarkeit:

  • Außerhalb der Funktion/Blockes nicht zugreifbar
  • Beim Betreten der Funktion Reservierung von Speicherplatz für lokale Variablen
  • Dieser wird beim Verlassen des Blockes/Funktion automatisch wieder freigegeben
  • Namen sind nur nach Deklaration und innerhalb des Blockes, in dem sie deklariert wurden, gültig
  • Namen sind auch gültig für innerhalb des Blockes neu angelegte innere Blöcke

  Software Engineering: Vermeiden Sie lokale Namen, die Namen aus einem äußeren Scope überdecken!

=> Werden auch als automatische Variablen bezeichnet

Globale Variablen ("externe Variablen")

/* ======== Datei main.cpp (einzeln kompilierbar) ======== */
int main() {
    extern int global;  // Deklaration
}

int global;             // Definition

/* ======== Datei foo.cpp (einzeln kompilierbar) ======== */
extern int global;      // Deklaration

void foo() {
    global = 45;
}

• Globale Variablen: Außerhalb jeder Funktion definierte Variablen
• Globale Variablen gelten in allen Teilen des Programms
• Auch in anderen Dateien! => müssen bei Nutzung in Funktionen als extern deklariert werden
• Existieren die gesamte Programmlebensdauer über

=> Werden auch als externe Variablen bezeichnet

Die Dateien sind einzeln kompilierbar (extern sagt dem Compiler, dass die Variable woanders definiert ist) => erst der Linker löst das auf.

Hinweis: Bei globalen Konstanten in C++ brauchen Sie zusätzlich auch bei der Definition ein "extern", da die Konstante sonst nur in ihrer Datei sichtbar ist.

Statische lokale Variablen

void foo() {
    static int x = 42;
    x++;
}

int main() {
    foo();  foo();  foo();
}

• Lokale Variablen mit "Gedächtnis": Definition mit dem vorangestellten Schlüsselwort "static"

  static int callCount;

• Eigenschaften:

  • Wert bleibt für die folgenden Funktionsaufrufe erhalten
  • Wert kann in der Funktion verändert werden
  • Dennoch: lokale Variable, d.h. von außen nicht sichtbar/gültig

Hinweis: static für globale Variablen bedeutet etwas anderes! (s.u. "Sichtbarkeit")

Initialisierung von Variablen

(Automatische) Initialisierung von Variablen hängt von ihrer Speicherklasse ab!

• Automatisch
  • Werden nicht automatisch initialisiert (!)
  • Bei vorgegebenem Wert ab Aufruf der Funktion
• Extern
  • Mit dem Wert 0 oder vorgegebenem Wert
  • Bereits vor Programmstart (im Code enthalten)
• Statisch
  • Mit dem Wert 0 oder vorgegebenem Wert
  • Ab erstem Aufruf der Funktion

Sichtbarkeit globaler Variablen (und Funktionen) beschränken

• Beschränkung der Gültigkeit von globalen Variablen auf die Datei, wo sie definiert sind: Schlüsselwort static
  • werden (weiterhin) automatisch mit 0 initialisiert
  • sind nun nur in der Datei sichtbar/gültig, wo sie definiert sind
  • dient zur Vermeidung von Namenskonflikten bei globalen Variablen
• Sichtbarkeitsbeschränkung gilt auch für Funktionen

static für globale Variablen beschränkt deren Sichtbarkeit auf die Datei, wo sie definiert sind. D.h. man kann diese dann nicht in einer anderen Datei nutzen, nicht mal mit extern ...

static für Funktionen beschränkt deren Sichtbarkeit ebenfalls auf die Datei, wo sie definiert sind. Man kann sie dann nur in anderen Funktionen, die ebenfalls in der selben Datei definiert werden, nutzen. In anderen Dateien sind die static Funktionen nicht sichtbar. D.h. es macht auch keinen Sinn, sie in einer Header-Datei zu deklarieren! (In der Praxis liefert der gcc dann sogar einen Fehler!). Das ist mit private Methoden vergleichbar.

Globale Konstanten

In C funktionieren globale Konstanten wie globale Variablen

• Definition in einer Übersetzungseinheit ohne "extern"

  => Definition als "extern" wird in C mit einer Warnung quittiert!

• Nutzung in anderen Übersetzungseinheiten durch (erneute) Deklaration als "extern"

• Beispiel:

  /* ======== Datei main.c ======== */
  const int PI=123;       // Definition OHNE "extern" (C)
  
  int main() {
      fkt_a1();
      int x = PI;
      ...
  }

  /* ======== Datei a.c ======== */
  extern const int PI;    // (erneute) Deklaration mit "extern"
  void fkt_a1() {
      int x = PI;
      ...
  }

In C++ sind globale Konstanten per Default nur in ihrer Definitionsdatei sichtbar!

• Abhilfe: Definieren und Deklarieren mit extern

• Beispiel:

  /* ======== Datei main.cpp ======== */
  extern const int PI=123;    // Definition MIT "extern" (C++)
  
  int main() {
      fkt_a1();
      int x = PI;
      ...
  }

  /* ======== Datei a.cpp ======== */
  extern const int PI;        // (erneute) Deklaration mit "extern"
  void fkt_a1() {
      int x = PI;
      ...
  }

Alternativ: In beiden Sprachen Konstanten vorwärts deklarieren

Folgende Definition und (Vorwärts-) Deklaration der Konstanten PI funktioniert sowohl in C als auch in C++:

/* ======== Datei main.c ======== */
extern const int PI;    // (Vorwärts-) Deklaration mit "extern"
const int PI=123;       // Definition OHNE "extern"

int main() {
    fkt_a1();
    int x = PI;
    ...
}

/* ======== Datei a.c ======== */
extern const int PI;    // (erneute) Deklaration mit "extern"
void fkt_a1() {
    int x = PI;
    ...
}

Automatisieren der Buildvorgänge: GNU Make

Makefile: Textdatei mit Regeln für das Programm make

• Abläufe automatisieren: Kompilieren, testen, Pakete bauen, aufräumen, ...
• Java: ant, C/C++: make
• Achtung: Verschiedene Make-Dialekte! Wir nutzen GNU Make!

 # Kommentar
 Ziel1: AbhaengigkeitenListe1
     Aktionen1

 Ziel2: AbhaengigkeitenListe2
     Aktionen2

 # ... und so weiter :-)
 # ACHTUNG:
 # Vor den Aktionen <TAB> benutzen, keine Leerzeichen!!!
 # Vorsicht mit Editor-Einstellungen!

Bedeutung: Um das Ziel Ziel1 zu erzeugen, müssen alle Abhängigkeiten der Liste AbhaengigkeitenListe1 erfüllt sein. Dann werden die Aktionen in Aktionen1 durchgeführt, um Ziel1 zu erzeugen. Aber nur, falls das Ziel Ziel1 nicht existiert oder veraltet ist!

Falls die Abhängigkeiten nicht erfüllt sind, wird nach Regeln gesucht, um diese zu erzeugen. Das bedeutet, dass u.U. zunächst weitere Targets "gebaut" werden, bevor die Aktionenliste ausgeführt wird.

Die Ziele und Abhängigkeiten sind i.d.R. Dateien (müssen es aber nicht sein).

Makefiles: Fiktives Beispiel

• Annahme: Projekt besteht aus der Datei main.cpp, daraus soll das Programm "tollesProgramm" erzeugt werden

• Passendes Makefile:

  CXXFLAGS = -Wall
  
  .PHONY: all
  all: tollesProgramm
  
  tollesProgramm: main.o
      $(CXX) $(LDFLAGS) $< $(LDLIBS) -o $@
  
  %.o: %.cpp
      $(CXX) $(CXXFLAGS) -c $< -o $@
  
  .PHONY: clean
  clean:
      rm -rf tollesProgramm *.o *.~
  

Bedeutung: Um das Ziel all zu erzeugen, muss die Abhängigkeit tollesProgramm erfüllt sein. Beachten Sie, dass im Beispiel all kein Dateiname ist, tollesProgramm dagegen schon.

Um tollesProgramm zu erzeugen, muss die Datei main.o vorhanden sein. Falls sie es nicht ist, wird sie mit Hilfe des dritten Targets erzeugt. Das % ist dabei ein Patternmatcher, d.h. wenn nach einem main.o gesucht ist, matcht %.o (das % bindet sich dabei an "main") und auf der rechten Seite des Targets steht als Abhängigkeit main.cpp.

Die Variablen CXX, CXXFLAGS, LDFLAGS und LDLIBS sind vordefinierte Variablen:

• CXX: C++-Compiler, Default: g++
• CXXFLAGS Extra Flags für den C++-Compiler (nur für Kompilieren)
• LDFLAGS: Extra Flags, die für das Linken genutzt werden (Beispiel: -L.; nicht -lm)
• LDLIBS: Bibliotheken, die für das Linken genutzt werden (Beispiel: -lm -lfoo; nicht -L.)

Die Variablen $<, $^ und $@ lösen auf das Ziel bzw. die Abhängigkeiten eines Targets auf:

• $< => gibt die erste Abhängigkeit an
• $^ => gibt alle Abhängigkeiten an
• $@ => gibt das Ziel an

Falls die Datei tollesProgramm nicht existiert oder aber älter ist als main.o, wird die Regel des Targets tollesProgramm ausgeführt, um die Datei tollesProgramm zu erzeugen: g++ main.o -o tollesProgramm.

Hinweis: Das Beispiel entspricht den minimalen Kenntnissen, die Sie über Make haben müssen.

Makefiles: Typische Aufrufe

• make Sucht nach Datei mit dem Namen "GNUmakefile", "makefile" oder "Makefile" und erzeugt das erste Ziel in der Datei

  Konvention: Das erste Ziel hat den Namen all

• make -f <datei> Sucht die Datei mit dem angegebenen Namen, erzeugt das erste Ziel in der Datei

• make -f <datei> <ziel> Sucht die Datei mit dem angegebenen Namen, erzeugt das Ziel <ziel>

• make <ziel> Sucht nach Datei mit dem Namen "GNUmakefile", "makefile" oder "Makefile" und erzeugt das Ziel <ziel>