Informatik: Abschnitt 4

Transkript

1 Inhalt: 4. Programmiersprache C Informatik: Abschnitt 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 Zeigern 4.6 Zeichen und Zeichenketten 4.7 Funktionen (Unterprogramme) 4.8 Strukturen 4.9 Typen, Variable und Konstante Danach folgen noch Abschnitte zu: Funktionen der Standardbibliothek, Speicherverwaltung, Datei-Ein und -Ausgabe Peter Sobe 1 Programmiersprache C Die C-Sprachfamilie: K&R C (1972, Kerningham-/Ritchie, Entwickler von C) ANSI/ISO-C89 ANSI/ISO-C99 Weiterentwickelt zu C++ C++ (1985, Bjarne Stroustrup) ANSI/ISO-C++ 98 ANSI/ISO-C++ 0x Weitere C-ähnliche Sprachen: Java C++-ähnliche Programmiersprache, SUN 1995 C# C++-ähnlich, Microsoft 2001 Peter Sobe 2

2 Programmiersprache C Imperative Programmiersprache: C-Anweisungen werden in der im Programm angegebenen Reihenfolge ausgeführt: zeilenweise (von oben nach unten) innerhalb Zeile möglicherweise mehrere Anweisungen, dann von links nach rechts Steuerfluss-Anweisungen (if, for, while, repeat, break, continue) zur Beeinflussung der Abarbeitungsreihenfolge Zum Vergleich: manch andere Programmiersprachen (logische und funktionale, beispielsweise PROLOG) arbeiten die Ausdrücke nicht notwendigerweise in der im Programm angegebenen Reihenfolge ab. Peter Sobe 3 Ein Programm besteht aus: Programmiersprache C Variablenvereinbarungen: hier werden Bezeichner für die Verarbeitungselemente festgelegt. Es wird ein Typ für jede Variable angegeben, z.b. Ganzzahl (int) oder Zeichen (char) Anweisungen: zur Verarbeitung der Variablen zur Beeinflussung des Steuerflusses Mehrfach auftretende Anweisungsfolgen werden oft in Funktionen gekapselt. Eine Hauptfunktion (main-funktion) ist der Punkt, an dem mit der Ausführung eines C-Programms begonnen wird. Peter Sobe 4

3 Programmiersprache C Vor dem Ausführen des Programms: C-Programm vorgegebene Header C-Präprozessor C-Programm C-Compiler Assembler Programm Compiler (2. Stufe) Maschinencode Bibliotheken Linker ausführbarer Code Peter Sobe 5 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 4.8 Strukturen 4.9 Typen, Variable und Konstante Peter Sobe 6

4 4.1 Programm-Aufbau in C // Beispielprogramm fakultaet.c #include <stdio.h> int main() { int fakultaet; int i,n; printf("geben Sie bitte n ein >"); scanf("%d",&n); Kommentar Include-Präprozessor-Anweisung main-funktion Variablen-Deklarationen fakultaet = 1; for (i=2;i<=n;i++) fakultaet = fakultaet * i; printf("die Fakultaet von %d betraegt %d \n",n, fakultaet); return 1; } Anweisungen Steuerfluss- Anweisung Peter Sobe 7 Kommentare Zur Kommentierung gibt es in C++ (nicht in C) die Zeichenfolge // (sog. Inline-Kommentare). Alles ab hier, bis zum Ende der Zeile wird vom Compiler als Kommentar betrachtet: int anzahl = 0; // Zähler für die Anzahl der Häuser, int i; // die ein weißes Dach haben Bei den Kommentarzeichen /* wird alles bis zu den Kommentarendezeichen */ als Kommentar vom Compiler überlesen (in C und C++): int anzahl = 0; /* Zähler für die Anzahl der Häuser, die ein weißes Dach haben */ int i; Peter Sobe 8

5 Kommentare Kommentare in Kommentaren Kommentare der Form /*...*/ können nicht geschachtelt werden: falsch /* int anzahl = 0; /* Zähler für die Anzahl der Häuser, die ein weißes Dach haben */ int i;*/ Inline-Kommentare können dagegen in Kommentaren der Form /*...*/ geschachtelt werden: /* int anzahl = 0; // Zähler für die Anzahl der Häuser, // die ein weißes Dach haben int i; */ Probleme, wenn Codeteile durch Auskommentieren deaktiviert werden müssen! richtig Peter Sobe 9 Präprozessor-Anweisungen Präprozessor-Anweisungen beginnen mit # und werden vor der Übersetzung verarbeitet Hier können z.b.text-ersetzungen vorgenommen werden. #define EPS if ( diff < EPS ) return value; else { /* berechne weitere Werte */ } Einbinden von so genannten Header-Dateien (*.h) zur Bekanntgabe von Funktionsinterfaces, z.b. #include <stdio.h> Peter Sobe 10

