Vorlesung 1

• C Sprache

• Algorithmen

• Effektivität von Algorithmen

• Programme specifizieren, Algorithmen zu ausarbeiten, Quelltext generieren, dokumentieren

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.

Elektrotechnik

38 - 44 P. Note 5

32 - 37 P. Note 4

26 - 31 P. Note 3

20 - 25 P. Note 2

Informatik

• Grosse Klausur: es soll einen Note 2 erreicht werden

• Schriftliche Prüfung im Prüfungsperiod

Informatik labor

• 3 kleine Klausur

• Hausaufgabe

• Durchschnitt + od. - 1

• 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

• 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:

– 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)

– 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

– 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

– 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.

#include <stdio.h>

main()

{

printf(”hello, world\n”);

}

#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;

}

• Arithmetische Operatorenbinäre +, -, /, *, %unäre +, -

• Vorrang

arithmetische Operatoren werden von links her zusammenfaßt

• Verbindung von arithmetische Operatorenc = a = d+e;von rechts her

+, - (unären)

*, / , %

+, - (binären)

Datentypen

• 4 elementare Datentypenchar ein Byte, ein Zeichen – Grundelement des

Speichers

int ganzahliger Wert, 16 oder 32 Bits

float ein einfach genauer Gleichpunktwert

double ein doppelt genauer Gleichpunktwert

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

Varianten dieser elementaren Typen

• signed

• unsigned

char oder int (sind ≥ 0)

• Wertebereich

int -32768...32767

unsigned int 0...65535

float 3.4e-38...3.4e+38

double 1.7e-308...1.7e+308

long double 3.4e-4932...1.1e+4932

Konstanten• ganzzahlige Kostante 1234 hat den Typ int• long-Konstante 12345678l oder 12345678L• vorzeichenlose Kostante 456u oder 456U• 5789ul oder 5789UL unsigned long• 036 oktal• 0x36 oder 0X36 hexadezimal• 0XFUL unsigned long mit Dezimalwert 15• Gleitpunktkonstanten 123.4 (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

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

• %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

• float f = 1.23456789;

• printf("f=%f \n",f);

1.234568

• printf("f=%15f \n",f);

1.234568

• printf("f=%-15f \n",f);

1.234568

• printf("f=%.3f \n",f);

1.235

• float f = 123.23456789;

• printf("f=%f \n",f);

123.234566

• printf("f=%3.3f \n",f);

123.235

• printf("f=%15e \n",f);

1.232346e+002

• printf("f=%15.2e \n",f);

1.23e+002

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

• zeile ist ”hello, world” Zeichenketteprintf(”:%s:”,zeile);

:hello, world:printf(”:%10s:”,zeile);

:hello, world:printf(”:%.10s:”,zeile);

:hello, wor:printf(”:%-15s:”,zeile);

:hello, world :printf(”:%15.10s:”,zeile);

: hello, wor:printf(”:%-15.10s:”,zeile);

:hello, wor :

• 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*/

• 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

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 istcos, cosh, exp, fabs, floor(x), größter ganzzahliger Wert, der nicht größer als x istlog, log10, pow, sin, sinh, sqrt, tan, tanh

long a;

float f = 123.9;

a=f;

printf("a=%ld \n",a);

a=123

long a;

float f = 123.9;

f=f-(a=f);

printf("a=%ld \n",a);

printf("f=%15.2e \n",f);

a=123

f= 9.00e+002

Schleifen

• for Schleife

• while Schleifewhile (Ausdruck) Anweisungen

• do while Schleifedo Anweisungenwhile (Ausdruck);

do while Schleife

do Anweisungen

while (Ausdruck);

Anweisung(en)

Ausdruck

Ausdruck ≠ 0

Ausdruck = 0

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);

while Schleife

Ausdruck Ausdruck = 0

Anweisung(en)

Ausdruck ≠ 0

while (Ausdruck) Anweisungen

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};

i = 10; sum = 0;

while (i) { sum=sum+i;i= i-1};

for Schleife

for (init;test;post-expr)

statement;

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.

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 */

a b

Nab

iafdxxfN

i

b

a

/

))1(()(1

#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;}

Bedingter Ausdruck

if (a>b)

z = a;

else

z = b;

z = (a>b)?a:b;

Ausd1?Ausd2:Ausd3

Auch in Form

Zuweisungen und Ausdrücke

i = i+2;

Ausdruck

mit Zuweisungsoperator ( +=)

i += 2;

(+, -, *, /, %, <<, >>, &, |, ^)

#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;}

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)

#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;}

Die switch Anweisung

Es ist eine Auswahl unter mehreren AlternativenUntersucht, ob ein Ausdruck einen von mehreren

Konstanten ganzzahligen Werten besitzt.

switch(Ausdruck){case const-Ausdruck1:Anweisung1case const-Ausdruck2:Anweisung2default : Anweisung3}

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”);

}

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

Funktionen und Programmstruktur

FunktionsdefinitionFunktionstyp Funktionsname(Parameterdeklarationen){Vereinbarungen und Anweisungenreturn Ausdruck}

return-Anweisung liefert einen Wert als Resultat von der aufgerufenen Funktion zum Aufrufen

double addiert(double a, double b)

{

return a+b;

}

void ausschreibt(double a)

{

printf(”%lf ”,a);

} /*Funktion ohne Ausgangswert*/

#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) { 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);}

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; }

#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; }

#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;}

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;

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]

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]

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;

Zeigern als Funktionsargumente

void tausch(int *px,int *py){ int temp; temp = *px; *px = *py; *py = temp;}in main() Funktiontausch(&a,&b);

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;}

Char Zeiger

”konstante Zeichenkette”

das ist ein Zeichenvektor

der Vektor wird mit dem Nullzeichen ‘\0’ beendet

char *Zeichenzeiger;

Zeichenzeiger = ”Hallo”;

char Zeichenpuffer[] = ”Hallo”;

Zeichenzeiger:

H a l l o \0 Zeichenzeiger:

·

·

Zeichenpuffer: H a l l o \0

Char Zeiger

int strlen(char *c){int n;for(n = 0;*s!=‘\0’;s++) n++;return n;}

int main(){printf(”%d”,strlen(”Guten Tag”);

Char Zeigerint 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);

void strcpy(char *s,char *t)

{int i = 0;while (t[i]!=‘\0’) {s[i]=t[i];i++;}

s[i]=t[i];

}

void strcpy(char *s,char *t)

{int i = 0;while ((s[i]=t[i])!=‘\0’) i++;

}

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;

Präzedenz und BindungEnglisch: „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

C preprozessor

# include Definitionsdatei einfügen

#include <filename>

#include „filename”

#define Textersatz

Ersatztext

#define Name Ersatztext

#define sqr(x) x*x

a = 2;

c = sqr(a); → c = a*a;

/* c wird 4 sein */

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);

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))

Ersatztext

#define ab(x) (x<0)?(-x):(x)

#define max(a,b) (a)>(b)?(a):(b)

Strukturen

• eine Ansammlung von einer oder mehrerer Variablen (auch mit verschiedenen Typen)

• unter einem einzigen Namen zusammenfassen

struct point {double x;double y;};

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

Strukturen

struct point pt;

•deklaration eine Variable pt, die eine Struktur vom Typ struct point ist.

•Initialisieren von Strukturen

struct point pt1 = {100,200};

Strukturen

•Verweis auf eine Komponente einer bestimmten Struktur

Struktur-Variablenname.Komponente

struct point pt;

pt.x = 150.5;

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;}

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

#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;}