Nichtobjektorientierte Erweiterungen von C++

1. Diverse 'Kleinigkeiten'

1.1 Kommentare

2 Möglichkeiten:

• wie in C ('/* */'): besser geeignet für mehrzeilige Kommentare
• mittels '// ': geht bis ans Zeilenende, für kurze Kommentare

1.2 Variablen-Vereinbarungen

• Variablen-Definitionen sind auch mitten im 'Anweisungs-Teil' eines Blockes erlaubt.
  Bsp.:
            // Blockende
• 'sparsam' verwenden!
• Häufiger Anwendungsfall:
  for (int i = 0; i < max; ++i)
  Vorsicht: i gehört dem umschließenden Block!
• Hinweis: auch in C gilt: Variablen-Vereinbarungen in jedem Block möglich, allerdings nur am Anfang.

1.3 Struktur-Vereinbarungen

• 'Struktur-Namen' sind in C++ 'richtige' Typen.
  Bsp.:
  struct PERSON ;
  
  PERSON mitarbeiter;   // C-Version: struct PERSON mitarbeiter;

1.4 Prototypen

• zwingend:
• wenn Funktion aufgerufen wird, bevor sie definiert wurde
• beim Aufruf von 'externen' Funktionen (z.B. strcmp, --> string.h inkludieren!)
• Hinweis: die Parameter-Namen beim Prototyp sind nur 'Kommentar', können weggelassen werden

2. Standard-Ein/Ausgabe mittel cin/cout

• eigentlich schon 'objekt-orientiert', für einfache Aufgaben jedoch auch 'rezeptmäßig' einsetzbar
• Beispiel:

• Operator '<<' ersetzt printf, Operator '>>' ersetzt scanf
• cin / cout entsprechen stdin / stdout [printf () entspricht ja fprintf (stdout, )]
• 'endl' = 'Manipulator'
• Vorteile:
• Typen werden automatisch richtig berücksichtigt, kein Formatstrings erforderlich
• kein &-Zeichen bei der Eingabe erforderlich
• Konzept auf eigene Typen erweiterbar (z.B. cin >> mitarbeiter;)
• Nachteile:
• formatierte Ausgaben relativ aufwendig, iostream-Bibliothek wird kompliziert

3. Überladen von Funktionen

• mehrere Funktionen können den gleichen Namen haben
• sie müssen sich jedoch durch ihre Parameter unterscheiden (Anzahl und/oder Typ)
• Beispiel:

• Compiler unterscheidet selbständig beim Aufruf der Funktion aufgrund der aktuellen Parameter, welche Funktion aufgerufen wird.
• Vorsicht: Programmierer muss mehr nachdenken, welche Funktion wirklich aufgerufen wird!
• Funktionen sollten (unbedingt!) logisch das gleiche tun.
• Hinweis: '<<' und '>>' sind überladene Funktionen, die mehrfach (für alle Standard-Typen) vorliegen!

4. Default-Parameter

• treten in Kraft, wenn beim Aufruf der Funktion Parameter weggelassen werden
• Beispiel:
  void fu (int p1, int p2 = 20, int p3 = 30)
  
• Parameter können von rechts nach links weggelassen werden.
• Wenn ein Prototyp angegeben wird, dann die Defaultwerte nur beim Prototyp angeben.
• Vorsicht: Gefahr von Mehrdeutigkeiten vor allem im Zusammenhang mit Funktions-Überladungen.
  Bsp.:
  void fu (int p1, int p2 = 20, int p3 = 30)
  void fu (int i, int j)
  void main ()
  

5. Referenzen

• mehrere Namen für eine Variable
• Bsp.:
  int i;
  int& ri = i;
  i = 5;
  cout << 'i=' << i << ', ri=' << ri << endl; // i = 5, ri = 5
  ri = 10;
  cout << 'i=' << i << ', ri=' << ri << endl; // i = 10, ri = 10
• Referenz muss sofort bei der Definition initialisiert werden (mit dem Namen einer anderen Variablen)
• danach wird bei jeder Verwendung der Referenz-Variable immer auf den Variablen-Inhalt zugegriffen
• sehr ähnlich Zeigern, Unterschied:
• Verweis auf anderes Objekt wird sofort beim Anlegen (nur einmal!) festgelegt, danach ist ein Andern des Verweises nicht mehr möglich.
• außer bei der Definition wird durch den Namen der Referenz-Variablen immer der Inhalt angesprochen, nicht die Adresse -> es wird immer automatisch dereferenziert.
• Wichtigste Anwendung: 'Var'-Parameter (= 'Referenz'-Parameter)
  Beispiel:

• Referenzen können auch als Funktionsergebnis auftretenn
  z.B.: suche ('Karl') = 25;
  Vorsicht: keine Referenzen auf lokale Variable zurückliefern!