Vorlesung 1.

Präsentation zum Thema: "Vorlesung 1."—  Präsentation transkript:

1 Vorlesung 1

2 C Sprache Algorithmen Effektivität von Algorithmen Programme specifizieren, Algorithmen zu ausarbeiten, Quelltext generieren, dokumentieren

3 Elektrotechnik Kleine Klausuren: max. 6 P. (3 * 2P.)
Laboren(8-13 Wochen): max. 18 P. (6 * max. 3P.) Hausaufgabe: max. 10 P. (Note * 2P.) Grosse Klausur : max. 10 P. (Note * 2P.) Zusammen: max. 44 P.

4 Elektrotechnik 38 - 44 P. Note 5 32 - 37 P. Note 4 26 - 31 P. Note 3

5 Informatik Grosse Klausur: es soll einen Note 2 erreicht werden
Schriftliche Prüfung im Prüfungsperiod

6 Informatik labor 3 kleine Klausur Hausaufgabe Durchschnitt + od. - 1

7 Vor C: Multics project—General Electric, MIT, und Bell Laboratory (1969) (kein Erfolg) – zu große OP System Bell Laboratory - Ken Thompson, Dennis Ritchie, Brian Kernighan – „UNIX” Ken Thompson – prog. Sprache B

8

9 BCPL und B sind typenlose Sprachen C hat eine Reihe von Datentypen
Zeichen, ganze Zahlen, Gleitpunktzahlen Es gibt eine Hierarchie von abgeleitete Datentypen (mit Hilfe von Zeigern, Vektoren, Strukturen und Unionen erzeugt) Kontrollstrukturen, die für wohlstrukturierte Programme nötig sind:

10 Kontrollstrukturen, die für wohlstrukturierte Programme nötig sind:
Zusammenfassung von Anweisungen { } Entscheidungen (if-else) Auswahl von einem aus einer Menge von möglichen Fällen (switch) Schleifen mit Test des Abbruchkriteriums am Anfang (while, for) oder am Ende (do) Vorzeitiges Verlassen einer Schleife (break)

11 Funktionen können Werte der elementare Typen, aber auch von Strukturen, Unionen oder als Zeigern als Resultat liefern. Jede Funktion darf rekursiv aufgerufen werden Die lokalen Variablen einer Funktion sind typischerweise „automatisch”, das heißt, sie werden bei jedem Aufruf der Funtion neu erzeugt werden

12 Funktionsdefinitionen können nicht verschachtelt werden,
Die Funktionen eines C Programms können sich in verschiedenen Quelldateien befinden, die getrennt voneinander übersetzt werden Ein Preprozessor ersetzt Makros im Programmtext, fügt andere Quelldateien ein und ermöglicht bedingte Übersetzung

13 Definition einer Bibliothek, die zu C gehört
ANSI C standard 1988 Definition einer Bibliothek, die zu C gehört Funktionen zum Zugriff auf das Betriebsystem (Dateien zu lesen und schreiben) Funktionen für formattierte Ein- und Ausgabe Funktionen für Speicherverwaltung etc.

14

15

16 #include <stdio.h>
main() { printf(”hello, world\n”); }

17 #include <stdio.h>
int main() { int a,b,c; int summe; a = 1; b = 2; c = 3; summe = a+b+c; printf(”summe=%d \n”,summe); return 0; }

18 Arithmetische Operatoren binäre +, -, /, *, % unäre +, - Vorrang
arithmetische Operatoren werden von links her zusammenfaßt Verbindung von arithmetische Operatoren c = a = d+e; von rechts her +, - (unären) *, / , % +, - (binären)

19 Datentypen 4 elementare Datentypen
char ein Byte, ein Zeichen – Grundelement des Speichers int ganzahliger Wert, 16 oder 32 Bits float ein einfach genauer Gleichpunktwert double ein doppelt genauer Gleichpunktwert

20 Varianten dieser elementaren Typen
short int long int das Wort int kann ausgelassen werden short und int haben wenigstens 16 Bits long hat mindestens 32 Bits short ist nicht länger als int int ist nicht länger als long

