¨Ubungspaket 14 Eindimensionale Arrays

Übungspaket 14
Eindimensionale Arrays
Übungsziele:
Deklaration und Verwendung eindimensionaler Arrays
Skript:
Kapitel: 33
Semester:
Wintersemester 2017/18
Betreuer:
Kevin, Theo, Thomas und Ralf
Synopsis:
Nach dem wir nun die wesentlichen Datentypen kennengelernt haben,
kommt etwas neues dazu; die eindimensionalen Arrays. Mit Arrays
kann man mehrere Variablen gleichen Typs zusammenfassen, so wie
wir es aus der Mathematik in Form von Vektoren, (indizierten) Koeffizienten und dergleichen kennen.
Teil I: Stoffwiederholung
Aufgabe 1: Aufbau eines eindimensionalen Arrays
Aus welchen Komponennten besteht eine Array-Definition (ohne Initialisierung)?
1. Elementtyp
2. Array-Name
3. Eckige Klammern []
4. Array-Größe (innerhalb der [])
Aufgabe 2: Array-Größe und gültige Indizes
Nehmen wir an, wir hätten ein Array der Größe n (eines mit n Elementen), wobei n stellvertretend für eine ganzzahlige Konstante wie beispielsweise 14 ist.
Frage: Was sind die gültigen Indizes? 0 .. n-1
Aufgabe 3: Speicherbelegung
Wie viele Bytes belegt ein Array mit n Elementen mindestens im Arbeitsspeicher (RAM),
wenn der Elementtyp genau b Bytes belegt? n × b Bytes
Skizziere ein Array a mit 6 Elementen vom Typ int unter der Annahme, dass ein int
genau 4 Bytes belegt und die Startadresse des Arrays 0x1000 ist.
Definition: int a[ 6 ];
Adresse
0x1018
0x1014
0x1010
0x100C
0x1008
0x1004
0x1000
14-1
Variable
a[
a[
a[
a[
a[
a[
5
4
3
2
1
0
]
]
]
]
]
]
Typ
Größe
int
int
int
int
int
int
4 Bytes
4 Bytes
4 Bytes
4 Bytes
4 Bytes
4 Bytes
Wintersemester 2017/18, Einführung in die Praktische Informatik
Teil II: Quiz
Aufgabe 1: Standard“ Arrays
”
Gegeben seien die folgenden vier Definitionen:
1.
2.
3.
4.
int
char
double
int
a[
b[
c[
d[
3
4
2
1
];
];
];
];
Welche Indizes sind bei den jeweiligen Arrays erlaubt und welche Werte haben die ArrayElemente unmittelbar nach der Definition?
Array
a
b
c
d
Indizes
Werte
0, 1, 2
nicht initialisiert
0, 1, 2, 3 nicht initialisiert
0, 1
nicht initialisiert
0
nicht initialisiert
Aufgabe 2: Implizit definierte Arrays
Die Größe eines Arrays kann man auch implizit“ durch eine zusätzliche Initialisierung
”
definieren. Gegeben seien die folgenden vier Definitionen:
1.
2.
3.
4.
int
int
double
double
e[]
f[]
g[]
h[]
=
=
=
=
{
{
{
{
3, 4, 5 };
-1, -3 };
, , 23.0, };
-3,0 , , 2.0 };
Welche Größen haben die Arrays, welche Indizes sind jeweils erlaubt und welche Werte
haben die einzelnen Elemente unmittelbar nach der Definition?
Array
Größe
e
f
g
h
3
2
4
4
Indizes
Werte
0,
0,
0,
0,
3, 4, 5
-1, -3
n.i., n.i., 23.0, n.i.
3.0, 0.0, n.i., 2.0
1, 2
1
1, 2, 3
1, 2, 3
n.i. =
ˆ nicht initialisiert
Einführung in die Praktische Informatik, Wintersemester 2017/18
14-2
Teil III: Fehlersuche
Aufgabe 1: Arbeiten mit mehreren Zahlen
Das folgende Programm soll zehn Zahlen einlesen und in einem Array ablegen, anschließend
die Summe ausrechnen und diese am Ende ausgeben. Leider hat Dr. One-Neuron wieder
diverse Fehler gemacht, die ihr finden und korrigieren sollt.
1 # include < stdioh >
2
3 # define N =10
4
5 int man ( int argc , char ** argv )
6
{
7
int i , sum , a [ N ];
8
for ( i = 0 , i < N , i = i + 1 )
9
{
10
printf ( Bitte Wert fuer a [ % d ] eingeben : , i ) ;
11
scanf ( " % d " , & ( a [ ] ) ) ;
12
}
13
for ( i = 1; sum = 0; i <= N ; i = i + 1 )
14
sum = sum + a { i };
15
printf ( " Die Summe der Zahlen betraegt % d \ n " , N , sum ) ;
16
}
Zeile
Fehler
Erläuterung
Korrektur
1
. fehlt
Der Name der Datei ist stdio.h
<stdio.h>
3
= zu viel
Die #define-Direktive hat zwei Argumente“, erst das, #define
”
was definiert werden soll, und dann die eigentliche De- N 10
finition; ein = ist hier nicht erlaubt.
..............................................................................................................................................
..............................................................................................................................................
5 Tippfehler:
man
Das Hauptprogramm heißt nicht man() sondern
main().
main
Die einzelnen Teile der for-Anweisung werden mittels
Semikolons getrennt.
for( ...;
...; ...)
..............................................................................................................................................
8
, statt ;
..............................................................................................................................................
10
" fehlen
Die Texte in der Ausgabeanweisung müssen in Gänse- "..."
füßchen eingeschlossen sein.
..............................................................................................................................................
11 Index i fehlt
14-3
Beim Zugriff auf die einzelnen Arrayelemente muss der
jeweilige Index angegeben werden.
a[ i ]
Wintersemester 2017/18, Einführung in die Praktische Informatik
Zeile
13
Fehler
Erläuterung
Korrektur
; statt ,
Werden bei der for-Anweisung in einem der drei Teile i = 1,
mehr als ein Ausdruck verwendet, müssen diese unter- sum = 0
einander mit Kommas getrennt werden.
..............................................................................................................................................
13/14 Laufindex
Da in Zeile 14 auf die Array-Elemente direkt mittels i = 0
a[ i ] zugegriffen wird, muss der Laufindex i von 0 i < N
bis N-1 laufen.
..............................................................................................................................................
14
{} statt []
Beim Zugriff auf die einzelnen Elemente eines Arrays a[ i ]
müssen eckige Klammern verwendet werden.
..............................................................................................................................................
15
N, zu viel
Der Parameter N ist zu viel.
", sum );
Programm mit Korrekturen:
1 # include < stdio .h >
2
3 # define N
10
4
5 int main ( int argc , char ** argv )
6
{
7
int i , sum , a [ N ];
8
for ( i = 0; i < N ; i = i + 1 )
9
{
10
printf ( " Bitte Wert fuer a [ % d ] eingeben : " , i ) ;
11
scanf ( " % d " , & ( a [ i ] ) ) ;
12
}
13
for ( i = 0 , sum = 0; i < N ; i = i + 1 )
14
sum = sum + a [ i ];
15
printf ( " Die Summe der % d Zahlen betraegt % d \ n " ,N , sum ) ;
16
}
Einführung in die Praktische Informatik, Wintersemester 2017/18
14-4
Teil IV: Anwendungen
Aufgabe 1: Deklaration einfacher Arrays
Die folgende Übungsaufgabe ist nicht wirklich sinnvoll, sondern dient hauptsächlich dem
Einüben des Hantierens mit eindimensionalen Arrays.
1. Aufgabenstellung
Ziel der Aufgabe ist es, ein Programm zu erstellen, das folgende Arrays enthählt:
1. ein Array mit 10 Elementen vom Typ int,
2. ein Array mit
3 Elementen vom Typ char und
3. ein Array mit 100 Elementen vom Typ double.
Des Weiteren sollen die Elemente dieser drei Arrays initialisiert werden. Dies geschieht vorzugsweise in einer Schleife. Diese Schleife soll so aufgebaut sein, dass eine
Größenänderung des Arrays keine weiteren Änderungen in den Initialisierungsschleifen nach sich ziehen sollte; mit anderen Worten: Eine Größenänderung sollte durch
eine einzige Modifikation vollständig realisiert sein.
2. Kodierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
14-5
# include < stdio .h >
# define A_SIZE
# define B_SIZE
# define C_SIZE
10
3
100
int main ( int argc , char ** argv )
{
int i , a [ A_SIZE ];
char b [ B_SIZE ];
double c [ C_SIZE ];
for ( i = 0; i < A_SIZE ; i = i + 1 )
a [ i ] = 0;
for ( i = 0; i < B_SIZE ; i = i + 1 )
b [ i ] = ’A ’;
for ( i = 0; i < C_SIZE ; i = i + 1 )
c [ i ] = 0.0;
}
Wintersemester 2017/18, Einführung in die Praktische Informatik
Aufgabe 2: Implizite Größendefinitionen
Wir haben gelernt, dass man in der Programmiersprache C die Größe eines Arrays auch
indirekt und zwar durch die initialisierte Definition festlegen kann. Gegenstand dieser Aufgabe ist das aktive Einüben dieses Konzeptes.
1. Aufgabenstellung
Entwickle ein kleines C-Programm, in dem die Größen von mindestens vier Arrays
implizit durch ihre Initialisierung definiert werden. Zwei Beispieldefinitionen sind
bereits weiter unten angegeben.
Zur weiteren Verwendung der Größen, beispielsweise in Initialisierungsschleifen, ist
die Größe jedes Arrays durch ein geeignetes #define-Makro zu berechnen“.
”
Zur Bestätigung, dass alles korrekt abgelaufen ist, sind die einzelnen Elemente mittels
geeigneter Schleifen auszugeben. In diesen Schleifen sind natürlich oben erwähnte
#define-Makros zu verwenden.
2. Pflichtenheft
Aufgabe :
Eingabe :
Ausgabe :
Sonderfälle :
Korrekte Definition von Arrays mittels Initialisierung
Eingaben werden nicht benötigt
Größe und Inhalt der Arrays als Gegenprobe“
”
Da es keine Eingaben gibt, können auch keine Problemfälle auftreten
3. Testdaten
Array
Typ
Initialwerte
C-Definitionen
a
int
1, 2, 3, 4
x
double
1.0, 2.0
int
a[] = {1, 2, 3, 4 }
#define A SIZE sizeof( a )/sizeof(a[
double x[] = { 1.0, 2.0 }
#define X SIZE sizeof( x )/sizeof(x[
char
c[] = { ’H’, ’i’ }
#define C SIZE sizeof( c )/sizeof(c[
char
m[] = { 98, 99, 100 }
#define M SIZE sizeof( m )/sizeof(m[
c
m
char
char
’H’, ’i’
98, 99, 100
Einführung in die Praktische Informatik, Wintersemester 2017/18
0 ])
0 ])
0 ])
0 ])
14-6
4. Kodierung
1 # include < stdio .h >
2
3 int main ( int argc , char ** argv )
4
{
5
int a [] = { 1 , 2 , 3 , 4 };
6
# define A_SIZE
sizeof ( a ) / sizeof ( a [0])
7
8
double x [] = { 1.0 , 2.0 };
9
# define X_SIZE
sizeof ( x ) / sizeof ( x [0])
10
11
char c [] = { ’H ’ , ’i ’ };
12
# define C_SIZE
sizeof ( c ) / sizeof ( c [0])
13
14
char m [] = { 98 , 99 , 100 };
15
# define M_SIZE
sizeof ( m ) / sizeof ( m [0])
16
17
int i ;
18
printf ( " a [ % d ]: " , A_SIZE ) ;
19
for ( i = 0; i < A_SIZE ; i = i + 1 )
20
printf ( " % d " , a [ i ] ) ;
21
printf ( " \ n " ) ;
22
printf ( " x [ % d ]: " , X_SIZE ) ;
23
for ( i = 0; i < X_SIZE ; i = i + 1 )
24
printf ( " % e " , x [ i ] ) ;
25
printf ( " \ n " ) ;
26
printf ( " c [ % d ]: " , C_SIZE ) ;
27
for ( i = 0; i < C_SIZE ; i = i + 1 )
28
printf ( " % c " , c [ i ] ) ;
29
printf ( " \ n " ) ;
30
printf ( " m [ % d ]: " , M_SIZE ) ;
31
for ( i = 0; i < M_SIZE ; i = i + 1 )
32
printf ( " % c " , m [ i ] ) ;
33
printf ( " \ n " ) ;
34
}
14-7
Wintersemester 2017/18, Einführung in die Praktische Informatik