REFERAT-MenüDeutschGeographieGeschichteChemieBiographienElektronik
 EnglischEpochenFranzösischBiologieInformatikItalienisch
 KunstLateinLiteraturMathematikMusikPhilosophie
 PhysikPolitikPsychologieRechtSonstigeSpanisch
 SportTechnikWirtschaftWirtschaftskunde  



Nichtobjektorientierte Erweiterungen von C++

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.:
    {           // Blockbeginn
       int i;
       i = 15;  // 1. Anweisung, "Anweisungsteil" beginnt
       ...
       int j;   // wäre in C ein Syntax-Fehler!
       ...
    }           // 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 {
       char Name [30];
       int Alter;
       ...
    };
    ...
    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:

C++
#include
...
long x;
cout << "Wert für x? ";
cin >> x;
cout << "x*x = " << x*x << endl;
...
C
#include
...
long x;
printf ("Wert für x? ");
scanf ("%ld", &x);
printf ("x*x = &ld\n", x*x);
...

  • 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:

C++
void ausgabe (int wert)
{
   cout << "Wert: " << wert << endl;
}

void ausgabe (double wert)
{
   cout << "Wert: " << wert << endl;
}

void main ()
{
  &nbsx;ausgabe (2017);
   ausgabe (3.141592);
}
C
void ausgabeInt (int wert)
{
   printf ("Wert: %d\n", wert);
}

void ausgabeDbl (double wert)
{
   printf ("Wert: %f\n", wert);
}

void main ()
{
   ausgabeInt (2017);
   ausgabeDbl (3.141592);
}

  • 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)
    {
       cout << "p1 = " << p1 << ", p2 = " << p2 << ", p3 = " << p3 << endl;
    {

    void main ()
    {
       fu (1, 2, 3);     // p1 = 1, p2 = 2, p3 = 3
       fu (1, 2);        // p1 = 1, p2 = 2, p3 = 30
       fu (1);           // p1 = 1, p2 = 20, p3 = 30
       // fu ();         führt zu Compiler-Fehlermeldung
       // fu (1, , 3);   führt zu Compiler-Fehlermeldung
    }

  • 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 ()
    {
       fu (10, 20); // führt zu Compiler-Fehlermeldung
    }

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 Ändern 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:

C++
void tausche (int& a, int& b)
{
   int h;
   h = a; a = b; b = h;
   ...
}

void main ()
{
   int v1 = 10, v2 = 20;
   tausche (v1, v2);
   ...
}
C
void tausche (int *a, int *b)
{
   int h;
   h = *a; *a = *b; *b = h;
   ...
}

void main ()
{
   int v1 = 10, v2 = 20;
   tausche (&v1, &v2);
   ...
}

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






Haupt | Fügen Sie Referat | Kontakt | Impressum | Nutzungsbedingungen