6 Präprozessor-Anweisungen Präprozessor-Anweisungen können zur Versionierung des Codes benutzt werden #ifdef VERSION_1 int a = 0,b = 0, c =0; // hier alles mit Integerzahlen #endif #ifdef VERSION_2; float a = 0.0, b = 0.0, c = 0.0; // jetzt alles mit Fließkommazahlen #endif Präprozessor-Anweisungen auch zum Auskommentieren von Code anstelle geschachtelter Kommentare #ifdef IRGENDETWAS_UNDEFINIERTES int anzahl = 0; // Zähler für die Anzahl der Häuser, // die ein weißes Dach haben int i; #endif Peter Sobe 11 Die main-funktion Der Beginn der main-funktion ist der Startpunkt des Programms. Die main-funktion kann aus dem Aufruf des Programms Parameter übernehmen Das Ende der main-funktion bedeutet das Ende des Programmlaufs. int main() { // hier beginnt die Verarbeitung return 1; // hier ist alles zu Ende } exit oder return aus der main-funktion bedeutet auch das Ende der Programmverarbeitung Peter Sobe 12

7 Die Form eines C-Progamms C ist eine formatfreie Sprache, d.h. das Aussehen, Zeilenumbrüche, Einrückungen haben keinen Einfluss auf die Funktion. Beispiele: main() { scanf("%d",&a); printf(" quadrat = %d\n", a*a); return 1; } main() { scanf("%d",&a); printf(" quadrat = %d\n", a*a); return 1; } Trotzdem sollte Code wie links dargestellt aussehen, um bessere Lesbarkeit zu gewährleisten. Peter Sobe 13 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 4.8 Strukturen 4.9 Typen, Variable und Konstante Peter Sobe 14

8 4.2 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 Peter Sobe 15 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 Peter Sobe 16

9 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; Peter Sobe 17 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

10 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) Peter Sobe 19 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: { }. ; Peter Sobe 20

11 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 Peter Sobe 21 Elementare Datentypen (1) Wertebereich Genauigkeit char = signed char unsigned char 1 Byte 1 Byte -2^ ^ ^8-1 2 Dezimalstellen, z.b. 88 ist genau int = signed int unsigned int short int = signed short int unsigned short int long int = signed long int unsigned long int 4 Byte 4 Byte 2 Byte 2 Byte 8 Byte 8 Byte -2^ ^ ^ ^ ^ ^ ^ ^ ^64-1 bool (nur C++) 1 Byte {true,false} 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 Peter Sobe 22

12 Elementare Datentypen (2) Wertebereich Genauigkeit enum { list } enum id { list } enum id float double long double type* void* 4 Byte 4 Byte 4 Byte 4 Byte 8 Byte 10 Byte 4 Byte 4 Byte 2^32 verschiedene Werte ca. -10^ ^38 ca. 10^ ^308 ca. -10^ ^ ^ ^32-1 type& 4 Byte 0...2^ Dez.-Stellen 15 Dez.-Stellen 19 Dez.-Stellen einzelne Bytes im Speicher adressierbar Peter Sobe 23 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. Peter Sobe 24

13 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). Peter Sobe 25 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 ; Peter Sobe 26

14 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: */ \ Peter Sobe 27 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 Peter Sobe 28

15 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= Peter Sobe 29 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 Peter Sobe 30

16 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 Peter Sobe 31 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); Peter Sobe 32

17 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,... }; Peter Sobe 33 Operatoren (1) Binäre Operatoren + - * / % Addition Subtraktion Multiplikation Division Divisionsrest Arithmetik Zahlen, mit Einschränkung Adressen nur ganze Zahlen < <= ==!= >= > Vergl. auf kleiner Vergl. auf kleiner oder gleich Vergl. auf gleich Vergl. auf ungleich Vergl. auf größer oder gleich Vergl. auf größer Vergleich Alle Typen & ^ << >> bitw. UND-Verknüpfung bitw. ODER-Verknüpfung bitw. Exkl.-Oder-Verknüpfung bitw. Linksverschieben bitw. Rechtsverschieben Bitoperationen Ganzzahlige Typen && log. UND-Verknüpfung log. ODER-Verknüpfung Logische Verknüpfungen Boolesche Werte Peter Sobe 34

18 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 Peter Sobe 35 Operatoren (3) Zuweisungs-Operatoren und sonstige Operatoren = Wertzuweisung Zuweisung Alle Typen += -= *= /= %= &= = ^= <<= >>=?:, Addition Subtraktion Multiplikation Division Divisionsrest bitw. UND-Verknüpfung bitw. ODER-Verknüpfung bitw. Eckl.-Oder-Verkn. bitw. Linksverschieben bitw. Rechtsverschieben Formulierung bed. Ausdrücke Aufzählung in Klammerausdr. Arithmetik und Zuweisung Bitoperationen und Zuweisung Fragezeichen-Operator zur verkürzten Formulierung bedingter Ausdrücke, siehe 4.3 Zahlen, mit Einschränkungen, Adressen nur ganze Zahlen ganzz. Typen Ausdrücke Ausdrücke Peter Sobe 36

19 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 Peter Sobe 37 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 >= Peter Sobe 38

20 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 Peter Sobe 39 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 Peter Sobe 40

21 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 zahl2 66. Peter Sobe 41 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; } Peter Sobe 42

22 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 Peter Sobe 43