Programmiersprache(n) für technische Anwendungen

Aufbau eines C-Programms
 Ein C-Programm besteht aus Funktionen
 Jedes C-Programm muss eine Funktion haben die main() heißt
• int main( )
• int main( int argc[ , char *argv[ ] [, char *envp[ ] ] ] )
 Fast jedes C-Programm nutzt zusätzliche Funktionen aus Bibliotheken
oder selbstdefinierte Funktionen
• um diese zu verwenden müssen sie bekannt sein
• Prototypen zeigen uns wie die Funktionen aussehen
• Prototypen sind in „include-Dateien“ abgelegt.
// Ihr erstes Programm
#include <stdio.h>
int main ()
{
printf ("Hello World");
}
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
C ist case sensitive
d.h. es wird zwischen GROSSund klein- Schreibung unterschieden
main ≠ Main
printf ≠ PRINTF
1
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Aufbau einer Funktion
 Jede Funktion besteht aus:
• Funktionskopf
• Funktionsblock
int main(void)
{
int zahl = 0;
int quadrat;
Funktionskopf
Beginn Funktionsblock
Deklarationen
printf(“Bitte Zahl eingeben “);
scanf ( “%d“, &zahl);
Anweisungen
quadrat=zahl * zahl;
printf(“Quadrat ist: %4d\n“,quadrat);
return 0;
}
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
2
Ende Funktionsblock
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Regeln
 C ist formatfrei
• Anweisungen können über mehrere Zeilen geschrieben werden
 C besteht im wesentlichen aus Funktionsaufrufen
