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!
| Anmerkungen: |
| impressum | datenschutz
© Copyright Artikelpedia.com
