C-Block 1LU 182.109 Systemprogrammierung

Harald Paulitsch

2

Entstehung von C

• 1972 entstanden• von Dennis Ritchie für UNIX entworfen• durch UNIX große Verbreitung• ab 1993 Bestrebungen C zu standardisieren

American National Standard Institute (ANSI)

3

Goals & „non Goals“

• Ziele– Überblick über C– Grundlegendes über C-Programmierung– Hilfestellungen zum Selbststudium

• Was kann dieser Kurs nicht?– Ihnen das Üben abnehmen– „C beibringen“ das müssen Sie selber

4

ProgrammentwicklungAufgabe

Lösung

Implementierung

Design

Analyse

5

Unser erstes C-Programm 1/2

Schreiben Sie ein Programm, das den Schriftzug„Hello world“

auf dem Terminal ausgibt.

6

Unser erstes C-Programm 2/2

/* Hello World! */

#include <stdio.h>

int main(int argc, char *argv[]){

printf(“Hello, world!\n”);return 0;

}

7

Rückblende

• Kommentare/* Kommentar */

• Definition der Funktion mainint main(int argc, char *argv[]){...}

• Headerdateien includieren#include<stdio.h>

• Ausgabe mittels printfprintf(„Hello world\n“);

• terminieren mit Rückgabewertreturn 0;

8

Elemente von C

• Variablen, Konstanten, Operatoren, Ausdrücke• Kontrollflussmechanismen• Arrays• Pointer & Pointerarithmetik• Funktionen• Strukturen und benutzerdefinierte Typen

9

Was kann C?

• kompakte effiziente Sprache, Source ist portabel• Preprozessor mit Makroersetzung• Flexible Programmierung

– Hochsprache– Maschinennahe Operatoren– Direkter Speicherzugriff– Adressarithmetik

10

... und was kann C nicht?

• keine Laufzeittests– Stackoverflow– Bereichsüberschreitung (Arrays)

• keine komplexen Datentypen– keine Strings mit impliziter Funktionalität

(Vergleich, Aneinanderhängen, ...)

11

Unser zweites C-Programm 1/5

Schreiben Sie ein Programm, das eine Umrech-nungstabelle von Schilling in Euro auf dem Terminal ausgibt.x[Euro]=x[Schilling]/13.7603

12

Unser zweites C-Programm 2/5#include <stdio.h>

int main(int argc, char *argv[]){

return 0;}

13

Elementare Datentypen 1/3

• Ganzzahlig– char⇒ ein Zeichen (compilerabhängig)– int ⇒ Zahl (compilerabhängig)– short ≤ int⇒ Zahl (compilerabhängig)– long ≥ int⇒ Zahl (compilerabhängig)

• Modifier– signed– unsigned

14

Elementare Datentypen 2/3

• Fließkommazahlen– float⇒ eine Fließkommazahl– double≥float⇒ eine Fließkommazahl

• auch hier wieder: Länge (Mantisse & Exponent) ist complierabhängig

• Dot (.) nicht Komma (,) trennt den ganzzahligen vom gebrochenen Anteil

15

Elementare Datentypen 3/3• Obwohl Wertebereich der einzelnen Datentypen nicht konkret

spezifiziert, so wird im ANSI C Standard [1] dennoch zumindest ein Minimalumfang dieser Wertebereiche (definiert in limits.h) gefordert.

• Beispiele – CHAR_BIT⇒ 8 /* d.h. ‚char‘ hat mind. 8 bits */– SCHAR_MIN⇒ -127– SCHAR_MAX⇒ +127– INT_MIN⇒ -32767 /* d.h. ‚int‘ hat mind. 16 bits */– INT_MAX⇒ +32767– … /* und so weiter */

[1] ANSI C Standard „C99“, Abschnitt 5.2.4.2, Numerical Limits

16

Variablen 1/4

• Name– Buchstaben, Ziffern, ‘_‘ (case-sensitive,

Postleitzahl ≠ postleitzahl)– erstes Zeichen muss Buchstabe sein– nur die ersten 32 Zeichen sind relevant– keine Schlüsselwörter (if, while, int, ...)

