Programmieren in C - IKP, TU Darmstadt

Programmieren in C
Programmierkurs
Aufbau
1. Historisches und Grundlagen
ƒ
ƒ
ƒ
ƒ
Entwicklung von Computern
Prozessorarchitekturen
Programmiersprachen
Ein einfaches Programm
2. Rechnen, Bedingungen,
Schleifen
ƒ
ƒ
ƒ
ƒ
Operatoren
if…else…then
for
while – do…while
3. Zeichen, Zeichenketten,
Zeiger, Strukturen
ƒ
ƒ
ƒ
ƒ
Strings
Was ist ein Pointer?
Strukturen/Unions
Typen
19.08.2010 | FP 5 | Kernphysik | M. Platz | 2
4. Strukturiertes Programmieren
ƒ
ƒ
Symbolische Konstanten, Makros,
Header
ObjektDateien/Bibliotheken/Linker
5. Spezialitäten
ƒ
ƒ
ƒ
ƒ
Variable Argumentenliste
Dynamischer Speicher
Rekursion
Zeiger auf Funktionen
Tag 1
Historisches und Grundlagen
Entwicklung der Rechner
ƒ Rechenhilfen
ƒ Abacus
ƒ Rechenschieber …
ƒ Programmierbare Maschinen
ƒ Webstühle (1745)
ƒ Klavier…
ƒ Programmierbarer Rechner
ƒ Nutzung eines Zwischenergebnisses für weitere Rechenoperationen
ƒ Speicher
ƒ Rechnervarianten
ƒ Digital
ƒ Analog
19.08.2010 | FP 5 | Kernphysik | M. Platz | 4
Zuse Z1
ƒ Baujahr: 1937
ƒ Elektro-Mechanisch (Binär)
ƒ Ein-/Ausgabewerk
ƒ Rechenwerk
ƒ Speicherwerk
ƒ Programmwerk
ƒ Harvard-Architektur
19.08.2010 | FP 5 | Kernphysik | M. Platz | 5
Eniac
ƒ Baujahr: 1942
ƒ Röhren (Binär)
ƒ Rechnung im Dezimalsystem!
ƒ Kein Befehlsspeicher: Verkabelt
ƒ Später umgebaut auf von-Neumann-Architektur
19.08.2010 | FP 5 | Kernphysik | M. Platz | 6
Algebra
ƒ Bool‘sche Algebra
ƒ George Bool, englischer Mathematiker
ƒ Mathematical Analysis of Logic (1847)
ƒ Logik (Wahr/Falsch, 0/1)
ƒ Dual-System
ƒ Rechnen wie im Dezimalssystem
And:
1101
0011
0001
1101
0011
1111
Or:
8 4 2 1
+
1101 =13
0011 =3
10000
-
1101
0011
1010
19.08.2010 | FP 5 | Kernphysik | M. Platz | 7
1101
0011
Excl.Or: 1110
1101 * 0011
0000
0000
1101
1101
+
100111
1101
___________
Not:
0010
1101 : 0011 = 0100
0011
0011
-0000
0011
0011 + Rest 1
Grundlegender Aufbau einer CPU
ƒ Aufbau eines „typischen“ Computerprozessors (Z80 von Zilog)
ƒ Von-Neumann-Architektur
ƒ Recheneinheit (ALU)
ƒ Register
ƒ Adress-Bus
Instruction
ƒ Daten-Bus
Decoder
Data Bus
Interface
Instruction
Register
Data Bus
ALU
Register
Array
Address Bus
Address Logic
and Buffers
19.08.2010 | FP 5 | Kernphysik | M. Platz | 8
Register
ƒ Speicherstellen in der CPU
ƒ Schnellerer Zugriff als auf RAM über den Daten-/Adressbus
ƒ Teilweise bestimmte Funktionalität
A
F
A‘ F‘
B
C
B‘ C‘
D
E
D‘ E‘
H
L
H‘ L‘
IX
IY
SP
PC
I
19.08.2010 | FP 5 | Kernphysik | M. Platz | 9
R
Typisches Program
CD91BD
3F
C8
F20CA0
3E01
B7
C9
E5
1153A0
010500
EDB0
E1
…
NEWSQR CALL SGN
CCF
RET Z
JP P,GOON
LD A,1
OR A
RET
GOON PUSH HL
LD DE, STORE1
LD BC, 5
LDIR
POP HL
-> Hochsprache wünschenswert
19.08.2010 | FP 5 | Kernphysik | M. Platz | 10
Schnelle Funktion zum ziehen
der Quadratwurzel,
Brückmann, Englisch, Gerits, Steigers,
„CPC Intern“
Gängige Sprachen
ƒ Fortran (1954/1957, IBM)
ƒ BASIC (Beginner‘s All-Pupose Symbolic Instruction Code; 1964)
ƒ Pascal (1972, ETH Zürich, Lehrsprache)
ƒ C (Anfang 70er, Bell Labs, Unix)
ƒ C++ (Anfang 80er, AT&T)
ƒ Java (Anfang 90er, SUN)
19.08.2010 | FP 5 | Kernphysik | M. Platz | 11
Übersetzen einer Hochsprache
ƒ Interpreter
ƒ Schrittweise Syntax-Überprüfung, Übersetzung und Ausführung des
Programms (Scripte)
ƒ Compreter
ƒ Vollständige Syntax-Überprüfung und teilweise Übersetzung während der
Ausgabe, schrittweise endgültige Übersetzung während der Ausführung, oder
ƒ Schrittweise Syntax-Überprüfung und Übersetzung während der Ausführung,
wenn das Programm nicht mehr geändert wird, liegt es in Übersetzter Form
vor
ƒ Compiler
ƒ Syntax-Überprüfung und Übersetzung vor der Ausführung
19.08.2010 | FP 5 | Kernphysik | M. Platz | 12
Konventionen (Namen)
ƒ Namen (Variable)
ƒ Folge von Buchstaben und Ziffern
ƒ Erstes Zeichen Buchstabe (_ zählt als Buchstabe)
ƒ Beliebig lang
ƒ Die ersten 6 Zeichen werden unterschieden
ƒ Anmerkung:
ƒ Implementierungen dürfen auch mehr Zeichen als relevant betrachten
ƒ Interne Name sind umfassender
ƒ Wenigstens 31 Zeichen werden unterschieden
ƒ Case-Sensitiv
19.08.2010 | FP 5 | Kernphysik | M. Platz | 13
Konventionen (Schluesselworte)
ƒ Reservierte Worte (Schlüsselworte)
ƒ Anweisungen, Typen, Speicherklassen, Attribute
ƒ Sehr eingeschränkter Befehlssatz -> "Maschinennah"
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
19.08.2010 | FP 5 | Kernphysik | M. Platz | 14
Konventionen (Konstanten)
ƒ Konstanten
ƒ Ganzzahlige Konstanten
ƒ Zifferfolge (zunächst Dezimal)
ƒ Präfix 0x: Hexadezimal Æ 0xAF, 0Xaf
ƒ Präfix 0 (Null): Oktal Æ 072, 023
ƒ Suffix u: unsigned Æ 1234u
ƒ Suffix l: long Æ 12l
ƒ Zeichenkonstanten
ƒ Werden in einfachen Anführungszeichen (') angegeben Æ ('a')
ƒ Liefert den numerischen Wert des Zeichens im Zeichensatz der jeweiligen
Maschine, auf der das Programm ausgeführt wird
ƒ Möglich sind Definitionen von "wide character constants" (Präfix L)
ƒ Fliesskomma Konstanten
ƒ 1000.50 ; 1.0/100.0 ; 10E20
ƒ Suffix f: float
ƒ Suffix l: long double
ƒ Aufzählungen
ƒ Ganzzahlige Konstanten (s. enum)
19.08.2010 | FP 5 | Kernphysik | M. Platz | 15
Konventionen (Strings)
ƒ Konstante Zeichenketten
ƒ Strings; Zeichenketten in Anführungszeichen ("…") angegeben
ƒ Statischer Vektor
ƒ Änderungsversuche undefiniert
ƒ NUL ('\0') Terminiert
ƒ Präfix L: wide character string
19.08.2010 | FP 5 | Kernphysik | M. Platz | 16
Konventionen (Operatoren)
ƒ Operatoren
ƒ
ƒ
ƒ
ƒ
ƒ
Rechenoperationen, Zuweisung
Vergleiche
Bitmanipulation
Adressoperatoren
Sonstiges
+
-
*
++
/
--
%
==
&&
||
!
<
<=
>
>=
!=
|
<<
>>
~
&
^
&
*
?:
,
=
*=
+=
-=
/=
%=
<<=
>>=
&=
19.08.2010 | FP 5 | Kernphysik | M. Platz | 17
~=
|=
Syntax
#Präprozessoranweisung
Typ Name;
Typ Name=…;
Typ Name (Typ Name …)
{
Typ Name=…;
Typ Name, Name;
…
#
Präprozessoranweisung
Anweisung;
#
Präprozessoranweisung
Anweisung;
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 18
Präprozessoranweisungen können an
beliebigen Stellen stehen, # aber in
der ersten Spalte, kein ';' am Ende
der Zeile!
Blöcke strukturieren den Code
Deklarationen und Definitionen auf
allen Ebenen möglich, aber nur
innerhalb des Blocks gültig. Müssen
vor den ersten Anweisungen stehen.
Anweisungen, wie auch Deklarationen,
enden mit ';'
Hello World / Hinweise
#include <stdio.h>
#include <stdio.h>
#include <stdio.h>
main #include
()
<stdio.h>
main (void)
{ void #include
<stdio.h>
{ /* printf ("Hello World\n");
int main
main (int
(int argc
argc,[,char
char
{
int
char*argv,
*argv[]
[, *envp)
char *envp[]]])
printf
("Hello
World\n");
}
int main
(argc,
argv,
envp)
printf
("Hello
World\n");
} */
int argc;
return
1;
char *argv;
} main (int
int
argc, char *argv, char *envp)
char *envp;
{
{
printf ("Hello World\n");
printf ("Hello World\n");
return (1);
return 1;
}
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 19
Hello World
#include <stdio.h>
Präprozessor Befehl "Datei einbinden".
main ()
{
printf ("Hello World\n");
}
Hauptfunktion; Hier fängt die
Programmausführung an.
Diese Art der Definition
schaltet die Überprüfung der
Argumentenliste ab, es wird
kein Rückgabewert erwartet.
Funktionsaufruf; Deklaration in
"stdio.h" (Standardbibliothek).
19.08.2010 | FP 5 | Kernphysik | M. Platz | 20
Compilieren (Linux)
GNU C-Compiler (gcc):
benutzer@rechner:~$ gcc <C-File> -o <Ausgabedatei>
Genaue Überprüfung des C-Standards:
benutzer@rechner:~$ gcc –Wall <C-File> -o <Ausgabedatei>
hello_world.c:4: warning: return type defaults to 'int'
hello_world.c: In function 'main':
hello_world.c:6: warning: control reaches end of non-void function
19.08.2010 | FP 5 | Kernphysik | M. Platz | 21
Aufgaben
ƒ Versuchen, die Fehler zu entfernen
ƒ Mehrere
hintereinander
ausführen
printf,printf-Anweisungen
fprintf, sprintf, snprintf,
vprintf, vfprintf,
vsprintf, und die
vsnprintf - formatted output conversion
Ausgabe interpretieren.
SYNOPSIS
ƒ Benutzung
von<stdio.h>
Steuerzeichen (was bedeutet was?):
#include
ƒ \a, \b, \f,
\n, \r, \t, \v, \? ,\ooo,\xhhh
int printf(const char *format, ...);
fprintf(FILE\',
*stream,
ƒ Escape int
Sequenzen:
\",\\ const char *format, ...);
int sprintf(char *str, const char *format, ...);
int printf
snprintf(char
*str, size_t size, const char *format,
ƒ Mehr über
(benutzer@rechner:~$
man 3...);
printf)
#include <stdarg.h>
int
int
int
int
vprintf(const char *format, va_list ap);
vfprintf(FILE *stream, const char *format, va_list ap);
vsprintf(char *str, const char *format, va_list ap);
vsnprintf(char *str, size_t size, const char *format, va_list ap);
DESCRIPTION
19.08.2010 | FP 5 | Kernphysik | M. Platz | 22
Tag 2
Rechnen, Bedingungen, Schleifen
Rechnen
Addition
i = a + b;
i = i + x;
i += x;
Subtraktion
i = a – b;
i = i – x;
i -= x;
Multiplikation
i = a * b;
i = i * x;
i *= x;
Division
i = a / b;
i = i / x;
i /= x;
Inkrementieren
i = i + 1;
i += 1;
i ++;
++i;
Dekrementieren
i = i – 1;
i -= 1;
i --;
--i;
Modulo
i = a % b;
i = i % x;
i %= x;
19.08.2010 | FP 5 | Kernphysik | M. Platz | 24
Vergleiche
ƒ Alle Vergleiche geben einen Boolschen Wert zurück.
ƒ Der Typ BOOL ist in der Regel Betriebssystemabhängig und in
<stddef.h> definiert
ƒ Ist der Typ BOOL vorhanden, gibt es auch die symbolischen
Konstanten
ƒ FALSE
ƒ TRUE (! FALSE d.h alles ungleich FALSE)
ƒ Ist bei einem Vergleich Gleichheit festgestellt, ist das Ergebnis
TRUE, sonst FALSE
ƒ Für bedingte Code-Ausführung wird die if-else-Anweisung
benutzt
19.08.2010 | FP 5 | Kernphysik | M. Platz | 25
If-Else
#include <stdio.h>
main()
{
char c;
Bedingung
c = getchar(); {
if (c == ' '){
printf ("War ein SPACE\n");
}
else {
printf ("%c\n", c);
}
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 26
Ausführung
wenn TRUE
Ausführung
wenn FALSE
Vergleichsoperatoren
AND
&&
Ungleichheit
!=
OR
||
Größer
>
NOT
!
Kleiner
<
Größer Gleich
>=
Kleiner Gleich
<=
Gleichheit
==
19.08.2010 | FP 5 | Kernphysik | M. Platz | 27
Weitere Möglichkeit
ƒ Operator ?:
Bedingung
#include <stdio.h>
#include <stdio.h>
Zuweisung wenn
wahr
main()
{
if (a > b)
{
z = a;
}
else
{
z = b;
}
main()
{
z = (a > b) ? a : b;
}
Zuweisung wenn
falsch
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 28
Vorrang
#include <stdio.h>
main()
{
}
#include <stdio.h>
main()
if (y = a > b ||
{ a == 100 && b !=
{
if ((y = a
z = a;
{
}
z
else
}
{
else
z = b;
{
}
z
}
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 29
0)
> b) || ((a == 100) && (b != 0))
= a;
= b;
Schleifen
ƒ Wiederholung einer bestimmten Funktionalität
ƒ Kriterium für das Schleifenende
ƒ Anzahl der Durchläufe
ƒ Bestimmte Bedingungen sind erfüllt
ƒ Die Sprache C bietet zwei Schleifentypen
ƒ for-Schleife
ƒ In der Regel wird diese Schleife bei einer definierten Anzahl von
Durchläufen benutzt
ƒ while-Schleife bzw. do-while Kombination
ƒ Wird in der Regel für Schleifen benutzt, die durch Erfüllung von
Bedingungen beendet werden
ƒ Beide Schleifentypen sind prinzipiell austauschbar!
19.08.2010 | FP 5 | Kernphysik | M. Platz | 30
For-Schleife
/*
Umrechnung Fahrenheit in Celsius nach:
°C = (5/9)(F-32)
*/
#include <stdio.h>
Startwert
Abbruchkriterium
main()
{
unsigned int iF;
Operation nach einem
Schleifendurchgang
for (iF=0; iF<=300; iF = iF + 20)
{
printf ("%3d %6.1f\n", iF, (5.0/9.0)*(iF-32));
}
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 31
Intermezzo zu Variablen
ƒ Deklaration
ƒ Festlegen, um welchen Typ es sich handelt (kommt später)
ƒ Definition
ƒ Typ festlegen und Speicher reservieren
ƒ Initialisieren
ƒ Der definierten Variablen einen Wert zuweisen
{
{
int i; // Definition
int i = 0; /* Definition
und
Initialisierung*/
…
i = 0; // Initialisierung
…
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 32
}
Aufgaben (for-Schleife)
ƒ Was passiert, wenn die Schleifenvariable nicht initialisiert wird
ƒ Was passiert, wenn man (5.0/9.0) durch (5/9)
ƒ Was kann man bei der for-Schleife alles weglassen?
ƒ Kann die Schleifenvariable auch andere Typen haben (double,
long)?
19.08.2010 | FP 5 | Kernphysik | M. Platz | 33
While-Schleife
/*
Umrechnung Fahrenheit in Celsius nach:
°C = (5/9)(F-32)
*/
#include <stdio.h>
Abbruch Kriterium
main()
{
unsigned int iF = 0;
Initialisierung und
Inkrementierung an einer
anderen Stelle
while (iF<=300)
{
printf ("%3d %6.1f\n", iF, (5.0/9.0)*(iF-32));
iF+=20;
}
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 34
Do-While-Schleife
/*
Umrechnung Fahrenheit in Celsius nach:
°C = (5/9)(F-32)
*/
#include <stdio.h>
main()
{
unsigned int iF = 0;
In dieser Kombination
muss ein ';' am Ende der
Schleife stehen!
do
{
printf ("%3d %6.1f\n", iF, (5.0/9.0)*(iF-32));
iF+=20;
}
while (iF<=300);
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 35
Aufgaben (while-Schleife)
ƒ Tabelle von "unten" nach "oben" ausgeben
ƒ In der Ausgabe noch eine Index (1.) anfügen
ƒ Ausgabe einer Tabelle Celsius -> Fahrenheit
ƒ Unterschied bei der Definition signed, unsigned?
19.08.2010 | FP 5 | Kernphysik | M. Platz | 36
Continue Anweisung
ƒ Nur gültig in Schleifen
ƒ Durch diesen Aufruf wird der Programmablauf am Anfang der
Schleife fortgesetzt
for (i=0; i<10; i++)
{
if (irgendeine Komische Bedingung)
{
continue;
}
….
}
Ähnlich zur goto-Anweisung; wird bei klarer Programmierung nicht gebraucht !
19.08.2010 | FP 5 | Kernphysik | M. Platz | 37
Break-Anweisung
ƒ Beendet die übergeordnete Schleife
while (TRUE)
{
if (irgendeine Komische Bedingung)
{
break;
}
….
}
Oft durch ein sinnvolles Abbruchkriterium der Schleife vermeidbar;
Bei höheren Verschachtelungsstufen kann es undurchsichtig sein!
19.08.2010 | FP 5 | Kernphysik | M. Platz | 38
Aufgaben
ƒ Die ersten 100 Primzahlen berechnen lassen
ƒ Eine Primzahl ist eine natürliche Zahl mit genau zwei natürlichen
Zahlen als Teiler, nämlich der Zahl 1 und sich selbst
ƒ Optimieren
ƒ 2k + 1
19.08.2010 | FP 5 | Kernphysik | M. Platz | 39
Switch - case
ƒ switch-case Anweisungen erlauben die Auswahl aus mehreren Alternativen
ƒ In switch() wird der zu testende Wert angegeben
ƒ case legt Marken fest, an denen die Programmausführung fortgesetzt wird,
wenn der in der Marke angegebene konstante Wert mit dem in der switch()Anweisung übereinstimmt
char c;
Wert von Interesse
c = getchar ();
switch (c)
Konstante
{
Auszuführender Code
case '\r':
case '\t':
Abruch der switch()-Anweisung
case ' ':
printf ("Whitespace\n");
break;
default:
printf ("Zeichen");
break;
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 40
Optionaler Ausdruck; Wenn
keine case-Anweisung
zutreffend ist, wird die
Ausführung hier fortgesetzt
Tag 3
Zeichen, Zeichenketten, Zeiger, Strukturen
Zeichen
ƒ Type für Zeichen: char
ƒ Die tatsächliche Bit-Breite eines Typs ist nicht im C-Standard
definiert, sondern systemabhängig
ƒ Definition des Wertebereiches in limits.h (/usr/include/limits.h)
ƒ In der Regel 8-Bit breit, Wertebereich -128 – 127
ƒ Gibt in der Regel den Code eines Zeichens im ASCII Standard
an
ƒ ASCII Standard enthält 128 Zeichen (33 Steuerzeichen, 95 druckbare
Zeichen)
Anmerkung: Auch die anderen Typen haben keine definierte Breite (oder Aufbau).
19.08.2010 | FP 5 | Kernphysik | M. Platz | 42
Aufgaben
ƒ ASCII Tabelle der Druckbaren Zeichen ausgeben (ab Zeichen
32)
ƒ Zeichen von 32 bis 255 ausgeben
ƒ Zeichensatz ändern und Programm erneut ausführen
ƒ ASCII Codes der Steuerzeichen aus der prinf()-Anweisung
ausgeben
19.08.2010 | FP 5 | Kernphysik | M. Platz | 43
Zeichenketten
ƒ Array aus Zeichen, letztes Zeichen '\0'
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
main()
{
char szString_1[16];
char szString_2[] = "Hello World";
char szString_3[] = {'H','e','l','l','o',' ','W','o','r','l','d','\0'};
strcpy (szString_1, szString_2);
if (! strcmp (szString_1, szString_3))
{
printf ("Gleich\n");
}
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 44
Array
char szString[] = "Hello World";
Startadresse
… 'H' 'e'
'l'
'l'
0xAF00
Index
0
1
'o'
' ' 'W' 'o'
'r'
'l'
'd' '\0' …
0xAF0B
2
…
11
char c;
int iAddress;
c = szString[2]; // c enthält jetzt 'l'
iAddress = szString; /* iAddress enthält jetzt
die Adresse des Strings im
Arbeitsspeicher (0xAF00)*/
19.08.2010 | FP 5 | Kernphysik | M. Platz | 45
Aufgaben
ƒ Definition von strcpy() und strcmp() nachschlagen
ƒ Inhalt des uninitialisierten char-Arrays ausgeben
ƒ Inhalt des initialisierten char-Arrays ausgeben
ƒ String in ein zu kleines Array kopieren
ƒ Länge des Strings bestimmen
19.08.2010 | FP 5 | Kernphysik | M. Platz | 46
Pointer
ƒ Zeiger auf einen Speicherbereich (Adresse)
Inhaltsoperator
#include <stdio.h>
main()
{
char *pcTest;
Der Zeiger hat immer die für
das laufende System
benötigte Bit-Breite, um eine
Adresse zu speichern (32-Bit
System Î 32 Bit).
printf ("Adresse der Variablen: %4x\n", pcTest);
printf ("Inhalt der Variablen: %i\n", *pcTest); //Uninitialisiert
/*
Werte Zuweisung
*/
Für den Inhalt des Pointers
*pcTest = 'T';
}
Soll mehr als ein Zeichen gespeichert werden,
muss der entsprechende Speicher reserviert werden
19.08.2010 | FP 5 | Kernphysik | M. Platz | 47
wird die Bit-Breite reserviert,
die durch die Definition
gegeben ist (hier char).
Arbeiten mit Adressen
char szString_1[16];
char szString_2[] = "Hello World";
/* Definition von strcpy:
Startadresse
char* strcpy (char *str1, char *str2); */
strcpy (szString_1, szString_2);
… 'H' 'e'
'l'
'l'
'o'
' ' 'W' 'o'
'r'
'l'
0xAF00
Address-Operator
'd' '\0' …
0xAF0B
char szString_2[] = "Hello World";
char *pstrString_3;
char *pstrWorld;
pstrString_3 = szString_2;
pstrWorld = &szString_2[6];
19.08.2010 | FP 5 | Kernphysik | M. Platz | 48
Aufgaben
ƒ Arbeiten mit Pointern
ƒ Zuweisen von Adressen
ƒ Beispiel von vorheriger Folie in lauffähiges Programm umsetzen
ƒ Benutzung des Inhaltsoperator (*) zum Zugriff auf Speicherstellen
ƒ Mit Hilfe von Pointer den Inhalt des Arrays ausgeben
19.08.2010 | FP 5 | Kernphysik | M. Platz | 49
Strukturen
ƒ Zusammenfassung zusammengehörender Daten
ƒ Z.B. Punkt Î Zusammenfassung von x- und y-Koordinate
ƒ Beschreibung von Daten im Adressbereich
ƒ Registermap (z.B. eines Mikrocontrollers - Kurs 3)
struct point
{
int x;
int y;
}
Member
main()
{
struct point pt;
struct point *pPt;
pPt = &pt;
pt.x = 10;
pt.y = 20;
pPt->x = 10;
…
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 50
Auswahl des Members
Unions
ƒ Möglichkeit zur Speicherung unterschiedlicher Datentypen in
einem Speicherbereich
ƒ Der Compiler überwacht die Größe des Speicherbereichs.
ƒ Zugriff auf den falschen Datentyp sind implementierungsabhängig
ƒ Zugriff gleich zu Strukturen
union number
{
int iNum;
double dbNum;
char szNum[16];
}
main()
{
union number Number;
Number.iNum = 1;
/*
geht nicht:
Number.szNum = 1;
Geht:
strcpy (Number.szNum, "1");
*/
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 51
Typen
ƒ Neue (eigene) Typen werden definiert mit typedef
typedef unsigned char BYTE;
typedef struct point
{
int x;
int y;
}
POINT;
Void funktion (void)
{
BYTE by;
POINT pt;
…
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 52
Typ Definition
Typ Name
Funktionsaufrufe
ƒ Eine Funktion kann erst aufgerufen werden, wenn sie deklariert
wurde
ƒ Funktionsargumente (Inhalt der Variablen) werden vor dem
Aufruf kopiert
ƒ D.h. man kann einen Wert an die Funktion übergeben, bekommt die
Änderung aber nicht durch diese Variable zurück
ƒ Rückgabe von Werten ist nur durch die return-Anweisung möglich
ƒ Diese Einschränkung ist nur durch Pointer zu umgehen
ƒ Werden Pointer als Funktionsparameter benutzt, wird die
Adresse kopiert
ƒ Man greift dann direkt auf den Speicher zu (der Inhalt wird nicht
kopiert!)
ƒ Beim Rücksprung der Funktion bleiben die Änderungen im
Speicherbereich erhalten
19.08.2010 | FP 5 | Kernphysik | M. Platz | 53
Glossar
ƒ Definition
ƒ Festlegen des Typs einer Variablen und Reservierung von Speicher
ƒ Deklaration
ƒ Festlegen des Typs einer Variablen ohne Reservierung des Speichers
ƒ Initialisierung
ƒ Zuweisen des Wertes einer Variablen
ƒ Funktionsargument
ƒ Wert, der dem Funktionsaufruf übergeben wird
ƒ Funktionsparameter
ƒ Variable, die dem Funktionsaufruf übergeben wird
19.08.2010 | FP 5 | Kernphysik | M. Platz | 54
Aufgaben
ƒ Eingabe von Text mit Hilfe von getchar
ƒ Eingegebene Zeile in einem Puffer (Array) speichern
ƒ Einfache Verschlüsselung (Zeichen + Offset)
ƒ Eigene strcpy()-Funktion schreiben
ƒ char *strcpy (char *str1, char *str2);
ƒ Rückgabewert ist Zeiger auf das Ziel
ƒ Eigene strcmp()-Funktion schreiben
ƒ int strcmp (char* str1, char *str2);
ƒ Rückgabewert 0 wenn gleich, sonst kleiner oder größer 0
ƒ Typ "Komplexe Zahl" definieren (a+bi)
ƒ Funktionen zum Rechnen mit komplexen Zahlen schreiben
ƒ Addition: (a+bi) + (c+di) = (a+c) +(b+d)i
ƒ Multiplikation: (a+bi) * (c+di) = (ac – bd) + (ad+bc)i
19.08.2010 | FP 5 | Kernphysik | M. Platz | 55
Tag 4
Strukturiertes Programmieren
Strukturen
char char
int
short
Startadresse
typedef struct beispiel
{
char c1;
char c2;
int i;
short s1;
short s2;
}
19.08.2010 | FP 5 | Kernphysik | M. Platz | 57
short
Strukturiertes Programmieren
ƒ Allgemeine Regeln
ƒ Auf globale Variablen verzichten
ƒ Möglichst kurze und übersichtliche Funktionen
ƒ Sinnvolle Variablen-Namen
ƒ Schwer verständliche Konstrukte vermeiden, auch wenn man es für
genial hält
ƒ Bei größeren Projekten
ƒ Aufteilung des Programms auf mehrere C-Dateien
ƒ Zusammengehörender Code/Variablen in eine Datei
ƒ Möglichkeit eine eigene Bibliothek aufzubauen
ƒ Möglichst gleich dokumentieren
ƒ Kommentare vor den Funktionen, die Funktionalität, Parameter,
Rückgabewerte und Spezialitäten beschreiben.
19.08.2010 | FP 5 | Kernphysik | M. Platz | 58
Präprozessor
ƒ Vorstufe zum Compiler
ƒ Einfügen von Dateien (#include)
ƒ Definition von symbolischen Konstanten und Makros (#define)
ƒ Vordefinierte Makros (__LINE__, __FILE__, __DATE__, __TIME__)
ƒ Bedingungsabhängige Code-Generation (#if, #else, #ifdef, …)
ƒ Erweiterte Compiler-Steuerung (#warning, #error, #pragma)
19.08.2010 | FP 5 | Kernphysik | M. Platz | 59
Präprozessor
#include <stdio.h>
#include "mydef.h"
// Symbolische Konstante
#define MAX_VALUE
255
//Makro
#define ABS(A)
((A < 0) ? –A : A)
void test void (int iValue)
{
#ifdef DEBUG
printf ("Maximal zulässiger Wert: %i\n", MAX_VALUE);
#endif
if (iValue > MAX_VALUE)
{
printf ("Zu gross\n");
}
…
19.08.2010 | FP 5 | Kernphysik | M. Platz | 60
Speicherklassen
ƒ Variablen sind zunächst nur innerhalb des Blocks gültig, in dem
sie definiert wurden.
ƒ Definition ist die Festlegung des Typs und das Reservieren des
benötigten Speichers
ƒ Wird eine Variable in unterschiedlichen C-Dateien benötigt (ist
selten der Fall), darf sie nicht in allen Dateien definiert werden
ƒ Für jede Variable würde Speicher reserviert –> unterschiedliche
Variablen (aber gleicher Name)
ƒ Variable muss in allen Dateien deklariert werden (nur den Typ
festlegen) und in einer Datei definiert.
ƒ Deklaration einer Variablen für die Benutzung in
unterschiedlichen Dateien mit dem Keyword extern
ƒ extern gibt eine Speicherklasse an
19.08.2010 | FP 5 | Kernphysik | M. Platz | 61
Header-Dateien
ƒ Header-Dateien (Endung .h) sind Dateien, in denen i.d.R. keine
Code steht
ƒ Dienen zum
ƒ Deklarieren von Variablen und Funktionen
ƒ Definieren von Makros und Konstanten
ƒ Definieren eigener Typen, Unions
ƒ Werden also benutzt, um Informationen, die in
unterschiedlichen C-Dateien benötigt werden, zentral
zusammenzufassen
Header-Dateien sollten nur gemeinsam genutzte Information enthalten!
19.08.2010 | FP 5 | Kernphysik | M. Platz | 62
Beispiel
test.h
test.c
#ifndef test_h
#define test_h
#include "test.h"
#include "test.h"
/*
…
#include <stdio.h>
/*
Globale Variable, die
in allen Dateien, in
denen test.h
eingebunden wird,
definiert wird
*/
int iVariable;
/*
Hiermit wird nur der
Typ festgelegt, aber
kein Speicher
reserviert.
*/
extern int iGlobal;
#endif
19.08.2010 | FP 5 | Kernphysik | M. Platz | 63
test2.c
Hier wird iGlobal
definiert.
*/
int iGlobal;
…
void test (void)
{
iGlobal = 1;
iVariable = 0;
…;
}
void test2 (void)
{
if (iGlobal == 1)
{
…;
}
// undefiniert
if (iVariable ==
0)
{
;
}
…;
}
Speicherklassen II
ƒ Variablen innerhalb eines Blocks werden ungültig, wenn der
Block verlassen wird
ƒ In seltenen Fällen kann es nötig sein, dass eine Variable den
gespeicherten Wert behalten muss
ƒ Beim erneuten Eintritt in den Block ist die Variable mit dem zuvor
gespeicherten Wert wieder verfügbar
ƒ Dafür dient die Speicherklasse static
ƒ Globale statische Variablen sind nur innerhalb der C-Datei, in der sie
definiert wurden, gültig
19.08.2010 | FP 5 | Kernphysik | M. Platz | 64
Aufgaben
ƒ Benutzung der Speicherklasse static
ƒ Implementierung einer Funktion, die die Anzahl ihrer Aufrufe
protokolliert
19.08.2010 | FP 5 | Kernphysik | M. Platz | 65