Redundanz bezeichnet kurz ausgedrückt mehrfach geschriebenen Code. Hier ein kleines, sehr simples Beispiel:

#include<stdio.h>
 
int main (void)
{
   printf("Hallo ");
   printf("Hallo ");
   printf("Hallo ");
   printf("Hallo ");
   printf("Hallo ");
   printf("Hallo ");
   return 0;
}

Nun könnte man sich fragen, was denn nun an dieser Redundanz so schlecht ist. Nehmen wird das Beispiel von oben. Angenommen wir hätten uns vertippt und wollten statt der deutschen Ausgabe „Hallo“ die englische „Hello“. Im obigen Beispiel müssten wir ins so einem Fall 6 Änderungen im Code vornehmen.

6 Änderungen sind nun an sich keine größe Geschichte. Stellen wir uns aber vor, wir wollten 500 mal „Hallo“ auf den Bildschirm schreiben. Alleine der Aufwand, 500 mal die Zeile

   printf("Hallo ");

zu schreiben ist schon ungeheuer. Würden wir uns in solch einem Fall jedoch im Nachhinein dazu entscheiden „Hello“ statt „Hallo“ ausgeben zu lassen, ständen wir vor der netten Aufgabe, 500 Codezeilen abzuändern.

Ein weiterer Nachteil von Redundanz sind viel größere Source Code Dateien. Bei kleineren Projekten nicht wirklich entscheidend, bei größeren jedoch schon.

Und zu guter letzt ist noch die fehlende Übersichtlichkeit als großer Nachteil zu zählen.

Ganz Schlaue unter euch werden nun sagen: Wozu gibt es „Ersetzen“ ? Nunja, das wäre eine Möglichkeit, um das Problem (augenscheinlich) zu lösen. Jedoch kann und wird es auch vorkommen, das mehr als eine Code Zeile mehrfach ausgeführt werden muss. Hierbei wird „Ersetzen“ schon etwas schwieriger. Außerdem löst „Ersetzen“ nicht unser Problem der großen Source Code Dateien. Und übersichtlicher wird durch das Ersetzen auch nichts.

Wie kommt man dem Problem nun also entgegen?

Hierzu gibt es im Großen und Ganzen 2 Möglichkeiten:

• Funktionen
• Schleifen

Funktionen dienen hauptsächlich dazu, zusammengehörige Anweisungen aus der Hauptfunktion auszugliedern. Eine Funktion alleine hilft also noch nicht viel gegen Redundanz, es wird lediglich die Übersichtlichkeit verbessert.

#include<stdio.h>
 
void Schreibe_Nachricht (void)
{
   printf("Hallo ");
}
 
int main (void)
{
   Schreibe_Nachricht();
   Schreibe_Nachricht();
   Schreibe_Nachricht();
   Schreibe_Nachricht();
   Schreibe_Nachricht();
   Schreibe_Nachricht();
   return 0;
}

Außerdem läßt sich nun ein Fehler, wie der oben schon erwähnte Tippfehler, leicher und schneller ausbessern.

Um die Wiederholungen ganz streichen zu können benötigen wir Schleifen. Dadurch erhalten wir die Möglichkeit, Codeteile wiederholt auszuführen.

#include<stdio.h>
 
int main (void)
{
   for( int i = 0; i < 6; ++i )
   {
      printf("Hallo ");
   }
   return 0;
}

Anstatt einer for-Schleife kann natürlich auch eine while-Schleife verwendet werden, wobei dabei der Code etwas länger wird.

Kombiniert mit einer Funktion können wir unseren Code nochmals verbessern:

#include<stdio.h>
 
void Schreibe_Nachricht_6_mal (void)
{
   for( int i = 0; i < 6; ++i )
   {
      printf("Hallo ")
   }
}
 
int main (void)
{
  Schreibe_Nachricht_6_mal();
  return 0;
}

Nun sieht unsere Hauptfunktion doch recht ordentlich aus. Und gleichzeitig ist unser Code nun viel einfacher zu warten. Es ist leicht, den ausgegebenen Text zu verändern. Außerdem ist die Anzahl der Ausgaben mit einer kleinen Änderung beeinflußbar.

Für weitere Informationen über Schleifen und Funktionen sind die dazugehörigen Kapitel zu lesen.

Die obige Funktion ist noch weiter verbesserbar. Dazu sollte man im Umgang mit Parametern vertraut sein. Informationen über Parameter sind im Kapitel Funktionen zu finden. Hier eine Version mit Parametern:

void Schreibe_Nachricht (int Anzahl)
{
   for( int i = 0; i < Anzahl; ++i )
   {
      printf("Hallo");
   }
}
 
int main (void)
{
   Schreibe_Nachricht(6); //Es wird 6 mal "Hallo" ausgegeben
 
   Schreibe_Nachricht(2932); //Es wird 2932 mal "Hallo" ausgegeben
 
   return 0;
}