21 Varianten dieser elementaren Typen
signed unsigned char oder int (sind ≥ 0)

22 Wertebereich int unsigned int float 3.4e e+38 double 1.7e e+308 long double 3.4e e+4932

23 Konstanten ganzzahlige Kostante 1234 hat den Typ int
long-Konstante l oder L vorzeichenlose Kostante 456u oder 456U 5789ul oder 5789UL unsigned long 036 oktal 0x36 oder 0X36 hexadezimal 0XFUL unsigned long mit Dezimalwert 15 Gleitpunktkonstanten (enthalten einen Dezimalpunkt) oder 1e-2 (enthalten einen Exponenten) sind double 113.6f oder 113.6F hat Typ float 113.6l oder 113.6L hat Typ long double

24 Elementare printf Umwandlungen
Zeichen Argument; Ausgabe als d,i int; dezimale Zahl o int; oktale Zahl ohne Vorzeichen x, X int; hexadezimale Zahl ohne Vorzeichen u int; dezimale Zahl ohne Vorzeichen c int; einzelnes Zeichen

25 %d als dezimale ganze Zahl ausgeben
%6d als dezimale ganze Zahl ausgeben, mindestens 6 Zeichen breit %f als Gleitpunktzahl ausgeben %6f als Gleitpunktzahl ausgeben, mindestens 6 Zeichen breit %.2f als Gleitpunktzahl ausgeben, 2 Zeichen hinter Dezimalpunkt (abgerundete Zahl) %6.2f als Gleitpunktzahl ausgeben, 6 Zeichen breit und 2 Zeichen hinter Dezimalpunkt

26 float f = ; printf("f=%f \n",f); printf("f=%15f \n",f); printf("f=%-15f \n",f); printf("f=%.3f \n",f); 1.235

27 float f = ; printf("f=%f \n",f); printf("f=%3.3f \n",f); printf("f=%15e \n",f); e+002 printf("f=%15.2e \n",f); 1.23e+002

28 Elementare printf Umwandlungen
Zeichen Argument; Ausgabe als s char*; aus der Zeichenkette werden Zeichen ausgegeben f double; [-]m.dddddd , wobei die Genauigkeit die Anzahl der d festlegt e, E double; [-]m.dddddde±xx , wobei die Genauigkeit die Anzahl der d festlegt

29 zeile ist ”hello, world” Zeichenkette
printf(”:%s:”,zeile); :hello, world: printf(”:%10s:”,zeile); printf(”:%.10s:”,zeile); :hello, wor: printf(”:%-15s:”,zeile); :hello, world : printf(”:%15.10s:”,zeile); : hello, wor: printf(”:%-15.10s:”,zeile); :hello, wor :

30 Vereinbarungen int i,j,k; double a,b; Eine Variable kann bei ihrer Vereinbarung auch initialisiert werden double a = 1.3, b = 2.3; Mit dem Attribut const kann bei der Vereinbarung einer Variablen angegeben werden, daß sich ihr Wert nicht ändert. const int a=3; dann a=a+1; /*ist falsch*/

31 Das Komma Operator mehrere Zuweisungen kann verbindet werden int i,j,k; i = 3; j = 4; k = i, i = j; die Auswertung geht von links her

32 Mathematische Bibliothekfunktionen
in <math.h> deklariert abs int abs(int) acos double acos(double) asin, atan, atan2 double atan2(double,double) atof, string to a floating point double atof(const char*) cabs, ceil(x), kleinster ganzzahliger Wert, der nicht kleiner als x ist cos, cosh, exp, fabs, floor(x), größter ganzzahliger Wert, der nicht größer als x ist log, log10, pow, sin, sinh, sqrt, tan, tanh

33 long a; float f = 123.9; a=f; printf("a=%ld \n",a); a=123

34 long a; float f = 123.9; f=f-(a=f); printf("a=%ld \n",a); printf("f=%15.2e \n",f); a=123 f= e+002

35 Schleifen for Schleife while Schleife while (Ausdruck) Anweisungen
do while Schleife do Anweisungen while (Ausdruck);

36 do while Schleife do Anweisungen while (Ausdruck);

