Correlated Channel Faults - ti.tuwien.ac.at › cps › teaching › courses › ... · 5 Unser...
Transcript of Correlated Channel Faults - ti.tuwien.ac.at › cps › teaching › courses › ... · 5 Unser...
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)