4.2 Basisdatentypen und einfache Anweisungen

Transkript

1 Inhalt Inhalt: 4. Programmiersprache C 4.1 Programmaufbau in C 4.2 Basisdatentypen und einfache Anweisungen 4.3 Steuerfluss-Konstrukte 4.4 Arbeit mit indizierten Größen (Felder) 4.5 Arbeit mit Pointern 4.6 Zeichen und Zeichenketten 4.7 Funktionen Basisdatentypen und einfache Anweisungen Die Verarbeitung erfolgt durch Anweisungen, die die Werte der Variablen verändern. Variablen können Zahlenwerte, logische Werte (wahr, falsch), Zeichen, Zeichenketten, Zeiger, Felder aufnehmen Variablen müssen vor ihrer ersten Benutzung auf jeden Fall deklariert worden sein. Bezeichner (Namen für Variable, Funktionen,...) Namen beginnen mit einem Buchstaben oder einem Unterstrich. Die weiteren Zeichen sind Buchstaben, Zahlen oder Unterstriche. Schlüsselworte der Sprache dürfen nicht als Name verwendet werden 15

2 Variablennamen Zulässige Variablennamen: a; i; j; k; _pointer; ganz_langer_name_24_undnochlaenger; name; Name; // Groß- und Kleinschreibung wird unterschieden Nicht als Variablenname zulässig: 34Name; // Fehler Zahl am Anfang nicht erlaubt Strassen Name; // Leerzeichen nicht erlaubt: Strassen_Name Ölinhalt // Fehler, Umlaute verboten C&A; // Fehler; Sonderzeichen verboten while; // da es ein Schlüsselwort while bereits gibt Variablenname sollten kurz sein, aber inhaltlich ihre Bedeutung wiedergeben 16 Variablennamen Variablenname sollten kurz sein, aber inhaltlich ihre Bedeutung wiedergeben, z.b. int anzahl_patienten; float gewicht; Indexvariable und Zähler werden oft mit i, j, k oder z bezeichnet. Beispiele für schlecht gewählte Variablennamen: int meinkleinerschleifenzähler=0; int grosserschleifenzaehler; 17

3 Schlüsselwörter Folgende C-Schlüsselworte dürfen nicht als Variablennamen benutzt werden: auto double int struct break else long switch case enum register typedef char extern return union const float short unsigned continue for signed void default goto sizeof volatile do if static while In C++ weitere Schlüsselwörter: asm export private true bool false protected try catch friend public typeid class inline reinterpret_cast typename const_cast mutable static_cast using delete namespace template virtual dynamic_cast new this wchar_t explicit operator throw Peter Sobe 18 Konstanten Konstanten und Zeichenfolgen (Literale) Konstanten sind ganze Zahlen, z.b. 123, -465, 033, 0xab, 0XFF, 123L, 123UL, Gleitkommazahlen, z.b , 12.45e-3, 0123, 1e20, Zeichenkonstanten, z.b. a, X, \07, \xb und Aufzählungswerte, z.b. rot, Montag,... (wenn vorher entsprechend definiert) Zeichenfolgen sind z.b. "Guten Morgen" (besteht aus Ein-Byte-Zeichen) und L"Guten Morgen" (besteht aus Mehr-Byte-Zeichen) 19

4 Operatoren Operatoren zur Anwendung auf eine oder zwei Variablen: [] (). -> & * + - ~! sizeof / % << >> < > <= >= ==!= ^ &&? : = *= /= %= += -= <<= >>= &= ^= = Beispiele: a++; // a=a+1; if (aussage1 && aussage2) {printf("zwei Aussagen \n");} // logisch UND glück = liebe geld; // logisch ODER Interpunktionszeichen in C: { }. ; 20 Trennzeichen (white spaces) Trennzeichen der Sprache C sind: Zwischenraum (space, blank), horizontaler Tabulator, neue Zeile vertikaler Tabulator, Seitenvorschub (form feed) siehe formatfreie Sprache Leerzeichen und Zeilenumbrüche dürfen in C / C++ an beliebiger Stelle außer in Namen stehen: int var_i=17; int var_i = 17; int var_i = 17; int var_ i=17; // ist aber verboten 21