37 Anweisungen werden durchgeführt bis Ausdruck bleibt von 0 verschieden
j = 0; i = 4; do { j = j+i; i = i-1; } while (i>0); j = 0; i = 4; do { j = j+i; i = i-1; } while (i); j = 0; i = 4; do j = j+i; while (i = i-1);

38 while Schleife while (Ausdruck) Anweisungen

39 Ist Ausdruck von 0 verschieden, so wird Anweisung ausgeführt und anshließend Ausdruck erneut bewertet i = 10; sum = 0; while (i>0) { sum=sum+i;i= i-1}; while (i) { sum=sum+i;i= i-1};

40 for Schleife for (init;test;post-expr) statement;

41

42 if else Anweisung if (Ausdruck) Anweisung1 else Anweisung2
Ausdruck hat einen von 0 verschiedenen Wert, so wird Anweisung 1 ausgeführt. Bei 0 wird Anweisung 2 ausgeführt.

43 Inkrement- und Dekrement-Operatoren
Der Inkrement-Operator ++ (addiert 1 zu seinem Operanden) Der Dekrement-Operator -- (substrahiert 1) Präfix-Notation ++n Postfix-Notation n++ n = 5; x = n++; /* x ist 5, n ist 6 */ n = 5; x = ++n; /* x ist 6, n ist 6 */

44

45 #include <stdio.h>
#include <math.h> int main() { int i,N=10; double a=1,b=2,del,x,sum,f,integral; del = (b-a)/N; sum = 0.0; for(i=1;i<=N;i=i+1) x = a+del*(i-1); f = sin(x); sum = sum + f; } integral = sum*del; printf("Integral = %lf\n",integral); printf("Integral = %lf\n",-cos(b)+cos(a)); return 0;

46 Bedingter Ausdruck z = (a>b)?a:b; if (a>b) z = a;
else z = b; z = (a>b)?a:b; Ausd1?Ausd2:Ausd3 Auch in Form

47 Zuweisungen und Ausdrücke
i = i+2; Ausdruck mit Zuweisungsoperator ( +=) i += 2; (+, -, *, /, %, <<, >>, &, |, ^)

48 #include <stdio.h>
#include <math.h> int main() { int i,N=10; double a=1,b=2,del,x,sum,f,integral; del = (b-a)/N; sum = 0.0; for(i=1;i<=N;i+=1) x = a+del*(i-1); f = sin(x); sum += f; } integral = sum*del; printf("Integral = %lf\n",integral); printf("Integral = %lf\n",-cos(b)+cos(a)); return 0;

49 Operatoren Vergleichsoperatoren == prüft auf Gleicheit ( a == b )
!= prüft auf Ungleicheit ( a != b ) >, >=, <, <= Verknüpfungen && AND (und-Verknüpfung) || OR (oder-Verknüpfung) ! NOT (Komplement; unär) Beispiel (a == b) && (c == d) || !(c == e)

50 #include <stdio.h>
int main() { int z1,nprim,i; z1=23; i=z1/2; nprim=0; while ((i>=2)&&(!nprim)) if (z1%i==0) nprim=1; i--; } if (nprim) printf("Nicht Prim \n"); else printf("Prim \n"); return 1;}

51 Die switch Anweisung Es ist eine Auswahl unter mehreren Alternativen
Untersucht, ob ein Ausdruck einen von mehreren Konstanten ganzzahligen Werten besitzt. switch(Ausdruck){ case const-Ausdruck1:Anweisung1 case const-Ausdruck2:Anweisung2 default : Anweisung3 }

52

53 i = 2; switch(i){ case 1: printf(”Montag”);break; case 2: printf(”Dienstag”);break; case 3: printf(”Mittwoch”);break; case 4: printf(”Donnerstag”);break; case 5: printf(”Freitag”);break; case 6: printf(”Sammstag”);break; case 7: printf(”Sonntag”);break; default : printf(”Fehler”); }

54

55 Operatoren Bit-Operatoren & Bit-AND | Bit-OR ^ Bit-XOR ~ Bit NOT
>> Bitshift nach Rechts << Bitshift nach Links int i = 8; i = i >> 2; /* Dividierung mit 4 */ i= i << 2; /* Multiplizierung mit 4 */

