Bild Referenz: http://3.bp.blogspot.com/_ynkoLGkpwXY/TDmvY3T0wQI/AAAAAAAAAjo/iy3tga3v7x4/s1600/local_variable_in_c.bmp

Intro

Hallo, ich bins @drifter2! Der heutige Artikel ist original und keine Übersetzung von meinen Englischen Artikeln. Da Funktionen und Variablen das wichtigste beim Programmieren sind, dachte ich mir das ein Artikel über diese Dinge sehr nützlich währe. Nach dem heutigen Artikel werdet ihr alle auch das Beispielprogramm vom vorherigen Artikel besser verstehen! Also, dann fangen wir mit dem heutigen Thema mal an!

Funktionen

Das Grundgerüst eines Programms in jeder Programmiersprache ist eine gewisse Hauptfunktion die meistens mit "main()" notiert wird. Diese Funktion repräsentiert das so genannte Programm-Block. Damit unser Programm kleiner und übersichtlicher wird, unterbringen wir nicht alle unsere Aktionen in diesem Block, aber lassen Funktionen (auch Unterprogramme) bestimmte Aufgabe erledigen. Durch diese Funktionen "zerteilen/zerlegen" wir unser Programm und größere Probleme in kleinere Teilprobleme. Jede Funktion erledigt dadurch eine bestimmte Aufgabe die wir mit so genannten Parametern "kontrollieren" können. Nachdem diese Funktion ihre Aufgaben ausgeführt hat kann diese einen Rückgabewert zurückgeben den dann die Hauptfunktion (oder auch andere Funktionen) verwenden kann. Eine Funktion ohne Rückgabewert wird meistens Prozedur genannt. Dieser Wert kann zum Beispiel das Resultat einer Summe zwischen zwei Ganzzahlen sein. Eine andere Funktion kann diese "addiere(...)" Funktion sehr leicht ausführen mit:

addieren(3, 5);

Diese Funktion wird '8' zurückgeben wenn nichts schiefgeht :P

Alles was wir bis jetzt erwähnt haben ist eine Generelle Formulierung von Funktionen, die alle Programmiersprachen betrefft. Gehen wir jetzt mal in spezifische Sachen die bei der Programmiersprache C gilten...

Die Vorteile der Modularisierung sind:

Bessere Lesbarkeit
Wiederverwendbarkeit
Wartbarkeit

Funktionen in C

Das Beispiel das ich erwähnt habe kann in C wie folgend implementiert werden:

