C Schleifen und Arrays
Schleifen
Variablen sind praktische Werkzeuge um einzelne Zahlen oder
Wörter zu definieren, aber was ist mit großen Mengen, wie Galaxien oder Damenschuhen?
Nehmen wir folgende Problematik: Ein Programm soll Schuhe von Otto, D & G
oder der Nachbarin zählen.
#include <stdio.h>
int main(void)
{
int number_of_ankleboots;
int number_of_anklesandals;
int number_of_ballerinas;
int number_of_booties;
int number_of_chapboots;
int number_of_dorsaypumps;
int number_of_famencopumps;
// ...
int number_of_stilettos;
int number_of_wedgepumps;
int number_of_wedges;
printf("Geben Sie die Zahl
der Ankle Boots an:\n");
scanf("%d", &number_of_ankleboots);
// ...
printf("Geben Sie die Zahl
der Wedges an:\n");
scanf("%d", &number_of_wedges);
int total_count = 0; //
gesamtanzahl an schuhen
total_count += number_of_ankleboots; // addiere ankle boots auf
// ...
total_count += number_of_wedges; // addiere wedges auf
printf("Es sind %d Schuhe auf
Lager.", total_count);
return 0;
}
Inspiriert von solchen Problemen haben die Entwickler von C
Arrays und Schleifen in die Sprache integriert, mit denen sich solche Probleme
unkompliziert lösen lassen.
Die Lösung für das Problem sieht so aus:
#include <stdio.h>
int main(void)
{
int total_count = 0;
for(int i = 0; i < 100; i++) // für i = 0, i = 1, ... i = 99 mache
{
printf("(%d) ", i); // zeige die aktuelle iteration i
char shoe_name[12]; // reserviere speicher für schuhnamen
int count; // schuhanzahl
printf("Geben Sie
den Namen der Schuhsorte ein: ");
scanf("%s",&shoe_name);
printf("Geben Sie
die Anzahl der Schuhe an: ");
scanf("%d", &count);
total_count += count;
printf("%s - %d
insgesamt: %d\n\n", shoe_name, count,
total_count);
}
printf("Gesamtanzahl an
Schuhen %d.", total_count);
getchar();
return 0;
}
In diesem Programm wird eine sog. for-Schleife genutzt. Eine
Schleife wiederholt einen bestimmten Programmabschnitt. Die for-Schleife nimmt
3 Argumente entgegen: die Startposition, die Ausführbedingung und die
Schrittweite: for(/* START */; /* BEDINGUNG*/; /* SCHRITTWEITE */).
In der aufgezeigten Lösung werden die Zahlen 0 bis 99
durchgezählt: for(int i = 0; i < 100; i++) (beachte, dass i++ die variable um
den Wert Eins erhöht).
In dem Block dieser Schleife wird die Schuhsorte und deren Stückzahl angegeben und anschließend die Gesamtkosten aktualisiert. (Die Details zu char shoe_name[12], scanf und printf werden später an passsender Stelle erklärt.)
Ein gutes Gefühl für die for-Schleife gibt folgendes Beispiel:
for(int i = 0; i < 10; i++)
printf("Iteration
%d", i);
Neben der for-Schleife gibt es noch die while- und die do-while-Schleife:
int i = 0;
while(i < 10) // ausführbedingung
{
printf("Iteration
%d", i);
i++;
}
int i = 0;
do // führe die schleife
mindestens einmal aus
{
printf("Iteration
%d", i);
}
while(i == -1); //
Schleifen lassen sich mit continue; überspringen und oder mit break; ganz abbrechen:
int i = 0;
while(i < 20)
{
i++; // erhöhe i
if(i == 5 || i == 10) // überspringe die durchgänge 5 und 10
continue;
if(i % 11 == 0) // brich ab, wenn i durch 11 teilbar ist
break;
printf("%d ", i);
}
printf(" letzter durchgang
%d", i);
Arrays
Im einführenden Beispiel haben unzählige Variablen
gebraucht, um unsere Schuhe nach Kategorie zu zählen:
int number_of_ankleboots;
int number_of_anklesandals;
int number_of_ballerinas;
// ...
int number_of_stilettos;
int number_of_wedgepumps;
int number_of_wedges;
Es wäre viel praktischer anstatt hunderte Variablen zu definieren,
eine Form von Container zu haben, der nur einmal definiert werden muss:
|
numbers_of_shoes[0]; //
Anzahl der Ankle Boots
// ...
numbers_of_shoes[99];
// Anzahl der Wedges
|
Arrays sind solche Container:
#include <stdio.h>
int main(void)
{
int numbers[5]; //
initialisiere container mit 5 elementen
// auf die elemente des
arrays kann mit den indizes 0
// bis 4 zugegriffen werden:
numbers[0] = 20;
numbers[1] = 21;
numbers[2] = 22;
numbers[3] = 23;
numbers[4] = 24;
printf("Index: %d -> Wert:
%d\n",0,numbers[0]);
printf("Index: %d -> Wert:
%d\n",1,numbers[1]);
printf("Index: %d -> Wert:
%d\n",2,numbers[2]);
printf("Index: %d -> Wert:
%d\n",3,numbers[3]);
printf("Index: %d -> Wert:
%d\n",4,numbers[4]);
getchar();
return 0;
}
Wie bei einer Variable muss der Datentyp des Array
festgelegt werden, außerdem hat jedes Array eine feste Länge: int numbers[5];. Zu
diesem Zeitpunkt legt C für uns 5 Felder von der Größe eines Integers im Speicher
an, der Wert der Felder ist noch nicht festgelegt. Die Einträge des Arrays
verhalten sich wie gewöhnliche Variablen numbers[0]
= 20;.
Zu
int numbers[5];
numbers[0] = 20;
numbers[1] = 21;
numbers[2] = 22;
numbers[3] = 23;
numbers[4] = 24;
gibt es eine Kurzform
int numbers[5] = { 20, 21, 22, 23, 24 };
mit Schleifen sieht das Programm in ästhetischer Weise so
aus:
#include <stdio.h>
int main(void)
{
int numbers[5] = { 20, 21, 22, 23, 24 };
for(int i = 0; i < 5; i++)
printf("Index: %d
-> Wert: %d\n",i,numbers[i]);
getchar();
return 0;
}
Wird numbers[5] nicht mit
obiger Notation initialisiert, kommen bei den nicht definierten Indizes ‚unsinnige‘
Werte raus:
#include <stdio.h>
int main(void)
{
int numbers[5];
numbers[0] = 20;
numbers[1] = 21;
numbers[2] = 22;
printf("Index: %d -> Wert:
%d\n",0,numbers[0]);
printf("Index: %d -> Wert:
%d\n",1,numbers[1]);
printf("Index: %d -> Wert:
%d\n",2,numbers[2]);
// nicht initalisiert:
printf("Index: %d -> Wert:
%d\n",3,numbers[3]);
printf("Index: %d -> Wert:
%d\n",4,numbers[4]);
getchar();
return 0;
}
Anderen Falls wird ein Standartwert gesetzt:
#include <stdio.h>
int main(void)
{
int numbers[5] = {20, 21, 22};
printf("Index: %d -> Wert:
%d\n",0,numbers[0]);
printf("Index: %d -> Wert:
%d\n",1,numbers[1]);
printf("Index: %d -> Wert:
%d\n",2,numbers[2]);
printf("Index: %d -> Wert:
%d\n",3,numbers[3]);
printf("Index: %d -> Wert:
%d\n",4,numbers[4]);
getchar();
return 0;
}
Anders als Programmiersprachen wie Java überprüft C nicht,
ob die angegebenen Indizes in den Grenzen des Arrays liegen, was eine mögliche
Fehlerquelle darstellt:
#include <stdio.h>
int main(void)
{
int numbers[5] = {20, 21, 22, 23, 24 };
printf("numbers[-99]:
%d\n",numbers[-99]);
printf("numbers[99]:
%d\n",numbers[99]);
numbers[-99] = 3333;
printf("setze numbers[-99] =
3333:\n",-99,numbers[-99]);
printf("Index: %d -> Wert:
%d\n",-99,numbers[-99]);
getchar();
return 0;
}
Arrays lassen sich auch mehrdimensional verschachteln, als
Arrays von Arrays
#include <stdio.h>
int main(void)
{
int numbers[4][5] = {
{ 10, 11, 12, 13, 14 },
{ 24, 25, 26, 27, 28 },
{ 30, 31, 32, 33, 34 },
{ 44, 45, 46, 47, 48 },
};
numbers[1][2]; // 26
numbers[2][2]; // 32
numbers[2][2]; // 46
printf("Index: [%d][%d] ->
Wert: %d\n", 1, 2, numbers[1][2]); // = 26
getchar();
return 0;
}
Keine Kommentare:
Kommentar veröffentlichen