56 Funktionen und Programmstruktur
Funktionsdefinition Funktionstyp Funktionsname(Parameterdeklarationen) { Vereinbarungen und Anweisungen return Ausdruck } return-Anweisung liefert einen Wert als Resultat von der aufgerufenen Funktion zum Aufrufen

57 double addiert(double a, double b)
{ return a+b; } void ausschreibt(double a) printf(”%lf ”,a); } /*Funktion ohne Ausgangswert*/

58 int main() { int i,N=10; double a=1,b=2,del,x,sum,f,integral; del = (b-a)/N; sum = 0.0; for(i=1;i<=N;i+=1) x = a+del*(i-1); f = fv(x); sum += f; } integral = sum*del; printf("Integral = %lf\n",integral); printf("Integral = %lf\n",-cos(b)+cos(a)); return 0; #include <stdio.h> #include <math.h> double fv(double x) { return sin(x); }

59 #include <stdio.h>
#include <math.h> double fv(double x) { return sin(x); } int main() int i,N=10; double a=1,b=2,del,x,sum,f,integral; del = (b-a)/N; sum = 0.0; for(i=1;i<=N;i+=1) sum += fv(a+del*(i-1)); integral = sum*del; printf("Integral = %lf\n",integral); printf("Integral = %lf\n",-cos(b)+cos(a)); return 0; }

60 #include <stdio.h>
#include <math.h> double fv(double x) { return sin(x); } int main() int i,N=10; double a=1,b=2,del,x,sum,f,integral; del = (b-a)/N; sum = 0.0; for(i=1;i<=N;) sum += fv(a+del*(i++-1)); integral = sum*del; printf("Integral = %lf\n",integral); printf("Integral = %lf\n",-cos(b)+cos(a)); return 0; }

61 #include <stdio.h>
#include <math.h> double fv(double x) { return sin(x); } int main() int i,N=10; double a=1,b=2,del,x,sum,f,integral; for(i=1,sum=0.0,del = (b-a)/N;i<=N;sum += fv(a+del*(i++-1))) ; integral = sum*del; printf("Integral = %lf\n",integral); printf("Integral = %lf\n",-cos(b)+cos(a)); return 0;

62 Zeiger und Vektoren Ein Zeiger ist eine Variable, die die Adresse einer Variablen enthält. & unäre Adress-Operator * Inhalts-Operator (indirection, dereferencing) int x = 1, y = 2; int *ip; ip = &x; y = *ip; *ip = 0;

63 Zeiger und Vektoren Die Vereinbarung int a[10]; double v[25];
definiert einen Vektor mit 10 (25) Elementen, einen Block aus 10 (25) aufeinanderfolgenden Objekten, mit den Namen a[0] a[1] a[9]

64 Zeiger und Vektoren Vereinbart man pa als Zeiger auf einen int Wert
int *pa; dann zeigt pa durch die Zuweisung pa = &a[0]; auf das erste Element 0 von a; pa enthält die Adresse von a[0]

65 Zeiger und Vektoren pa + 1 ist eine Zeiger auf das nachfolgende Element pa + i ist eine Zeiger auf das i-te Element nach (hinter) pa Statt a[i] auch *(a+i) geschrieben werden kann pa = &a[0]; equivalent mit pa = a;

66 Zeigern als Funktionsargumente
void tausch(int *px,int *py) { int temp; temp = *px; *px = *py; *py = temp; } in main() Funktion tausch(&a,&b);

67 Zeigern als Funktionsargumente
Auswahl maximaler Element #include <stdio.h> #include <stdlib.h> int max(int *v,int g){ int maxwert = 0; if(g){ maxwert = v[0]; while(--g) if (v[g]>maxwert) maxwert = v[g]; } return maxwert; int main() { int vekt[10],i; for (i=0;i<10;i++){ vekt[i] = rand(); } printf("%d \n",max(vekt,10)); return 0;