5 Elementare Datentypen (1) Wertebereich Genauigkeit char = signed char unsigned char int = signed int unsigned int short int = signed short int unsigned short int long int = signed long int unsigned long int 1 Byte 1 Byte 2 Byte 2 Byte 8 Byte 8 Byte -2^ ^ ^8-1 -2^ ^ ^ ^ ^ ^ ^ ^ ^64-1 bool (nur C++) 1 Byte {true,false} 2 Dezimalstellen, z.b. 88 ist genau 9 Dezimalstellen 4 Dezimalstellen 19 Dezimalstellen (ab C99, 64 Bit) Die angegebenen Werte stellen Beispiele für 32-Bit Umgebungen dar, sie sind implementierungsabhängig 22 Elementare Datentypen (2) Wertebereich Genauigkeit enum { list } enum id { list } enum id float double long double type* void* 8 Byte 10 Byte 2^32 verschiedene Werte ca. -10^ ^38 ca. 10^ ^308 ca. -10^ ^ ^ ^32-1 type& 0...2^ Dez.-Stellen 15 Dez.-Stellen 19 Dez.-Stellen einzelne Bytes im Speicher adressierbar 23

6 Elementare Datentypen (3) Datentypen für ganze Zahlen in C: int, signed int, unsigned int, long, signed long, unsigned long, short, signed short, unsigned short Beispiel: int i = -64; long li = 3; Integer-Variablen werden für beispielsweise für zählbare Dinge benutzt, oder für Index-Berechnungen. 24 Gleitkommazahlen: Elementare Datentypen (4) float, double, long double Beispiele: double d = ; double d1 = 1.234e-22; // ohne Leerzeichen zu schreiben float f = 67.31f; float f1 = e-22f; double x = 5.; // 5. entspricht 5.0 Gleitkommazahlen werden für Eigenschaften, Größen verwendet, die als rationale oder reelle Zahlen angegeben werden, z.b. Spannung (=4.5 V). 25

7 Elementare Datentypen (5) Wahrheitswerte (bool) mit den Werten true und false (nur C++) Beispiele: bool gefunden = true; bool ende = false; Einzelne Zeichen (char) - die Werte entsprechen in der Regel dem ASCII-Zeichensatz Beispiele: char c = 64; char c1 = h ; char c2 = \n ; 26 Zeichenkonstanten Spezielle Zeichenkonstanten: /* Zeilenvorschub: */ \n /* Horizontaler Tabulator: */ \t /* Vertikaler Tabulator: */ \v /* Backspace: */ \b /* Carriage-Return: */ \r /* Form-Feed: */ \f /* Alarm: */ \a /* Backslash: */ \\ /* Fragezeichen: */ \? /* Einfaches Anfuehrungszeichen: */ \ /* Doppeltes Anfuehrungszeichen: */ \ 27

8 Konstanten Die Verwendung von Konstanten erhöht die Lesbarkeit des Programms und macht es änderungsfreundlicher Anstatt: umfang = 2 * radius * ; Besser: const double PI = ; umfang = 2 * radius * PI; const heißt nur, dass die Variable nicht mehr verändert werden darf, der Wert muss nicht schon zur Übersetzungs-Zeit bestimmt werden können. Beispiel: const double UmfangMeinKreis = 2.0 * radius * PI; // radius muss keine Konstante sein 28 Konstanten Guter Programmierstil ist es, außer den Konstanten 1, 0 und 1 keine expliziten Zahlenkonstanten in seinem Programm zu verwenden, sondern diese immer über const einen Namen zuzuweisen. Anstatt: for (int i=0;i<10;i++) spieler[i].anzahl_huetchen= Besser: const int ANZAHL_DER_MITSPIELER = 10; for (int i=0; i < ANZAHL_DER_MITSPIELER; i++) spieler[i].anzahl_huetchen= 29