• außer mathematischen und logischen Verknüpfungen und einigen
Kontrollstrukturen
• Funktionen sind in Bibliotheken abgelegt
• das Format einer Funktion wird durch Prototypen beschrieben
• Prototypen sind in sogenannten Header-Dateien (name.h) deklariert.
• Um Funktionen aus Bibliotheken zu nutzen, muss die Header-Datei in
den Code „hineingeholt“ werden (durch #include)
– #include <stdio.h>
oder
#include "my_fkt.h"
 Die main() Funktion muss genau einmal in einem C Programm
vorkommen.
 Jeder Funktionscode ist in { } eingeschlossen
 Jede Anweisung wird mit Semikolon abgeschlossen;
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
3
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Notationsregeln
 Bezeichner
• Bezeichner bestehen aus einer Folge von Buchstaben (Klein- und
Großbuchstaben) oder Ziffern oder Unterstrich.
• Es wird zwischen Groß- und Kleinschreibung unterschieden.
• Mindestens die ersten 31 Stellen sind signifikant.
• alle Schlüsselwörter sind reserviert
• ( keine Umlaute )
 Trennzeichen
• Definitionen und Anweisungen muss man durch das Zeichen
„Semikolon“ abschließen.
• Bezeichner und Schlüsselwörter muss man trennen durch
Leerzeichen, Tabulatoren, Zeilenendezeichen, Operatoren oder
Kommentare.
• Mehrere Leerzeichen, Tabulatoren und Zeilenendezeichen
hintereinander interpretiert der Compiler wie ein Leerzeichen.
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
4
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Kommentare
 Kommentare werden zum besseren Verständnis der schrittweisen
Codeausführung zum Code hinzugefügt.
 Kommentare sollten Informationen bereitstellen, die durch das blosse Lesen des
Codes nicht deutlich werden.
 Kommentare, die nur das Offensichtliche wiederholen,
•
•
fügen nichts Brauchbares zum Code hinzu.
schaffen zusätzliches Codeverwaltungsproblem,
– denn bei jeder Änderung des Codes
– müssen auch die entsprechenden Kommentare überarbeitet werden.
// das ist ein Kommentar bis zum Zeilenende
y = x1 + x2;
// Kommentar nach Anweisung bis Zeilenende
/* das ist ein Kommentar
über mehrere Zeilen
dies ist somit kein Code y = x1 + x2; */
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
5
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Schlüsselwörter
auto
const
enum
if
short
switch
while
break
default
extern
int
signed
typedef
volatile
case
do
float
long
sizeof
union
char
double
for
register
static
unsigned
continue
else
goto
return
struct
void
 Datentypen
short
long
16 bit
32 bit
• char
Zeichen
• int
Ganzzahl
• float, double Gleitkommazahl
32 bit
signed
unsigned
vorzeichenbehaftet
vorzeichenlos
64 bit
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
6
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Definition einer Variablen
 Werte (Ergebnisse, Zwischenergebnisse usw.) werden während
des Programmablaufs in Variablen gespeichert.
 Eine Variable ist ein Speicherbereich, den Ihnen der Compiler zur
Verfügung stellt.
 Jede Variable hat einen Namen und einen Wert.
 Der Name wird vom Compiler mit einer bestimmten Adresse im
Speicher identifiziert, unter der der Wert abgelegt wird.
 Eine Variable muss vor ihrer Benutzung definiert werden.
 Bei der Definition müssen Sie einen Datentyp angeben.
 Der Datentyp bestimmt die Größe des zur Verfügung gestellten
Speicherbereiches.
Anmerkung:
Wieviel Speicherplatz die einzelnen Datentypen belegen, ist implementationsabhängig. Mit Hilfe
des Operators „sizeof“ können Sie den jeweiligen Speicherbedarf ermitteln. Die Wertebereiche für
die einzelnen Datentypen sind ebenfalls implementationsabhängig und können den Dateien
„limits.h“ und “float.h“ entnommen werden.
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
7
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Elementare Datentypen
int ist
implementationsabhängig
2 Byte oder
4 Byte
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
8
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Darstellung von Konstanten
 Zeichenkonstanten:
‘a‘
‘Z‘
Zeichen eingeschlossen in ‘...‘
Der Wert ist der numerische Wert des Zeichens im verwendeten
Zeichensatzes.
‘\n‘
‘+‘
‘\0‘
 ganzzahlige Konstanten:
'0' ist 1 Byte
364
23u
3271L
010
0xAB
Ganzzahlige Konstanten bestehen aus einer Ziffemfolge und
werden üblicherweise dezimal angegeben.
Um “unsigned“- oder “long“-Konstanten anzugeben, müssen
Sie die Suffixe “u“ oder “U“, bzw. “I“ oder “L“ anhängen.
Oktale Konstanten beginnen mit einer führenden Null, hexadezimale Konstanten mit „0x“ oder „0X“. Für die Darstellung
der hexadezimalen Ziffern größer 9 werden die Groß- oder
Kleinbuchstaben A-F, bzw. a-f verwendet.
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
9
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Darstellung von Konstanten
 Gleitkommakonstanten:
2.3
.4F
238e10
2.156E-8
0.471
Gleitkommakonstanten haben mindestens einen Dezimalpunkt oder einen Exponenten (durch „e“ oder „E“ gekennzeichnet).
In der Regel ist eine Gleitkommakonstante vom Datentyp
„double“, es sei denn sie wird durch einen Suffix „f“ oder
„F“ als „float“ bzw. durch „I“ oder „L“ als „long doubie“
gekennzeichnet.
 Zeichenkettenkonstanten:
'0' ist 1 byte
"0" ist 2 byte
“Hallo!“
Folge von Zeichen eingeschlossen in “ .... “
Zeichenkettenkonstanten werden als Folge von Einzelzeichen,
abgeschlossen durch ein NULL-Zeichen, im Speicher
abgelegt.
Alle Darstellungen von Zeichenkonstanten können auch in
Zeichenketten benutzt werden.
Zeichenketten werden
stets mit '\0' beendet!
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
10
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Schlüsselwort „const“
Durch Voranstellen des Schlüsselwortes “const“ kann bei der
Definition einer Variablen angegeben werden, dass sich ihr Wert
nicht ändert.
Solche Variablen müssen Sie bei der Definition initialisieren.
Beispiel:
int main (void)
{
const double pi = 3.14159;
......
pi = 3.14; /* fuehrt zu Fehlermeldung des Compilers */
......
return 0;
}
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
11
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Variablenzuweisung
 Variablen werden auch L-Werte genannt, weil sie auf der linken
Seite einer Zuweisung stehen können.
 Konstanten sind R-Werte. Bei einer Zuweisung können sie nur auf
der rechten Seite vorkommen.
 Nicht initialisierte Variablen enthalten zufällige Werte.
 Im Definitionsteil eines C-Programms können Sie lnitialisierungen
wie folgt vornehmen:
<Datentyp> <Variablenname> = <Anfangswert>;
 Im Definitionsteil eines C-Programms können Sie Zuweisungen
wie folgt vornehmen:
<Variablenname> = <Wert>;
<Variablenname1> = <Variablenname2>;
 Sprachgebrauch:
• in eine Variable schreiben
• aus einer Variablen lesen
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
12
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Unterschied Variable und Konstante
printf("%i",10);
 Konstante sind Werte
• die direkt im Quelltext angegeben werden
 Variablen sind Speicherstellen
int i = 10;
i = i + 4;
• die einen Wert speichern können
• dieser Wert (der Wert der Variable)
kann mehrmals gelesen werden
• die Variable kann mit neuen Werten beschrieben werden
x = 2 * i;
 Variable haben
• einen Wert
• und eine Adresse
 Konstante haben
• nur einen Wert .
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
13
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Eingabe, Ausgabe
 Ein- und Ausgabe einzelner Zeichen
• int putchar (int)
– schreiben Zeichen auf Standard-Ausgabe (Bildschirm)
• int getchar (void)
– holen des nächsten Zeichens von der Standard-Eingabe (Tastatur)
 Ein- und Ausgabe kompletter Zeichenketten
• printf und scanf
 sind mehr Zeichen / Zeichenketten in der Tastatur eingegeben
worden, als aktuell eingelesen werden sollen
• so bleiben diese im zugehörigen Puffer
– stdin
– stdout
die Standard-Eingabe, d.h. die Tastatur
die Standard-Ausgabe, d.h. der Bildschirm
• Puffer können mit fflush geleert werden.
– z.B.
fflush (stdin);
int fflush (FILE * stream);
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
14
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Ein- und Ausgabefunktionen
 getchar( ) und putchar( )
•
getchar( )
oder den
•
putchar ( )
Einlesen eines Zeichens von der Standardeingabe. Die Funktion liefert als
Resultat eine ganze Zahl, die den Tabellenwert für ein Zeichen darstellt,
Wert EOF bei Dateiende.
Die symbolische Konstante EOF hat typischerweise den Wert - 1 und ist definiert
in der „stdio.h“.
Ausgabe eines Zeichens auf die Standardausgabe (Terminal)
 Beispiel:
#include <stdio.h>
int main (void)
{
int zeichen;
printf(“Zeichen eintippen > “);
zeichen = getchar();
putchar(zeichen);
printf(“ hat den Code: dez. %d okt. %o hex. %x\n“,
zeichen, zeichen, zeichen);
return 0;
}
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
15
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Ein- und Ausgabefunktionen
 scanf( ) und printf( )
• scanf( )
• printf( )
dient zur formatierten Eingabe von Zeichenketten
dient zur formatierten Ausgabe von Zeichenketten
 Syntax:
• Befehlswort ( „Steuerstring“, Argumente);
 Beispiel:
• printf (“%6.2f „%6.2f \n“, 20.0 / 7.0, 4.73);
 Datentransfer:
• Bei beiden Funktionen wird der Datentransfer durch den
Steuerstring mit Formatelementen gesteuert.
• Die Argumente werden in Zeichenketten umgewandelt und ersetzen
die zugehörigen Formatelemente im Steuerstring.
• Dann wird der so aufbereitete Steuerstring ausgegeben .
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
16
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
printf - Formatangaben
 printf = print formatted
• printf ("Steuerstring", [argument_1, .., argument_n]);
\t
\n
%i
%s
 der Steuerstring kann mit Escape Sequenzen
als auch mit Formatelementen formatiert werden
Argument
 printf ("Der Wert von 2 * 3 ist %i\n", 6);
• Es findet nacheinander eine Ersetzung der Steuerzeichenketten
durch die Argumente statt.
 printf ("Der Wert von %i * 3 ist %i\n", 2, 6);
 Sind mehr Steueranweisungen als Argumente vorhanden, so
erzeugt dies einen Fehler (nur Warnung beim Compiler!)
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
17
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Formatierung
 Häufige Escape Sequenzen
• \t
Tabulator
• \n
new line
• \\ \? \' \"
(neue Zeile)
Sonderzeichen
\ ? ' "
 Häufig benutzte Formatelemente
•
•
•
•
%c
%i
%f
%e
Zeichen
Ganzzahl
Gleitkommazahl
Gleitkommazahl
 Zusätzliche Formatierung
•
•
•
•
+
6
.2
x.xxxxxx
x.xxxxxe+yyy
d, u, o, x, X
g
E
zwischen % und Buchstabe
linksbündig
mit Vorzeichen
minimale Feldweite (hier 6)
bei Festkomma: Anzahl zu schreibender Zeichen (hier 2)
bei Gleitkomma: Anzahl der Nachkommastellen
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
18
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Ausgabe mit printf()
 Prototyp in stdio.h
 Escape-Sequenzen in Zeichenketten
Escape-Sequenz
'\a'
'\b'
'\f'
'\n'
'\r'
'\t'
'\v'
'\\'
'\' '
'\" '
'\? '
'\ooo'
'\xhh'
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
Ausführung
akustisches Signal, bell
Rückschritt, backspace
Seitenvorschub, formfeed
Zeilenendezeichen, newline
Zeilenrücklauf, carriage return
horizontaler Tabulator, tab
vertikaler Tabulator
\
'
"
?
Zeichen in Oktaldarstellung
Zeichen in Sedezimaldarstellung
19
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
printf() – Formatelemente: Zahlen
printf ("%i + %i = %i\n", 5, 5, 10);
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
20
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
printf() – Formatelemente: Zeichen + Zeiger
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
21
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
printf() - Formatangaben - Feldangaben
 Zwischen % und Formatbuchstaben eines Formatelements
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
22
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
scanf()
Mit „scanf()“ werden Werte eingelesen, in eine oder mehrere Variablen.
Wir werden diese Funktion nur mit einem Formatelement benutzen.
Das zugehörige Argument muss die Adresse einer Variablen sein und wird
geschrieben: &<Variablenname>.
„scanf()“ liest nur, solange für das Format gültige Zeichen vorliegen oder
bis zum nächsten Leerzeichen, Tabulator oder Zeilenendezeichen oder bis
zum Dateiende.
Zwischen “%“ und Formatbuchstabe eines Formatelements können Sie
die maximale Anzahl der Zeichen festlegen, die eingelesen werden sollen.
Die Funktion „scanf()“ liefert als Rückgabe-Wert:
1 wenn Zeichen dem Format entsprechend gelesen wurden
0 wenn keine Zeichen dem Format entsprachen
EOF
wenn das Dateiende erreicht wurde
Mit dem Rückgabe-Wert kann ein erfolgreiches Lesen überprüft werden.
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
23
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Keine Ausgaben
mit scanf()!
scanf()
 Mit scanf() können Werte eingelesen werden
• Prototyp definiert in stdio.h
• int scanf (%Steuerstring, Argumente, ..);
 Ähnliche Formatanweisung wie bei printf()
•
•
•
•
%c
%s
%i
%f
Zeichen
String
Ganzzahl
Gleitkommazahl
d, u, o, x, X
 Modifizierer
• %l
• %h
long
short
%lf
%Lf
 Rückgabewert der Funktion
• Anzahl der erfolgreich eingelesenen Werte
– bei Fehler in Konvertierung erfolgt Abbruch
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
24
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Argumente müssen Adressen sein!
scanf() - Argument
 Neben dem Steuerstring müssen bei scanf Argumente übergeben
werden.
• Diese Argumente geben die Speicherstellen an,
wo die Funktion scanf die eingelesenen Werte ablegen soll.
• Die Speicherstelle einer Variablen,
d.h. den Ort (l-value) an dem der Wert gespeichert ist
erhält man über den Adressoperator &
• Der Datentyp der Variable und die Formatanweisung müssen
zueinander passen!
float f;
int i, k;
printf("Eingabe erstes Argument:\t");
i = scanf("%f",&f);
printf ("Eingabe zweites Argument:\t");
i += scanf("%i",&k);
printf("Anzahl der erfolgreich eingelesenen Argument ist: %i\n", i);
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
25
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Und noch ein scanf() – printf() Beispiel
#include <stdio.h>
int main (void)
{
char ch; int i; float x; double y;
scanf(“%c“, &ch);
scanf(‘%d“, &i);
scanf(“%f“, &x); scanf(“%lf“, &y);
printf (“Variable ch: %c \n“,ch);
printf (“Variable i (dezimal): %d \n“,i);
printf (“Variable i (oktal): %o \n“,i);
printf (“Variable i (hex): %x \n“,i);
printf (“Variable x: %f Variable y: %lf \n“, x, y);
printf (“ : %s : \n“, “hallo“);
printf (“ : %10s: \n“, “hallo“);
printf (“ : %-10s: \n“, “hallo“);
printf(“ :%6.2f: \n“, x);
return 0;
}
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
26
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Wir rechnen
i = 10;
 In Ausdrücken werden Variable und Konstante mit Operatoren
verknüpft
 Die Wert eines Ausdrucks wird einer Variablen zugewiesen
 Datentypen bestimmen Speicherplatz und die nötige Konversion
 Mögliche Arithmetische Operatoren in C
Achtung bei
Integer-Division
gibt es einen Rest!
*
/
+
%
~
<<
>>
sei x1 = 10 und x2 = 3
Multiplikation
y = x1 * x2;
Division
y = x1 / x2;
Addition
y = x1 + x2;
Subtraktion
y = x1 - x2;
Divisionsrest
y = x1 % x2;
Einer-Komplement
y = ~x1;
bitweise Negation
shift nach links
y = x1 << 1;
shift nach rechts
y = x1 >> 1;
Punktrechnung vor Strichrechnung!
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
27
dann ist y
30
3
13
7
1
-11
20
5
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Ein Rechenbeispiel
#include <stdio.h>
int main (void)
{
float a, b, c;
int i, j, k;
a = 5.0; b 7.0;
i = 8; j = 5;
c = a - 5. + b;
printf(“c = %6.2f \n“, c);
c = a + b * b * b;
printf(“c = %6.2f \n“, c);
c = a / ( b + 4. );
printf(“c = %6.2f \n“, c);
k = i / j;
printf(“k = %d \n“, k);
k = i % j;
printf(“k = %d \n“, k);
return 0;
}
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
28
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Vergleiche und Logische Verknüpfungen
C kennt folgende Vergleichsoperatoren:
< kleiner
<= kleiner gleich
> grösser >= grösser gleich
== gleich
!= ungleich
C kennt folgende logische Operatoren:
!
logische Negation
&& logisches Und
|| logisches Oder
Der Wert eines
Vergleichs- oder logischen Ausdrucks ist:
1, wenn der Ausdruck wahr ist
0, wenn der Ausdruck falsch ist
#include <stdio .h>
int main (void)
{
int i = 0, j = 0;
/* Werte einlesen */
printf (“Bitte i eingeben: “);
scanf (“%d“, &i);
printf(“Bitte j eingeben: “);
scanf(“%d“, &j);
/* Eingabe ueberpruefen */
if ( i>j && i > 0 && j > 0)
printf(“i > j und beide Zahlen sind positiv\n“);
return 0;
}
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
29
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Zuweisungsoperatoren
C kennt folgende Zuweisungsoperatoren:
=
+=
-=
*=
/=
%=
#include <stdio .h>
Zuweisung
a += b entspricht a = a + b
a -= b entspricht a = a - b
a *= b entspricht a = a * b
a /= b entspricht a = a / b
a %= b entspricht a = a % b
int main (void)
{
int i‚ j, k;
i = j = k = 5;
printf(“i = %d, j = %d, k = %d\n“,i,j,k);
Der Wert einer Zuweisung ist der zugewiesene
Wert und kann weiter verwendet werden z. B.
für Zuweisungen oder Vergleiche.
i += 2;
printf(“i = %d\n“,i);
i *= j + 2;
printf(“i = %d\n“,i);
return 0;
}
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
30
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Inkrement- und Dekrementoperatoren
Inkrement- und Dekrementoperator
++ Inkrementoperator (Inhalt einer Variablen um 1 erhöhen)
-- Dekrementoperator (Inhalt einer Variablen um 1 vermindern)
Inkrement- und Dekrementoperator können vor oder hinter dem Operanden
stehen. Der Operand muss ein L-Wert sein und darf nicht mehr als einmal in
einem Ausdruck vorkommen.
Steht der Operator vor dem Operanden (z.B. ++i) ‚ geschieht folgendes:
1. Variable i inkrementieren
2. Den Wert des Ausdrucks mit dem neuen Wert von i berechnen
Steht der Operator hinter dem Operanden (z.B. i++), geschieht folgendes:
1. Wert von i merken
2. Den Wert des Ausdrucks mit dem alten Wert von i berechnen
3. Variable i inkrementieren
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
31
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Ein Inkrementbeispiel
#include <stdio.h>
int main (void)
{
int i, j;
i = 5;
printf (“i = %d\n“, i);
Und das kommt raus:
i=5
j = ++i + 1;
printf(“i = %d, j = %d\n“, i‚ j);
 i = 6, j = 7
j = 4 + i++;
printf(“i = %d, j = %d\n“, i‚ j);
return 0;
 i = 7, j = 10
}
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
32
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Weitere Operatoren
 Anstelle der reinen arithmetischen Verknüpfungen (+, *)
 und der reinen logischen Verknüpfung (&&, ||)
 gibt es noch Bit-Operatoren
•
&
|
^
~
<<
>>
für die Manipulation von einzelnen bits innerhalb von Zahlen
bitweise UND-Verknüpfung
bitweise ODER-Verknüpfung
bitweise Exclusiv-Oder Verknüpfung
bitweise Negation
bits der Zahl um Anzahl (rechter Parameter) nach links schieben
bits der Zahl um Anzahl (rechter Parameter) nach rechts schieben
 ebenso die Verknüpfung von Operatoren
&= |= ^= <<= >>=
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
33
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Logische Verknüpfungen
 Verknüpfungsergebnis durch Wahrheitstabelle
x1
0
0
1
1
x2
0
1
0
1
y
0
0
0
1
x1
0
0
1
1
x2
0
1
0
1
y
0
1
1
1
x1
0
0
1
1
x2
0
1
0
1
y
0
1
1
0
UND-Verknüpfung
y = x1 & x2;
ODER-Verknüpfung
y = x1 | x2;
XOR-Verknüpfung
y = x1 ^ x2;
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
34
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Hierarchiestufen der Operatoren
 Wie auch in Mathe gilt
 allerdings gibt es hier noch
mehr Operatoren, so daß man
auf die Reihenfolge achten
muss
 Innerhalb dergleichen Stufe
werden fast alle Operatoren in
der Reihenfolge verarbeitet, wie
sie im Ausdruck erscheinen,
von links nach rechts
Ausnahmen:
Zuweisungsoperatoren,
bedingte Ausdruck
 im Zweifelsfall setzt man lieber
Klammern
Priorität fällt
• Punktrechnung vor
Strichrechnung
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
Operator
-> .
[] ()
++ -++ -+ - ~ !
* & ()
* / %
+ << >>
< <= > >=
== !=
& ^ |
&& ||
?:
= +=, etc.
,
35
Gruppe
Memberauswahl
Klammern
postfix
prefix
Vorzeichen, Inversion
dereference, adress, cast
Punktrechnung
Strichrechnung
Shift
Relation
Gleichheit
bitweise Operation
logische Operation
Bedingungsoperator
Zuweisung
Komma
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Umwandlung von arithmetischen Datentypen
Verknüpft ein Operator Ausdrücke arithmetischen Datentyps, so führt der
Compiler automatisch eine Datentypumwandlung durch, wenn die
Operanden verschiedene Datentypen aufweisen. Dabei wird der
„einfachere“ Datentyp in den „komplexeren“ umgewandelt.
Hier ein paar nützliche Umwandlungsregeln:
1. Werte vom Typ char oder short werden stets in int umgewandelt.
2. Gleitkomma-Konstanten haben den Datentyp double, wenn sie nicht durch
ein Suffix anders gekennzeichnet sind (z.B. 5.0f für float).
3. Hat ein Operand den Datentyp float, double oder long double, so wird der
andere Operand, falls er ganzzahlig ist, in den gleichen Gleitkommatyp umgewandelt.
4. Bei einer Zuweisung wird der Wert auf der rechten Seite in den Datentyp
der Variablen auf der linken Seite umgewandelt.
Dabei kann es zu Datenverlust oder zu undefinierten Ergebnissen kommen.
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
36
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Umwandlungsbeispiele von arithmetischen Datentypen
Beispiel 3
float a = 1.0, b = 7.0;
int erg;
erg = a / b;
Ergebnis: 0.142857
Regel 4: Die Dezimalstellen gehen verloren
Also „erg“ hat den Wert 0
Beispiel 1
int a = 5, b = 7;
float erg;
erg = a / b;
Regel 3 kann nicht angewandt werden
Also Ergebnis 0
Die Variable „erg“ hat den Wert 0
Beispiel 2
int a = 5;
float erg, b = 7.0;
erg = a / b;
Regel 3:
Der Wert von a wird in float umgewandelt.
Das Ergebnis ist: 0.714285
Die Variable „erg“ bekommt die Dezimalstellen
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
37
Beispiel 4
double a = 2147483647.0, b = 2.0;
int erg;
erg = a * b;
Ergebnis: 4294967294.0
Regel 4: Vorausgesetzt eine int- Darstellung
von 31 bits, dann ist die größte positive Zahl
2147483647(= 231-1)
Der Wert von „erg“ ist undefiniert.
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer
Umwandlung mit Hilfe des cast-Operators
Mit Hilfe des Umwandlungsoperators (cast-Operators) können Sie eine
Datentypumwandlung erzwingen:
Syntax:
(Datentyp) Ausdruck
Ein Ausdruck mit Umwandlungsoperator ist kein L-Wert.
Beispiel 1:
double erg;
erg = 5.0 / 7;
Bei Konstanten genügt es, wenn bei einem Operanden die Gleitkommadarstellung
genommen wird. So kann Umwandlungsregel 3 angewandt werden.
(erg = (double) 5 / 7 ist auch möglich)
Beispiel 2:
int a = 5 ‚ b = 7;
double erg;
erg = (double) a / b;
Bei Variablen ist der Umwandlungsoperator die einzige Möglichkeit, wenn die
Variablendefinition nicht verändert werden soll.
Fachhochschule Frankfurt am Main
University of Applied Sciences FB2
38
Programmiersprache(n) für technische Anwendungen
Dipl.math Gerd H. Neugebauer