68 Char Zeiger ”konstante Zeichenkette” das ist ein Zeichenvektor
der Vektor wird mit dem Nullzeichen ‘\0’ beendet char *Zeichenzeiger; Zeichenzeiger = ”Hallo”; char Zeichenpuffer[] = ”Hallo”;

69 Char Zeiger int strlen(char *c) {int n; for(n = 0;*s!=‘\0’;s++) n++;
return n; } int main(){ printf(”%d”,strlen(”Guten Tag”);

70 Char Zeiger int strlen(char *c) {int n; for(n = 0;*s!=‘\0’;s++) n++;
return n; } int main(){ char *Zeichenzeiger; Zeichenzeiger = ”Hallo”; char Zeichenpuffer[] = ”Hallo”; strlen(Zeichenpuffer); strlen(&Zeichenpuffer[]); strlen(Zeichenzeiger); strlen(Zeichenzeiger+2); strlen(Zeichenpuffer+2);

71 void strcpy(char *s,char *t)
{int i = 0; while (t[i]!=‘\0’) {s[i]=t[i];i++;} s[i]=t[i]; } {int i = 0; while ((s[i]=t[i])!=‘\0’) i++;

72 Type-Aliases (typedef)
Mit typedef kann man ein Alias für einen existierenden Typ deklarieren: typedef existing-type new-type; Beispiele: typedef int INTEGER; typedef int bool; typedef unsigned int uint;

73 Präzedenz und Bindung Englisch: „precedence” und „ associativity” („grouping”) Ohne diese ist ein Ausdruck der Art a + b * c nicht eindeutig Präzedenz: Reihenfolge der Auswertung der Operatoren Assoziativität: Reihenfolge bei Operatoren gleicher Präzedenz

74 C preprozessor # include Definitionsdatei einfügen
#include <filename> #include „filename” #define Textersatz

75 Ersatztext #define Name Ersatztext #define sqr(x) x*x a = 2;
c = sqr(a); → c = a*a; /* c wird 4 sein */

76 Ersatztext #define sqr(x) x*x a = 2; b = 3;
c = sqr(a+b); → c = a+b*a+b; /* c wird 2+3*2+3=11 sein */ #define sqr(x) (x)*(x) c = sqr(a+b); → c = (a+b)*(a+b);

77 Ersatztext #define sqr(x) (x)*(x) a = 1; b = 2;
c = 9/sqr(a+b); → c = 9/(a+b)*(a+b); /* c wird 9/3*3=9 sein */ #define sqr(x) ((x)*(x))

78 Ersatztext #define ab(x) (x<0)?(-x):(x) #define max(a,b)
(a)>(b)?(a):(b)

79 Strukturen eine Ansammlung von einer oder mehrerer Variablen (auch mit verschiedenen Typen) unter einem einzigen Namen zusammenfassen struct point { double x; double y; };

80 Strukturen das reservierte Wort struct steht am Anfang
Strukturvereinbarung – Liste von Deklarationen Etikett – hier point Etikett ist für Abkürzung für den Teil der Vereinbarung in geschweiften Klammern

81 Strukturen struct point pt;
deklaration eine Variable pt, die eine Struktur vom Typ struct point ist. Initialisieren von Strukturen struct point pt1 = {100,200};

82 Strukturen Verweis auf eine Komponente einer bestimmten Struktur
Struktur-Variablenname.Komponente struct point pt; pt.x = 150.5;

83 Rekursion #include <stdio.h> void printzahl(int zahl) {
if (zahl<0){ putchar('-'); zahl = -zahl; } if (zahl/2) printzahl(zahl/2); putchar(zahl % 2 +'0'); } int main() { int i = 32; printzahl(i); printf("\n"); return 0;

84 Argumente aus der Kommandozeile
Wenn main aufgerufen wird, werden zwei Argumente Übergeben argc für argument count argv für argument vector argv[0] der Programmname argv[1] das erste Argument argv[argc-1] das letzte Argument hat argc den Wert 1, gibt es keine Argumente auf der Kommandozeile

85 #include <stdio.h>
int main(int argc,char *argv[]) { int i,j; for (i=1;i<argc;i++) { j=0; while(argv[i][j])putchar(argv[i][j++]+'A'-'a'); } return 0;