Einführung in die Programmiersprache C

Transkript

1 Einführung in die Programmiersprache C 1 Einführung Alexander Sczyrba Robert Homann Georg Sauthoff Universität Bielefeld, Technische Fakultät

2 Inhalte der Veranstaltung 1 Einführung das Maschinenmodell Sprachelemente von C (komplexe) Datentypen Speicherverwaltung 2 Spezielle Themen I/O abstrakte Datentypen Portabilität Performance Security...

3 Geschichte 1957 Fortran 1958 erste ALGOL-Versionen 1967 BCPL wird vorgestellt (Richards) 1968 erstes UNIX in Assembler implementiert auf der PDP7 (18 kb RAM) 1969 Thompson entwickelt B (vereinfachtes BCPL) 1970 PDP11 (24 kb RAM) 1972 Dennis Ritchie entwickelt C an den Bell Labs 1973 erstes UNIX in C 1978 K&R C ANSI C

4 Motivation Warum C lernen?!? einfacher Sprachaufbau geringe Anzahl von verschiedenen Konzepten C ist sehr verbreitet C-Programme sind sehr portabel man möchte schnelle bzw. effiziente Programme schreiben man möchte Microcontroller in einer Hochsprache programmieren

5 Literatur Kernighan and Ritchie, The C Programming Language, 2nd Edition. Prentice-Hall, ANSI/ISO C99 Standard ( ISO/IEC 9899:1999(E) ) Harbison and Steele, C: A Reference Manual. Prentice-Hall, 2002.

6 Charakteristika von C maschinennah imperativ prozedural keine referentielle Integrität explizite Speicherverwaltung kleiner Sprachkern, benutzerdefinierte Abstraktionen ausgelagert in Bibliotheken

7 Das abstrakte Maschinenmodell Direkte Abbildung von Datentypen auf Hardware Programmablauf mit Seiteneffekten, also Änderungen des Zustands der Laufzeitumgebung durch das Programm Code Stack Heap RAM CPU Register

8 Schlüsselwörter in C ANSI-C (1989) definiert 32 Schlüsselwörter: auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while Erweiterungen in ISO C99 inline restrict _Bool _Complex _Imaginary Nichtstandardisierte Erweiterungen: asm, fortran, typeof,...

9 Hello world! #include <stdio.h> #include <stdlib.h> static long factorial(long n) { long i, result = 1; } for(i = 1; i <= n; ++i) result *= i; return result; int main(int argc, char *argv[]) { long n = (argc > 1)? atol(argv[1]) : 3; } printf("hello world!\n"); printf("factorial(%lu) = %lu\n", n, factorial(n)); return 0;

10 Hello world! Beobachtungen: die üblichen Sprachkonstrukte prozeduraler Sprachen sind vorhanden: Variablen, Bedingungen, Schleifen, Funktionen, etc. Code-Blöcke werden in geschweifte Klammern eingefasst Variablendeklarationen sind vom eigentlichen Code getrennt (in C99 auch gemischt erlaubt) Programme starten immer in der main()-funktion Ausgabe von Zeichenketten ist komisch

11 Einfache Datentypen Basistypen (basic types), built-ins : char int float double Qualifiers: signed unsigned short long (long long) Beispiele unsigned char long signed int... my_char; my_int;

12 Einfache Datentypen Achtung C garantiert keine festen Größen und somit auch keine Wertebereiche der Basistypen! Einzige Zusicherungen (gelten für signed und unsigned): sizeof(char) 1 (nicht 8 Bit) sizeof(char) sizeof(short int) sizeof(int) sizeof(long int) short int und int sind jeweils mindestens 16 Bit breit long int ist mindestens 32 Bit breit Konventionen: char: für das System natürliche Darstellung eines Zeichens (ASCII, EBCDIC, PETSCII, etc.) int: für das System natürliche Darstellung einer ganzen Zahl

13 Einfache Datentypen Typische Integer-Größen in Bits: I16LP32 ILP32 LP64 (m68k) (i386) (amd64) char short int int long int Pointer auf Daten Außerdem typisch (aber nicht garantiert): float double long double long long int 32 Bit 64 Bit 80 oder 96 Bit (x86), 128 Bit (SPARC) 64 Bit

14 Einfache Datentypen Default Signness : signed für int, float und double undefiniert für char ( implementierungsabhängig) Kombination von signed und unsigned weder möglich noch sinnvoll Sonstiges: alleinstehender Qualifier bedeutet implizit immer int (long = long int, short = short int) int wird üblicherweise weggelassen Anwendung von unsigned auf float oder double ist nicht definiert, Bedeutung also implementierungsabhängig

15 Einfache Datentypen Spezieller Typ: void Formell: unvollständiger Basistyp ein Ausdruck vom Typ void wird nur wegen seiner Seiteneffekte ausgewertet Verwendung: Rückgabetyp einer Funktion ohne Rückgabewert Argumentenliste einer Funktion ohne Argumente untypisierte Pointer Abschaltung der Typüberprüfung