9 Typkonvertierungen Ohne Angabe hat eine Gleitkommakonstante den Typ double. double d = 0.6; float f = 0.6;... d = f; // ergibt keine Warnung f = d; // ergibt eine Warnung Bei einer Zuweisung eines double an ein float wird eine Warnung erwartet: float ff = ; // kann man mal ausprobieren 30 Interne Darstellung von Gleitkommazahlen 0.6 ist im Binärsystem: Bits (Mantisse genannt) Dieses bedeutet: 1* 1/2 + 0 * 1/4 + 0 *1/8 + 1 * 1/ * 1/ * 1/ und ergibt: Wenn float nur 24-Bit zur Darstellung der Mantisse verwendet (ist üblich, da normalerweise noch 8 Bit zur Darstellung des Exponenten verwendet werden), ist die Genauigkeit noch etwas geringer. Die Zuweisung dieser 24 Bit-Genauigkeit an eine double-zahl ergibt somit eine Warnung 31

10 Explizite Typkonvertierungen In einigen Fällen ist eine explizite Typkonvertierung unbedingt erforderlich: int a = 5; int b = 2; // In C/C++ double x = ((double) a ) / ((double) b); // x ist 2.5, sonst 2.0 In C++ auch erlaubt: double x = double(a) / double(b) // In C++ empfehlenswert: double x = static_cast<double>(a) / static_cast<double>(b); 32 Aufzählungstypen Manchmal ist es sinnvoll, eine Vielzahl gleichartiger Konstanten zu einer Menge zusammenzufassen. Jedes Element dieser Menge bekommt eine Ordinalzahl Das erste Element erhält z.b. die Ordinalzahl 0, das zweite 1 usw., Beispiel: enum Wochentag { Mon, Die, Mit, Don, Fri, Sam, Son }; Wochentag Tag; Tag = Mon; Syntax von Aufzählungen: enum AufzTyp { Bezeichnerl, Bezeichner2,... } Variable; enum { Bezeichnerl, Bezeichner2,... } Variable; enum AufzTyp { Bezeichnerl = 2, Bezeichner2,... }; 33

11 Operatoren (1) Binäre Operatoren + - * / % < <= ==!= >= > & ^ << >> && Addition Subtraktion Multiplikation Division Divisionsrest Vergl. auf kleiner Vergl. auf kleiner oder gleich Vergl. auf gleich Vergl. auf ungleich Vergl. auf größer oder gleich Vergl. auf größer bitw. UND-Verknüpfung bitw. ODER-Verknüpfung bitw. Exkl.-Oder-Verknüpfung bitw. Linksverschieben bitw. Rechtsverschieben log. UND-Verknüpfung log. ODER-Verknüpfung Arithmetik Vergleich Bitoperationen Logische Verknüpfungen Zahlen, mit Einschränkung Adressen nur ganze Zahlen Alle Typen Ganzzahlige Typen Boolesche Werte 34 Operatoren (2) Unäre Operatoren, Postfix- und Präfix-Operatoren & * + - Adresse von Inhalt von pos. Vorzeichen neg. Vorzeichen Refernzierung Dereferenzierung Arithmetik alle Typen Zeiger Zahlen ~ bitw. Invertierung Bitoperationen ganzz. Typen! logische Invertierung Log. Verknüpfung boolesche Werte (type) Typecast C-Allzweck-Cast viele Typen sizeof sizeof sizeof expr.: Speicherbedarf sizeof (type):speicherbedarf Inkrementierung Dekrementierung Postfix und Präfix Ausdrücke Typen ganzz. Typen und Zeiger 35

