Grundlagen der Programmiersprache C für Studierende der Naturwissenschaften Teil 2: Numerische Datentypen und Verwendung von Variablen Patrick Schreier Abteilung für Angewandte Mathematik Vorlesung vom 22. April 2013
Gliederung
Berechnung der Quadratwurzel Quelltext (Quadratwurzel) 1 #include <math.h> 2 #include <stdio.h> 3 4 int main(void) 5 { 6 /* declare floating point variable */ 7 double x; 8 9 /* read from user input */ 10 printf ("x = "); 11 scanf("%lf", &x); 12 13 /* print value of x and square root */ 14 printf ("x = %f\n", x); 15 printf ("sqrt(x) = %f\n", sqrt(x)); 16 17 return 0; 18 }
Variablen Variable = symbolischer Name für einen Speicherbereich. Variablen in Mathematik und Informatik sind verschieden: Mathematik: Sei x R fixiert x Informatik: int x definiert eine Variable vom Type int. x = 5 weist x den Wert 5 zu. Jede Variable muss vor Ihrer Verwendung vereinbart werden. Eine Vereinbarung besteht aus Angabe von Namen und Typ der Variablen. Namen: Namen identifizieren Variablen in eindeutiger Weise. Typen: Der Typ einer Variablen legt fest, welche Werte in der Variablen gespeichert werden können und welche Operationen auf Ihnen möglich sind.
Der Datentyp int Der Datentyp int ist vorgesehen, um ganze Zahlen (engl. integers) darzustellen:..., 2, 1, 0, 1, 2,... Integer-Datentypen haben einen endlichen Wertebereich, d. h. Variablen vom Typ int können nicht beliebig (betragsmäßig) große Werte annehmen. Neben dem Typ int gibt es eine Reihe weiterer Integer-Datentypen: char, short int, unsigned int, long int,... Sie unterscheiden sich hinsichtlich ihres darstellbaren Wertebereichs und ihres Speicheraufwands.
Der Datentyp double Gleitpunktzahlen oder auch Gleitkommazahlen (engl. floating point numbers) sind eine Teilmenge der rationalen Zahlen. Arithmetische Operationen auf Gleitkommazahlen sind nicht exakt, sondern mit einem kleinen Fehler behaftet. Gleitpunktzahlen werden in einem der folgenden Typen abgespeichert: float double long double Wir beschäftigen uns heute ausschließlich mit dem Typ double.
Bezeichner Konstruktion von Bezeichnern: Bezeichner dürfen aus Buchstaben, Ziffern und dem Unterstrich bestehen. Das erste Zeichen darf keine Ziffer sein. Reservierte Schlüsselwörter dürfen nicht verwendet werden. Bemerkungen: Zwischen Groß- und Kleinschreibung wird unterschieden, d. h. value und Value sind verschiedene Bezeichner. Bezeichner dürfen beliebig lang sein. Der Standard garantiert allerdings nur, dass mindestens 31 Zeichen signifikant sind (in der Praxis heute irrelevant).
Reservierte Schlüsselwörter auto break default do float for register return struct switch volatile while case char const continue double else enum extern goto if int long short signed sizeof static typedef union unsigned void Tabelle : Reservierte Schüsselwörter in ANSI C89 inline _Bool _Complex _Imaginary Tabelle : Reservierte Schüsselwörter in ISO C99
Beispiele für Bezeichner Betrachten wir einige Beispiele: x, i, n,... Okay Sehr kurze Variablennamen sind üblich in arithmetischen Ausdrücken oder in Schleifen. Aussagekräftige Namen helfen allerdings beim Programmieren und Debuggen. _a_very_long_long_identifier Okay Sehr lange Bezeichnern sind allerdings auch unpraktisch (mögliche Schreibfehler, Zeilenlänge). größe Falsch Der Umlaut ö und der Buchstabe ß sind keine erlaubten Zeichen. case Falsch Bei case handelt es sich um ein reserviertes Schlüsselwort.
Deklaration von Variablen Die Deklaration entspricht der Zuweisung von einem Speicherbereich auf einen symbolischen Namen. Die Grösse des Speicherbereichs entspricht dem Typ der Variable. Syntax: typename identifier; wobei typename den Namen eines Typs (bisher: int oder double) bezeichnet, identifier ein gültiger Bezeichner sein muss. Beispiele: int a; double x;
Gleichzeitige Deklaration mehrerer Variablen Mehrere Variablen desselben Typs können auch in nur einer Zeile definiert werden. Beispiele: int a, b; double x, y; Durch Deklaration einer Variablen wird lediglich (uninitialisierter) Speicherbereich zugewiesen. Ist noch kein konkreter Wert zugewiesen ist der Wert einer Variable zufällig.
Initialisierung von Variablen Nach Deklaration kann der Variable ein konstanter Wert zugewiesen werden: int n; (Deklaration) n = 0; (Initialisierung) Konstanten haben (wie Variablen auch) einen Typ. Dieser muss nicht explizit angegeben werden. Integer- und Floating-Point-Konstanten werden durch die Angabe eines Punkts voneinander unterschieden: 1 /* constant expression of type int */ 1.0 /* constant expression of type double */ 1. /* constant expression of type double */ Deklaration und Initialisierung können auch in einer Zeile erfolgen: int n = 1; double x = 1.;
Platzierung von Definition Jede Variable muss vor Ihrer ersten Verwendung definiert werden. Andernfalls bricht der Übersetzungsvorgang mit einem Fehler ab. Ältere C-Standards (bis C99) schreiben vor, dass sämtliche Variablendefinitionen am Anfang von main (eigentlich: ihres Gültigkeitsbereichs) stehen müssen: int main(void) { /* list of all definitions */... /* subsequent statements */... } Moderne Compiler erlauben die Vermischung von Definitionen und Anweisungen.
Formatierte Ausgabe mit printf Der Funktion printf kann eine beliebige Zahl von Variablen und konstanten Ausdrücken übergeben werden: int n = 1; double pi = 3.14159265359; printf("n = %d \n", n); printf("pi = %lf \n", pi); printf("n = %d, pi = %lf \n", n, pi); printf("n = %d, pi = %lf \n", 1, 3.1415); Neben wörtlich wiederzugebendem Text enthält der Format-String (von doppelten Anführungszeichen eingeschlossen) Formatelemente (engl. conversion specifications).
Formatierte Ausgabe mit printf Formatelemente sind Platzhalter für Variablen oder Konstanten verschiedene Typs: %d /* conversion specification for type int */ %lf /* conversion specification for type double */ Bei der Ausgabe von Gleitpunktzahlen kann man die Anzahl der Nachkommastellen festlegen. Der Code double pi = 3.14159265359; printf("%lf\n", pi); printf("%.3lf\n", pi); printf("%.12lf\n", pi); produziert die Ausgabe: 3.141593 3.142 3.141592653590
Formatierte Eingabe mit scanf Variableninhalte können zur Laufzeit des Programms von der Konsole eingelesen werden. Dazu verwenden wir die Funktion scanf: int a; double x; scanf( "%d", &a ); scanf( "%lf", &x ); scanf( "%d %lf", &a, &x ); Der Funktion können eine oder mehrere Variablen als Parameter übergegeben werden. Ihre Anzahl und Typen müssen den Formatelemente entsprechen: %d /* conversion specification for type int */ %lf /* conversion specification for type double */ Vor jedem Element der Parameterliste muss ein "&" stehen. Seine Bedeutung werden wir erst später klären.
Arithmetische Operationen Bedeutung eines Operators kann vom Datentyp abhängen. Operatoren auf Gleitpunktzahlen: (Typ double) x=y; (Zuweisung) x+y, x-y, x *y (Addition, Subtraktion, Multiplikation) x/y, (Division) Operatoren auf Ganzzahlen: (Typ int) n=m; (Zuweisung) n+m, n-m, n *m (Addition, Subtraktion, Multiplikation) n/m, n%m (Division ohne Rest, Divisionsrest) Die Konstanten oder Variablen, die ein Operator verknüpft werden als Operanden bezeichnet, bspw. hat x+y die Operanden x und y.
Ganzzahlige Division mit Rest Für Integer-Werte entspricht das Operatorpaar /,% der ganzzahligen Division mit Rest: int quotient = 1/2; /* quotient = 0 */ int remainder = 1%2; /* remainder = 1 */ Das Teilen durch die Null führt nicht etwa automatisch zu einem Laufzeitfehler, das Programm bricht nicht ab. Der Ausdruck hat den ausgezeichneten Wert inf: printf("%lf\n", 1./0.); /* Output: inf */ Der Wert nan (not a number) dient als Hinweis für dubiose Rechen-Operationen wie 0/0 oder inf/inf: printf("%lf\n", 0./0.); /* Output: -nan */
Implizite Typkonversion Operatoren können Variablen verschiedener Datentypen verbinden. int x = 1; double y = 2.5; double sumdouble = x + y; int sumint = x + y; printf("sumint = %d\n", sumint); /* Output: sumint = 3 */ printf("sumdouble = %lf\n", sumdouble); /* Output: sumdouble = 3.500000 */ x + y hat den Datentyp double, bei der Addition wird x in ein double konvertiert. sumint hat den Typ int, d.h. x+y wird in ein int konvertiert.
Implizite Typkonversion Haben die Operanden eines arithmetischen Operators den gleichen Typ, so ist auch das Ergebnis von diesem Datentypen. Sind die Operanden von unterschiedlichem Typ, so wird der Operand mit ungenauerem Typ, zuerst zum genaueren Typ konvertiert, bspw. ist 1 / 5. eine Konstante vom Typ double. Konvertierung von double nach int erfolgt durch Abschneiden, nicht durch Rundung! int n = 3.7; printf("n = %d\n", n); /* Output: n = 3 */
Implizite Typkonversion Klammern entscheiden die Reihenfolge in der die Operatoren angewendet werden. double x_1 = 2 / 4; double x_2 = 2 / 4.; double x_3 = 10. * 2 / 4; double x_4 = 10. * (2 / 4); printf("x_1 = %lf\n", x_1); printf("x_2 = %lf\n", x_2); printf("x_3 = %lf\n", x_3); printf("x_4 = %lf\n", x_4);
Implizite Typkonversion Klammern entscheiden die Reihenfolge in der die Operatoren angewendet werden. double x_1 = 2 / 4; double x_2 = 2 / 4.; double x_3 = 10. * 2 / 4; double x_4 = 10. * (2 / 4); printf("x_1 = %lf\n", x_1); printf("x_2 = %lf\n", x_2); printf("x_3 = %lf\n", x_3); printf("x_4 = %lf\n", x_4); Der Code produziert den Output: x_1 = 0.000000 x_2 = 0.500000 x_3 = 5.000000 x_4 = 0.000000
Explizite Typkonversion Man kann dem Compiler mitteilen, in welcher Form eine Variable interpretiert werden muss. Man stellt dazu den Ziel-Typ in Klammern voran double x_1 = (double) (2 / 4); double x_2 = (double) 2 / 4; double x_3 = 2 / (double) 4;
Explizite Typkonversion Man kann dem Compiler mitteilen, in welcher Form eine Variable interpretiert werden muss. Man stellt dazu den Ziel-Typ in Klammern voran double x_1 = (double) (2 / 4); double x_2 = (double) 2 / 4; double x_3 = 2 / (double) 4; Die Variablen haben den Wert: x_1 = 0.000000 x_2 = 0.500000 x_3 = 0.500000
Vordefinierte Funktionen aus math.h Die Datei math.h gehört zur C-Standardbibliothek. Mit #include <math.h> wird sie einem Programm hinzugefügt. Die Datei enthält eine Reihe von wichtigen mathematischen Funktionen, z. B. double x, base, exponent; fabs(x) /* absolute value of x */ sqrt(x) /* square root of x */ sin(x), cos(x) /* sine, cosine of x */ exp(x) /* exponential function of x */ pow(base,exponent)/* base raised to the power exponent*/ Die genannten Beispiele erwarten als Parameter Gleitpunktzahlen und geben auch einen double-wert zurück: double x = fabs(-2.); /* x = 2. */ double y = pow(4.,2.); /* x = 16. */
Explizites Linken der Mathematik-Bibliothek Allein das Hinzufügen von math.h durch die #include-direktive reicht in der Regel nicht aus, damit ein Programm kompiliert wird. Fehlermeldungen der Form $ gcc -o math math.c math.c:(.text+0x6b): undefined reference to sqrt werden beim Linken (letzter Schritt im Übersetzungsvorgang) verursacht. Anders als etwa die Bibliotheksdatei stdio.h muss die Mathematik-Bibliothek im Compileraufruf explizit gelinkt werden: $ gcc -o math math.c -lm
Berechnung der Quadratwurzel Quelltext (Quadratwurzel) 1 #include <math.h> 2 #include <stdio.h> 3 4 int main(void) 5 { 6 /* declare floating point variable */ 7 double x; 8 9 /* read from user input */ 10 printf ("x = "); 11 scanf("%lf", &x); 12 13 /* print value of x and square root */ 14 printf ("x = %f\n", x); 15 printf ("sqrt(x) = %f\n", sqrt(x)); 16 17 return 0; 18 }
Gliederung
Binärsystem Das Binärsystem ist ein Zahlensystem, das zur Darstellung von Zahlen nur die Ziffern 0 und 1 benutzt: Sei n N, 0 n < 2 m, dann ist die Darstellung m 1 n = x i 2 i (x i {0, 1}) i=0 eindeutig. Im Binärsystem hat n die Darstellung x m 1 x m 2... x 1 x 0 2 Beispiel: Es gilt 378 10 = 1 2 8 + 0 2 7 + 1 2 6 + 1 2 5 + 1 2 4 + 1 2 3 + 0 2 2 + 1 2 1 + 0 2 0 Damit ist: 378 10 = 101111010 2.
Bits und Bytes Unter einem Bit stellen wir uns eine Binärziffer x {0, 1} vor (d. h. x nimmt nur die Werte 0 oder 1 an). Ein Byte ist eine zusammenhängende Folge von Bits. Alle Objekte in C werden in einer zusammenhängenden Folge von Bytes gespeichert. Der C-Standard schreibt eine Länge von mindestens 8 Bit für ein Byte vor. Die Größ eines Zeichens vom Typ char entspricht einem Byte.
Endlicher Wertebereich Ein Objekt vom Typ int belegt eine endliche Zahl an Byte im Speicher. Damit lassen sich nicht beliebig große Zahlen in einem Integer-Datentyp darstellen. Angenommen, eine vorzeichenlose Integer-Größe belegt M Bit. Die größte darstellbare Zahl lässt sich sofort angeben: das entspricht der Zahl } 111. {{.. 111 } 2, M M 1 i=0 2 i = 2 M 1. Sollen positive wie negative Zahlen dargestellt werden, muss ein Bit für das Vorzeichen reserviert werden.
Integer-Datentypen Die Integer-Datentypen zerfallen in zwei Klassen: solche, die negative wie positive Werte darstellen können (signed), und solche, die ausschließlich positive Werte annehmen (unsigned). Sämtliche Integer-Datentypen in C sind: /* signed integer types */ signed char short int int long int long long int /* unsigned integer types */ unsigned char unsigned short int unsigned int unsigned long int unsigned long long int Die verschiedenen Datentypen haben zum Teil eine unterschiedliche Speichergröße und damit auch unterschiedlich große Wertebereiche.
Speichergrößen ermitteln Die Speichergröße in Byte eines Datentyps, einer Variablen oder Konstanten lässt sich mit dem sizeof-operator ermitteln, z. B. printf("sizeof(int) = %zu Byte\n", sizeof(int)); printf("sizeof(double) = %zu Byte\n", sizeof(double)); Der Standard macht nur weiche Vorgaben zu den Größen der einzelnen Datentypen. Je nach System können diese unterschiedlich ausfallen: Datentyp Größe (PC, 32 Bit) Größe (PC, 64 Bit) char 1 Byte 1 Byte short int 2 Byte 2 Byte int 4 Byte 4 Byte long int 4 Byte 8 Byte long long int 8 Byte 8 Byte Tabelle : Größe in Byte der Integer-Datentypen
Ganzzahlüberlauf Lässt sich eine Zahl nicht mehr darstellen, spricht man von einem Ganzzahlüberlauf. Wir können diesen Fall künstlich herbeiführen: int n = (int)(pow(2.,31.)-1.); /* n = 2^31-1 */ printf("%d\n", n ); /* Output: 2147483647 */ printf("%d\n", n+1); /* Output: -2147483648 */ Ganzzahlüberlaufe können insbesondere bei Schleifen-Anweisungen mit grossen Datenmengen auftreten.
Gliederung
Normalisierte Gleitpunktzahlen I Normalisierte Gleitpunktzahlen basieren auf einer Darstellung der Form wobei p N\{0} fest gewählt, p 1 x = ( 1) s 2 e x i 2 i, der Exponent e innerhalb eines festgelegten Bereichs liegt, und x 0 0 gilt. i=0 e [e min, e max ] Z
Normalisierte Gleitpunktzahlen II Die Zahl m = x 0.x 1... x p 1 heißt Mantisse von x. Die festgewählte Zahl p nennt man Mantissenlänge. Eine Gleitpunktzahl x ist festgelegt durch Vorzeichen, Mantisse und Exponent: x = (s, m, e).
Arithmetik von Gleitpunkt-Zahlen Aufgrund ihrer Darstellung kommt es bei Gleitpunkt-Zahlen zu einer Reihe unintuitiver Phänomene, die das Ergebnis einer Berechnung beeinflussen. Die Addition von Gleitpunkt-Zahlen ist nicht assoziativ, d. h. im Allgemeinen gilt nicht: (a + b) + c = a + (b + c). 1 #include <stdio.h> 2 3 int main(void) 4 { 5 double a = 0.1, b = 0.2, c = 0.3; 6 7 /* print up to 20 decimal places */ 8 printf("(a+b)+c = %1.20lf\n", (a+b)+c); 9 printf("a+(b+c) = %1.20lf\n", a+(b+c)); 10 11 return 0; 12 }
Gliederung
Vergleichsoperatoren Objekte von numerischen Datentypen können miteinander verglichen werden. Hierzu dienen die binären Operatoren: expr1 < expr2 /* less than */ expr1 <= expr2 /* less than or equal to */ expr1 > expr2 /* greater than */ expr1 >= expr2 /* greater than or equal to */ expr1 == expr2 /* equal to */ expr1!= expr2 /* not equal to */ Beispiel: double x = 1., y = 2.; x < y; x >= y; x == y; x!= y; Frage: Welchen Typ und Wert haben die obigen Ausdrücke?
Logische Ausdrücke Vergleichsoperatoren liefern einen logischen Ausdruck. Ihre Auswertung resultiert in genau einem von zwei möglichen Werten: Der Rückgabewert ist 0, falls der Ausdruck unwahr ist, Der Rückgabewert ist 1, falls der Ausdruck wahr ist. Logische Ausdrücke sind damit vom Typ int. Umgekehrt gilt jeder von von Null verschiedene Ausdruck als wahre Aussage. Jeder Ausdruck mit Wert Null wird als unwahr interpretiert. Andere Programmiersprachen (z. B. C++, Java) reservieren einen eigenen Datentyp für Wahrheitswerte.
Logische Operatoren In C gibt es die folgenden Operatoren zur Verknüpfung logischer Ausdrücke:!expr /* logical negation */ expr && expr /* logical conjunction */ expr expr /* logical disjunction */ Ihr Wert ist jeweils vom Typ int und entweder 0 (falls die Aussage unwahr ist) oder 1 (sonst). Sogenannten Wahrheitstafeln kann man den Wert einer logischen Verknüpfung entnehmen: x y!x x && y x y ------------+-------+---------+-------- true true false true true true false false false true false true true false true false false true false false ------------+-------+---------+--------
Mehrfache Vergleiche Mehrfache Vergleiche sind in C nicht sinnvoll. Wir geben ein einfaches Beispiel. Es gilt 1 8 < 1 4 < 1 2. Der folgende Ausdruck hat aber den Wert 0 (die Aussage ist unwahr ): 0.125 < 0.25 < 0.5 denn die Vergleichsoperatoren werden von links nach rechts abgearbeitet.
if-anweisung Mit der if-anweisung kann der Ablauf eines Programms von Bedingungen abhängig gemacht werden. Syntax: if(expr) statement Die Semantik der Anweisung ist naheliegend: Der Ausdruck expr wird ausgewertet. Der Ausdruck heißt wahr, falls er ungleich Null ist. Falls expr wahr ist, wird die folgende Anweisung statement ausgeführt. Der Ausdruck expr heißt Kontrollausdruck.
Zusammenfassen von Anweisungen, Blöcke Sollen mehrere Anweisungen abhängig vom Kontrollausdruck ausgeführt werden, müssen sie in einem Block zusammengefasst werden: Syntax: if(expr) { statements... } Beispiel: int a, b, c, d;... if(a > b) { c = a - b; d = sqrt(c); return d; }
Programmbeispiel Quelltext (Wurzelberechnung mit Fehlerbehandlung) 1 #include <math.h> 2 #include <stdio.h> 3 4 int main(void) 5 { 6 /* declare floating point variable */ 7 double x; 8 9 /* read from user input */ 10 printf ("x = "); 11 scanf("%lf", &x); 12 13 /* check if value greater than 0 */ 14 if( x < 0 ) 15 { 16 printf("value x is less than zero\n"); 17 return 0; 18 } 19 20 /* print value of x and square root */ 21 printf ("x = %f\n", x); 22 printf ("sqrt(x) = %f\n", sqrt(x)); 23 24 return 0; 25 }
if-else-anweisung Optional kann die if-anweisung um den sog. else-zweig erweitert werden. if(expr) statement else statement Ob die Anweisungen des if- oder des else-zweigs bearbeitet werden, hängt vom Kontrollausdruck ab: Ist der Kontrollausdruck wahr, so wird der if-zweig bearbeitet, sonst werden die Anweisungen des else-zweigs bearbeitet. Sowohl im if- als auch im else-zweig können mehrere Anweisungen zu jeweils einem Block zusammengefasst werden.
Programmbeispiel Quelltext (Wurzelberechnung mit Fehlerbehandlung) 1 #include <math.h> 2 #include <stdio.h> 3 4 int main(void) 5 { 6 /* declare floating point variable */ 7 double x; 8 9 /* read from user input */ 10 printf ("x = "); 11 scanf("%lf", &x); 12 13 if( x < 0 ) 14 { 15 printf("value x is less than zero\n"); 16 } 17 else 18 { 19 printf ("x = %f\n", x); 20 printf ("sqrt(x) = %f\n", sqrt(x)); 21 } 22 23 return 0; 24 }
Autoren Autoren die an diesem Skript mitgewirkt haben: 2011 2014 : Christoph Gersbacher 2014 : Patrick Schreier This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) License. http://creativecommons.org/ licenses/by-sa/4.0/legalcode