17

Variablen 2/4

• Definition– am Beginn jedes Blockes– als Parameter einer Funktion

(Achtung! keine Defaultwerte)– global (ausserhalb jedes Blockes)

am besten vor allen Funktionen

18

Variablen 3/4

• Beispieldefinitionen– Blockbeginn{int nLower; ...

– Funktionsparameterint FooBar(int nUpper){ ...

– globalint nStep;int main(int argc,char *argv[]){...

19

Variablen 4/4

• Initiailisierung– Blockbeginn{int nLower = 42; ...

– Funktionsparameterkeine Initialisierung/Defaultwerte

– globalint nStep = 13;int main(int argc,char *argv[]){...

20

Unser zweites C-Programm 3/5#include <stdio.h>

int main(int argc, char *argv[]){int nI = 0;

return 0;}

21

Konstanten 1/2

• Schreibweise der Zahl drückt einen Typ aus:– ganzzahlig: 3356, -34, (27 + 3 * 2)– lang: 456456L, -1L– Gleitpunkt: 10., 3.141, -1.E-6

• Zahlensysteme– oktal: 012, 015, 040– hex: 0x41, 0xABBA, 0x0ED

22

Konstanten 2/2

• ein charakter: ‘a‘, ‘\n‘, ‘\0‘Vorsicht! einfache Hochkommata verwenden (auf der deutschen Tastatur Shift-#)

• Definition mit dem Preprozessor– #define NAME Wert

Klammern sind wichtig!#define FACTOR 3 + 4X = FACTOR * 5;

23

Unser zweites C-Programm 4/5#include <stdio.h>#define EURO_KURS 13.7603int main(int argc, char *argv[]){

int nI = 0;

return 0;}

24

Operatoren 1/7

• Arithmetische Operatoren– binär: +, -, *, /, %– unär: -(Negation), ++(Increment),

--(Decrement)

• Vergleichsoperatoren< > <= >= == !=Ergebnis ist true(1) oder false(0)

25

Operatoren 2/7

• logische Operatoren– Anzahl der Argumente:

• binär: && (log. AND), || (log. OR)• unär: ! (log. NOT)

– Ergebnis ist true(1) oder false(0)– Auswertung von links nach rechts bis das

Ergebnis feststeht („short circuit semantics“)

26

Operatoren 3/7

• bitweise Operatoren– binär: & (AND), |(OR),

^ (XOR), << bzw. >> (SHIFT)– unär: ~ (NOT)

Klammern setzten oder Prioritäten beachten!

27

Operatoren 4/7

• Zuweisungsoperatoren=, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=Syntaxformen:– variable OP= expression;– variable = variable OP (expression);

• Typumwandlungsoperatoren (casts)Syntax: ( typ ) expression

28

Operatoren 5/7

• Zuweisung - binäres MinusnI = 2 - 1;

• Postincrement - PrädecrementnI++ == 2 (false), --nI ==1 (true)

• logisches ANDif( (nI > 5) && (nI < 11) )(true ∀ nI ∈ {6,7,8,9,10})

29

Operatoren 6/7

• Typumwandlungint nI=15;(double) nI / 4 + 0.25; /* 4. */nI / 4 + 0.25; /* 3.25 */nI / 4. + 0.25; /* 4. */

• ZuweisungsoperatorennI *= 5 + 1; /* nI = nI * (5 + 1) */

30

Operatoren 7/7

• bitweise OperatorennA = 6; /* 0110 = 6 */nB = 3; /* 0011 = 3 */nC = nA | nB; /* 0111 = 7 */nD = 12; /* 1100 = 12 */nE = nC & nD; /* 0100 = 4 */nF = nE >> 2; /* 0001 = 1 */

31

Ausdrücke

• Ausdrücke werden gebildet aus– Konstanten– Variablen– Funktionsaufrufen– Operatoren zur Verknüpfung

• Priorität und Assoziativität– Klammern, bzw. auswendig lernen

32

Statements und Blöcke

• Statements– Durch ; werden Ausdrücke zu StatementsnI = 0715;

• Blöcke– Durch {} werden eingeschlossene

Deklarationen und Statements zu Blöcken– Kein ; nach }

33

Lokale Variablen

• in einem Block sind lokale Variablen möglich– Deklaration am Beginn des Blockes (nach {)– Geltungsbereich (Scope) auf Block begrenzt– können äußere Variablen überlagernint nI;int main(int argc, char *argv[]){int nI;nI = 15; /* lokales nI */

34

Kontrollflussmechanismen 1/2

• if( expression ){statements

}else{statements

}

• expression kann ein beliebiger Ausdruck seinjeder Wert != 0 ist true ⇒ if-Zweig,0⇒ else-Zweig (optional)

35

Kontrollflussmechanismen 2/2

• switch( expression ){case CONST1:

statementsbreak; /* break nicht vergessen!! */

case CONSTn:statementsbreak;

default:statementsbreak;

}

36

Schleifen

• while( expression ){statements

}• do{

statements}while( expression );

• for( PräExp; CondExp; PostExp ){statements

}

37

Explizite Schleifenunterbrechung

• breakAbbruch der innersten Schleife

• continueBeendigung des momentanen DurchlaufsFortsetzung mit nächster Iteration

• Return expressionbeendet die Ausführung einer Funktion

38

Strukturierung

• Leerzeichen, Leerzeilen und Klammern zur Strukturierung verwenden– Was bedeutet: if(nI&5+nJ==15)

a) if( ((nI & 5) + nJ) == 15 )b) if( (nI & (5 + nJ)) == 15 )c) if( nI & ((5 + nJ) == 15) )d) if( nI & (5 + (nJ == 15)) )

• Blöcke durch Einrücken kenntlich machen

39

So nicht!#include <stdio.h>#define PO(o,t)\(((o>64)&&(o<91))?(((t>96)&&(t<123))?(t-32):(t)):(((t>64)&&(t<91))?(t+32):(t)))

void main() { char *poo= "poot",*Poo="pootpoot" ,O[9];int o,t,T,p;(t=p =0)||(*O='\0');while((o= getc( stdin ))!=( EOF))if ((p== 0)&& (((o>64 )&& (o<91 )) || ((o> 96 ) &&(o< 123) ))) (t!=8 )&&(O [t]= o)&& (O[++ t] = '\0');else {if (t>7) {for (T = 0 ; T <=7; T++ )printf("%c", PO(*( O+T), *(Poo+ T))); printf("%c", o);}else if (t>3){for (T =0;T<=3;T++) printf("%c", PO(*(O+T),*( poo+T)

) ) ; printf( "%c" , o ) ; } else printf ( "%s%c" , O , o ) ; ( t = 0 ) || (* O = '\0' ) ; ( o == 60 ) && ( ++p ) ; ( o == 62 ) && (p!=0) && ( --p ) ; } }

40

Unser zweites C-Programm 5/5#include <stdio.h>#define EURO_KURS 13.7603int main(int argc, char *argv[]){

int nI = 0;for (nI = 1; nI <= 10; nI++){

printf(“%d ATS = %f EUR\n”,nI,((double) nI) / EURO_KURS);

}return 0;

}

41

Rückblende zweites C-Programm

FortschrittVariable, Konstante, Operatoren, AusdrückeKontrollmechanismen

– Arrays– Pointer und Pointerarithmetik– Funktionen– Strukturen und eigene Datentypen

42

Arrays

• Folge von Variablen gleichen TypsTyp Name[Größe];char acLine[80], aacScreen[25][80];

• Zugriff über Name und IndexacLine[5] = ‘a‘; (Indizes von 0 bis Größe-1)

43

Strings

• Strings sind char Arrayschar szBuffer[80];

• Zeichenkette wird durch ‘\0‘ terminiert• Stringkonstanten werden durch “ “ begrenztconst char szText[] = “Hello world!\n“;

• Viele Bibliotheksfunktionen vorhanden#include<string.h>

• Vorsicht! Keine boundary checks

44

Pointer 1/2• In Pointer sind Adressen explizit und

Typinformation implizitTyp *Name;int nI;int *pZeiger1,*pZeiger2;pZeiger1 = &nI; /* Initialisierung*/

pZeiger1pZeiger2

nI &nI&pZeiger1

&pZeiger2

45

Pointer 2/2

*pZeiger1 = 5; /* nI = 5 */*pZeiger2 = 7; /* Fehler? */

pZeiger1pZeiger2

nI &nI&pZeiger1

&pZeiger2

5

7

pZeiger2 = (int*)7; /* besser */

pZeiger2&pZeiger2 ? 7

46

Pointerarithmetik 1/2• Zuweisungen nur an typ-entsprechende Pointer• Adresse 0 (NULL) ist immer ungültig (NIL)• Increment erhöht um sizeof(Typ)• int *pZeiger;int anX[10];pZeiger = anX; /* pZeiger = &(anX[0]) */

pZeiger&pZeiger anX[0] &(anX[0])

anX[9] &(anX[9])

47

Pointerarithmetik 2/2

pZeiger += 5; /* pZeiger = &(anX[5]) */*pZeiger = 10; /*anX[5] = 10 */

pZeiger&pZeiger anX[0] &(anX[0])

anX[5] &(anX[5])

anX[9] &(anX[9])

10

48

Funktionen 1/5

• Funktionsdefinition (Implementation)Returntyp Name(Argumentdeklaration)double Wurzel(double fZahl){...}

• Aufruf einer FunktionName(expression,expression,...)double fRadix;fRadix = Wurzel(500.);

49

Funktionen 2/5

• Prozeduren?Returntyp ist void

• Falls der Returnwert Aufschluss über Erfolg bzw. Misserfolg der Funktion liefert, muss er behandelt werden!

• Wird er nicht benötigt auf (void) castenkeine Compilerwarnings und es wird besser sichtbar, dass die Abfrage nicht vergessen wurde

50

Funktionen 3/5

• Erfolg bzw. Misserfolgif( fclose(fpFile) != 0){/* Fehlerbehandlung */

}

• Nicht benötigter Return Wert(void) printf(“Fehler ...\n“);

51

Funktionen 4/5

• Funktionsdeklaration (Prototyping)Returnwert Name(Argumentdeklaration);

• korrekte Verwendung wird beim Compilierengeprüft

• „Referenz“ auf eine Funktion die anderswo definiert ist

• Funktionsdeklarationen in .h-File zusammen-fassen

52

Funktionen 5/5

• modulA.h (Deklaration)extern int Funktion(char *); oderextern int Funktion(char *szString);

• modulA.c (Definition)int Funktion(char *szString){...

}

53

Argumentübergabe 1/2

• Übergabe aller Argumente werden als Wertparameter (Kopie am Stack)

• Argumente in Funktionen können wie lokale Variablen verwendet werdenvoid Funktion(int nZahl){nZahl = 42;

}Funktion(nI);

54

Argumentübergabe 2/2

• Wie werden Variablenparameter übergeben?Adresse der Argumente werden als Wertparameter übergeben

• Zugriff durch Dereferenzieren der Adressevoid Funktion(int *pnZahl){*pnZahl = 42;

}Funktion(&nI);

55

Strukturen und eigene Datentypen 1/2

• Strukturenstruct Koordinate{int nX;int nY;

};struct Koordinate sPunkt;sPunkt.nX = 12;

56

Strukturen und eigene Datentypen 2/2

• Definieren eigener Datentypentypedef unsigned int uint32_t;uint32_t nI, nJ = 12;typedef struct Koordinate{int nX;int nY;

}sKoordinate_t;sKoordinate_t sPunkt;

57

Vom Sourcecode zum Executable

modul1.c modul1.h modul2.c

modul1.o modul2.o

program

Source Files

Object Files

Executable

Compiler

Linker

58

Weiterführende Literatur 1/2

• C-Programmierung– Buch Systemnahes Programmieren– Unix Manpages– The C Programming Language

(Kernighan, Ritchie, Prentice Hall)– Die C++ Programmiersprache

(Stroustrup, Addison-Wesley)

59

Weiterführende Literatur 2/2

• Programmierstil– Writing Solid Code

(Maguire, Microsoft Press)– C Elements of Style

(Oualline, M&T Publishing)