12 Operatoren (3) Zuweisungs-Operatoren und sonstige Operatoren = Wertzuweisung Zuweisung Alle Typen += -= *= /= %= Addition Subtraktion Multiplikation Division Divisionsrest Arithmetik und Zuweisung Zahlen, mit Einschränkungen, Adressen nur ganze Zahlen &= = ^= <<= >>= bitw. UND-Verknüpfung bitw. ODER-Verknüpfung bitw. Eckl.-Oder-Verkn. bitw. Linksverschieben bitw. Rechtsverschieben Bitoperationen und Zuweisung ganzz. Typen?:, Formulierung bed. Ausdrücke Aufzählung in Klammerausdr. Ausdrücke Ausdrücke Fragezeichen-Operator zur verkürzten Formulierung bedingter Ausdrücke, siehe Einfache Anweisungen Arithmetische Operatoren Einfache Zuweisung = Beispiel: summe=64; Addition + bzw. += Beispiele: summe = zahl + 61; summe = summe + 4; summe += 4; Subtraktion - bzw. -= Multiplikation * bzw. *= Division / bzw. /= Modulo-Operator % bzw. %= und weitere Operatoren... Jede Anweisung wird durch ein Semikolon abgeschlossen 37

13 Initialisierung von Variablen, Vergleich Deklaration und Initialisierung: int i = 7; /* Speicherplatz wird reserviert, der mit 7 initialisiert wird */ Zuweisung: i = 8; /* Vorhandener Speicherplatz wird mit neuem Wert belegt.*/ Vergleichsoperatoren gleich == ungleich!= kleiner < kleiner gleich <= größer > größer gleich >= 38 Vergleich Beispiele: if (zahl < 64)... if (zahl == 16)... if ((zahl >= 0) && (zahl <= 64))... // zahl aus dem Bereich [0..64] bool bo = 5 > 7; // bo erhält den Wert false int a = 5 > 7; // a erhält den Wert 0 int b = 5 < 7; // b erhält den Wert 1 39

14 Logische Verknüpfungen Logische Verknüpfungsoperatoren Logisches Und && Logisches Oder Logisches Nicht! Beispiele: if ( (!(zahl < 0)) && (!(zahl > 64)))... // Alle drei Abfragen sind gleich if ( (zahl >= 0) && (zahl <= 64) )... // bedeutend, sie testen, ob zahl if ( zahl >= 0 && zahl <= 64 )... // in dem Bereich liegt 40 Inkrement und Dekrement (1) zahl = zahl + 1; // kann verkürzt werden zu zahl += 1; // und nochmals zu zahl++; Entsprechend gibt es zahl--; für das Erniedrigen von zahl um 1. Beachte: zahl++; und ++zahl; sind nicht unbedingt das gleiche. Beispiel: int zahl1 = 64; int zahl2 = ++zahl1; // zahl2 und zahl1 sind nun beide 65 int zahl3 = zahl2++; // zahl3 ist 65 und zahl

15 Inkrement und Dekrement (2) Pre-Increment und Post-Increment als Funktionen Pre-Increment: int zahl2 = ++zahl1; // entspricht int zahl2 =PreInc(zahl1); // mit int PreInc(int& i) { i = i + 1; return i; } Post-Increment: int zahl2 = zahl1++; // entspricht int zahl2 =PostInc(zahl1); // mit int PostInc(int& i) { int temp=i; i = i + 1; return temp; } 42 Prioritäten von Operatoren 1! ~ * & sizeof (type) unär, postfix, präfix 2 3 / % + - binäre arithmetische Operatoren 4 << >> Shift-Operationen < <= > >= ==!= & ^ && Vergleichsoperatoren Bitoperationen logische Verknüpfungen 12 = += -= *= /= %= &= = = <<= >>= Zuweisungsoperatoren 13, Komma-Operator 1 ist die höchste Priorität, 13 die niedrigste 43