int addiere(int summand1, int summand2) {

 return (summand1 + summand2);

int main() {

 int summe = addiere(3, 7);

 printf("Summe von 3 und 7 ist %d\n", summe);

 return 0;

Die Konsole druckt natürlich folgendes aus:

Summe von 3 und 7 ist 10

Die generelle Syntax einer Funktion in C ist also:

Rückgabetyp Funktionsname(Parameterliste){

 Anweisungen / Aktionen

Ein paar wichtige Notizen über solche Funktionen:

Eine Funktion ohne Rückgabewert hat nen void-Rückgabetyp
Eine Funktion mit Rückgabewert enthält/endet mit einer "return" Anweisung die natürlich einen Wert mit übereinstimmenden Datentyp zurückgeben muss
Man kann Felder-Arrays nicht direkt zurückgeben aber man kann Zeiger-Pointer, also Adressen zu Speicherstellen abgeben (ein Feld wird Lokal abgespeichert, also werden die Informationen nicht mehr gültig sein, nachdem die Funktion ihre Ausführung beendet)

Etwas sehr wichtiges ist der Unterschied zwischen Definition und Deklaration. Eine Definition enthält auch die Anweisungen/Aktionen. Eine Deklaration enthält den so genannten Funktionskopf (Rückgabetyp, Name, Parameter) gefolgt durch einem Semikolon ';'. Die Deklaration der vorherigen Funktion sieht wie folgend aus:

int addiere(int summand1, int summand2);

Die meisten Programme fangen mit der Deklaration aller Funktionen an. Die eigentliche Definition folgt nach der "main()" Funktion oder ist in einer anderen C Bibliothek Datei. Die so genannte Header-Datei (.h) enthält die Deklaration und die Code-Datei (.c) enthält die Definition.

Variable Gültigkeitsbereich

Generelles - Lokale Variablen

Mit der Verwendung solcher Funktionen, müssen wir jetzt auch die Gültigkeit und Sichtbarkeit der Variablen beachten. Die Variablen haben also jetzt nicht nur einen bestimmten Datentyp, sondern auch einen Gültigkeitsbereich. Die Datentyp-Angabe hilft dem Compiler bei der Reservierung von genügend Speicher (die so genannte Speicherzuweisung oder Zuordnung). Wenn man eine Funktion ausführt wird genügend Speicher für diese Funktion zugewiesen und ihre Variablen. Die Variablen sind Lokal (local auf Englisch) und existieren nur innerhalb dieser Funktion und nur wenn diese Funktion gerade ausgeführt wird. Andere Funktionen können auf diese Lokale Variablen nicht direkt zugreifen. All das heißt das eine Variable immer nur in dem Funktions-Block sichtbar ist und das ihre Lebensdauer die selbe wie die Funktion die sie enthält ist.

Etwas sehr wichtiges ist das wir Variablen mit dem selben Namen deklarieren-definieren können. Die eigentliche Variable die aber innerhalb eines Blocks benutzt wird ist dann die "näheste" und meistens die im Lokalen Block. Wenn eine Variable in einer Funktion benutzt wird und nicht in dieser definiert/deklariert wurde, dann wird diese vom "höheren" oder sogar dem Globalen/Programm Block benutzt. All das bedeutet das Variablen nicht nur innerhalb eines {} Blockes zugegriffen werden können, sondern auch mit anderen Wegen. Funktionswerte werden z.B mit Parametern übergeben.

Globale Variablen

Eine Variable die bei mehreren Blöcken oder sogar bei dem ganzen Programm sichtbar ist nennt man eine Globale (global) Variable. Solche Variablen sind bei jedem Ort zugreifbar. Diese werden meistens außerhalb der Hauptfunktion (main) deklariert, wie folgend:

// Globale Variablen

// Funktion Deklaration

int main(){

...

// Funktionen Definition

Statische Variablen

Eine andere ähnliche Form von Variablen sind die so genannten Statischen (static) Variablen. Die Variablen die innerhalb von {} Blöcken deklariert existieren nach dem Durchlauf dieses Blocks nicht mehr. Um das zu verhindern können wir Variablen als statisch markieren, so das sie ihr Stellung behalten und nicht "abgereinigt" werden. Das alles heißt das eine statische Variable innerhalb einer Funktion nach einer zweiten, dritten usw. Ausführung noch ihren vorherigen Wert hält. Dadurch können wir z. B. einen Zähler (counter) erstellen der bei 0 anfängt und bei jeder Ausführung der Funktion den Wert um eins erhöht. Das sieht wie folgend aus:

int zaehlen() {

 static int counter = 0;

 return ++counter;

Konstante Variablen

Manchmal braucht man bei der Programmierung auch nur einen konstanten Wert bei vielen verschiedenen Stellen. Dieser Wert ist unveränderbar innerhalb der Ausführung des Programms. Wenn man diesen Wert bei vielen Stellen verwendet kann man den dann bei vielen Stellen gleichzeitig verändern durch die Benutzung einer Konstanten (constant - const) Variable. Dadurch ändern wir diesen Wert nur bei einer Stelle und sparen an Zeit. Eine Konstante Variable wird außerhalb der Hauptfunktion deklariert wie folgend:

const Datentyp Name = Wert;

Symbolische Variablen

Symbolische Variablen oder Konstante sind sozusagen Konstante Variablen aber haben gewisse Unterschiede. Man definiert so eine Symbolische Konstante mit einen Namen (Großgeschrieben) und einen Wert. Beim Kompilieren (Compiling) wird dann die Symbolische Konstante im Quellcode durch ihren Wert ersetzt. So eine "Variable" wird wie folgend definiert:

#define Name Wert

Wie ihr direkt sehen könnt haben wir solche Variablen-Konstanten bereits oft benutzt :)

Um eine solche Konstante wieder zu entfernen können wir #undef Name benutzen, aber das ist nur nötig wenn wir alles sehr sehr optimal machen wollen.

Ich schätze mal ihr habt jetzt einen besseren Überblick über das Thema: "Funktionen und Variablen". All das kann man nicht so leicht auswendig lernen aber wird man bit der Zeit langsam lernen. Bei großen Problemen kann man immer "Googlen". Beim Programmieren ist Google immer dein Freund :P

Referenzen:

Vorherige Artikel

Einführung -> Programmiersprachen, die Sprache C, Anfänger Programme

Felder -> Felder, Felder in C, Erweiterung des Anfänger Programms

Zeiger, Zeichenketten und Dateien -> Zeiger, Zeichenketten, Dateiverarbeitung, Beispielprogramm

Dynamische Speicherzuordnung -> Dynamischer Speicher, Speicherzuweisung in C, Beispielprogramm

Strukturen und Switch Case -> Switch Case Anweisung, Strukturen, Beispielprogramm

Und das war's dann auch mit dem heutigen Artikel und ich hoffe ich hab alles verständlich erklärt. Νächstes mal werden wir über Rekursive Algorithmen reden und wie man diese in C implementiert!

Keep on drifting! ;)

Programmieren in C - Funktionen und Variable-Gültigkeitsbereich