16 Deklarationen Deklaration von Variablen: [Qualifier] Typ Name [ = Initialisierung]; Beispiel: long result = 1; Deklaration von Funktionen ( Funktionsprototypen ): [Qualifier] Typ Name(Argumentenliste); Beispiel: static long factorial(long); Die Funktionsdefinition kann direkt mit der Funktionsdeklaration verbunden werden: [Qualifier] Typ Name(Argumentenliste) {... }

17 Prä-ANSI: Funktionsdeklaration Rückgabetyp implizit int falls nicht anders deklariert Argumentenliste nicht Teil der Deklaration, sondern der Definition ( K&R style ) Beispiel long factorial(); /* Deklaration */ /* anderer Code... */ /* Definition von factorial() */ long factorial() long n; {... }

18 Spätestens seit 1989 (erster ANSI-Standard): Rückgabetyp wird immer mit angegeben Funktionsdeklaration Argumentenliste wird immer vollständig angegeben (Argumentennamen bei reiner Deklaration optional) Prototypen Beispiel long factorial(long); /* Deklaration */ /* anderer Code... */ /* Definition von factorial() */ long factorial(long n) {... }

19 Funktionsaufruf und Rückgabewerte Funktionsaufruf: Funktionsname gefolgt von runden Klammern Argumente werden in Klammern wie im Prototyp vereinbart übergeben Rückgabewert kann weiterverarbeitet werden Beispiel long f; double x; f = factorial(10); x = pow(3.4, 9.1); /* siehe "man pow" */ /* man page: double pow(double x, double y); */

20 Funktionsaufruf und Rückgabewerte Ende einer Funktion: Rücksprung zum Aufrufer mit return Rückgabewert wird als Argument von return übergeben falls Rückgabetyp void: Rückkehr am Ende der Funktion oder vorzeitige Rückkehr mit return ohne Argumente Beispiel void print_warning(const char *text) { if(text == NULL) return; printf("# WARNING: %s\n",text); }

21 Funktionen Nesting-Level von Funktionen ist auf 1 beschränkt keine Methodenüberladung

22 main() ANSI-Prototypen sollten immer verwendet werden. Für main() gilt keine Ausnahme, auch wenn gängige Literatur dies häufig ignoriert! Korrekt: ohne Kommandozeilenparametern: int main(void) { /*... */ } mit Kommandozeilenparametern: int main(int argc, char *argv[]) { /*... */ } mit Kommandozeilenparametern und Environment: int main(int argc, char *argv[], const char *env[]) { /*... */ } (Erweiterung auf UNIX-Systemen)

23 Operatoren einfache Zuweisung: = Vergleichsoperatoren: ==,!= <, >, <=, >= arithmetische Operatoren: +, -, *, /, % +=, -=, *=, /=, %= logische Operatoren: &&,,! bitweise Operatoren: &,, <<, >>

24 Bedingungen Bedingungen werden wie üblich mit if/else, bestimmte Variablenwerte mit switch/case abgefragt: if(expression) { /*... */ } else if(expression) { /*... */ } else { /*... */ } switch(var) { case 23: /*... */ break; case 42: /*... */ break; default: /*... */ break; }

25 Drei Möglichkeiten: 1 for(expression; expression; expression) { /*... */ } 2 while(expression) { /*... */ } 3 do { /*... */ } while(expression); 4 goto (zählt nicht... ) nur für Ausnahmefälle! Schleifen

26 Für die Übung Ausgabe auf Konsole mit printf(): Anzahl der Argumente für printf() ist variabel erstes Argument: Format-String restliche Argumente: alles, was ausgegeben werden soll Beispiel int i=5; unsigned long j=10; char c= x ; printf("i = %d j = %lu c = %c\n",i,j,c); Details: $ man -s 3C printf (Solaris) $ man 3 printf (Linux)

27 Übersetzung Einfach: $ cc program.c Standard-C-Compiler des Systems oder $ gcc program.c GNU C Compiler Ausgabe: ausführbares Programm a.out Allerdings: C-Compiler kennen üblicherweise sehr viele Optionen, z.b. für Optimierung (z.b. -O), Warnungen (z.b. -Wall), Debugging (z.b. -g), Festlegung des Sprachstandards (z.b. -std=c99)... Als Referenz siehe $ man gcc bzw. $ man cc größere Programme bestehen aus mehreren Dateien direkter Aufruf des Compilers nur für sehr kleine Programme zweckmäßig

28 Übersetzung Besser: Makefile schreiben, dann $ make oder $ make program Beispiel: C08/Makefile Noch besser: Makefile generieren...

29 Schreibe ein Programm, welches die natürlichen Zahlen bis n quadriert und ausgibt, wobei n als Parameter beim Programmaufruf übergeben wird. Übung