Dieses Posting wird voraussichtlich mit den Themen weiterer Unterrichtstage aktualisiert.
Variablen
Eine Variable ist ein Name für einen Speicherbereich. Bevor der Speicher verwendet werden kann, muss er für das Programm reserviert werden.
Zu dieser Reservierung (Deklaration) wird der TYP der Variable und ihr name angegeben. Variablentypen sind z.B. int (Ganzzahl), float (Gleitkommazahl), char (Schriftzeichen)...
Die Syntax zur Variablendeklaration ist "typ name;", also z.B.
int meineVariable;
Damit existiert nun ein Speicherbereich, der "meineVariable" genannt wird und den Typ Ganzzahl hat.
Ich kann auch Schon bei der Deklaration der Variable einen Wert vergeben (Initialisierung). Der dafür benötigte Operator ist das Gleichheitszeichen "=".
int meineVariable = 15;
Wenn ich die Schritte aufteilen möchte, dann kann ich das auch getrennt voneinander tun:
int meineVariable;
meineVariable = 15;
Sobald der Name einmal vergeben ist, muss ich den Typen nicht mehr mit angeben.
VORSICHT!!!!!!!!
Auch Schriftzeichen (char) können dank ASCII als Zahlen verstanden werden. So kann ich z.B. eine Zuweisung durchführen wie
int meineVariable = 'a';
meineVariable enthält dann den Wert 97.
Weil der Typ char nur ein einziges Zeichen lang ist, müssen Zeichenketten (strings) als ARRAYS von Zeichen gebildet werden - über Arrays werden wir uns zu einem späteren Zeitpunkt noch unterhalten.
Vergleichsoperatoren
Vergleiche werden mit folgenden Symbolen durchgeführt:
== Gleichheitsprüfung - VORSICHT ein einfaches Gleichheitszeichen ist IMMER eine Wertzuweisung
< linker Wert kleiner als rechter Wert?
> größer als
<= kleiner oder gleich
>= größer oder gleich
!= Ungleich - das Ausrufezeichen ist immer eine Umkehrung des folgenden Ausdrucks
Eigentlich keine Vergleichsoperatoren aber trotzdem in diesem Kontext interessant sind UND ( && ) und ODER ( || ).
So kann ich ein Ereignis von mehreren Faktoren abhängig machen.
Beispiel:
if(meineVariable < 10 && meineVariable > 0) {Toller Code}
Der Code hinter der if Verzweigung wird nur ausgeführt, wenn meineVariable sowohl kleiner ist als 10 und auch größer ist als 0.
Kontrollstrukturen - Schleifen
Eine Schleife ist ein Block von Anweisungen (Code), der immer wieder durchgeführt wird, bis eine bestimmte, definierte Bedingung nicht mehr erfüllt ist.
Es gibt drei wichtige Arten von Schleifen: while, do...while und for.
while Schleifen werden entweder nicht, einmal oder mehrmals ausgeführt - je nachdem, wie die Bedingung definiert ist. Einige Beispiele:
while(meineVariable < 100)
{
meineVariable = meineVariable + 1;
}
Solange also meineVariable den Wert 100 noch nicht erreicht hat, wird im Anweisungsblock der Wert von meineVariable bei jedem Durchlauf um 1 erhöht. Hat die Variable vor Beginn der Schleife bereits einen Wert größer oder gleich 100, dann wird die Schleife komplett übersprungen und es geht nach der schließenden geschweiften Klammer } weiter.
Hat die Variable den Wert 99 wird die Schleife ausgeführt, die Variable um eins erhöht, die Bedingung erneut geprüft (der Wert ist nun 100, die Schleifenbedingung ist nicht mehr erfüllt) also wird auch nun die Schleife abgebrochen und das Programm nach der Schleife fortgesetzt.
do...while Schleifen werden mindestens einmal durchgeführt - das liegt daran, dass die Schleife ausgeführt wird, bevor die Abbruchbedingung geprüft wird. Wieder ein Beispiel:
do
{
meineVariable++
} while(meineVariable < 100);
Unabhängig vom Wert von meineVariable wird nun zunächst der Wert um eins erhöht (++ ist eine Kurzschreibweise für "Dieser Wert +1"), bevor erst nach der schließenden geschweiften Klammer die Schleifenbedingung geprüft wird. Ist der Wert immer noch kleiner als 100, dann läuft die Schleife wieder durch.
for Schleifen sind Zählschleifen. Sie sind in der Syntax etwas komplexer:
for(Variablen-Initialisierung; Schleifenbedingung; Zähler)
{Anweisungsblock}
Ein Beispiel:
for(meineVariable = 99; meineVariable >= 80; meineVariable -= 1)
{ CODE - 1337 Meg4 H4x0r SKILLZ }
Solange also meineVariable größer oder gleich 80 ist wird der Code im Anweisungsblock immer wieder ausgeführt.
meineVariable -= 1 ist ebenfalls eine Kurzschreibweise, in diesem Fall um die Variable um eins zu verringern. Anders als ++ oder -- kann ich hier aber beliebige Zahlen verwenden (es muss nicht 1 sein), oder auch andere Operatoren (z.B. meineVariable *= 2 multipliziert meineVariable mit 2).
Kontrollstrukturen - Entscheidungen
Für Entscheidungen (Verzweigungen im Programmablauf) werden hauptsächlich zwei Methoden verwendet: if und switch.
if teilt das Programm in zwei Wege - Entweder, die if-Bedingung ist erfüllt, oder eben nicht. ist sie erfüllt, dann wird der Code in der if-Anweisung ausgeführt.
Beispiel:
if(meineVariable < 100)
{
meineVariable *=2;
}
Ich kann if auch mit einem alternativen Pfad versehen, einem else.
if(meineVariable > 100)
{
meineVariable -= 10;
}
else
{
meineVariable += 10;
}
Hier wird eine Entscheidung getroffen: Ist meineVariable größer als 100? Dann zieh 10 ab. Ansonsten (ist die if Bedingung also nicht erfüllt) rechne 10 dazu.
Der switch fällt eine Entscheidung gemäß verschiedener Werte, die eine Variable annehmen kann. Es ist also nicht nur möglich, zwei Fälle zu unterscheiden, wie es mit if der Fall ist. Weil der switch nur präzise Werte und keine Wertebereiche annimmt, gibt es darüber hinaus auch einen Standardwert, der ausgegeben werden kann, für alle Variablenwerte ausserhalb der definierten cases.
Beispiel:
switch(meineVariable)
{
case 55: meineVariable += 45;
break;
case 66: meineVariable += 34;
break;
default: meineVariable = 100;
}
Im Fall dass meineVariable den Wert 55 hat, werden 45 dazu addiert. Sollte meineVariable den Wert 66 haben, werden 34 hinzugezählt. Ist der Wert weder 55 noch 66 (hat also irgendeinen Wert) wird meineVariable auf 100 gesetzt.
Das Kennwort "break" ist nötig, damit die Ausführung des Codes in dieser Stelle abgebrochen wird. Ist kein break gesetzt, geht das Programm nach diesem Case auch noch durch alle folgenden Cases durch.
Logische Operatoren und Wahrheitstabellen
Zur Entscheidung, ob ein Ausdruck wahr oder falsch ist (true or false) werden Vergleichsoperatoren verwendet, die wir weiter oben schon besprochen haben. Will ich aber den Wahrheitsgehalt einer Aussage von mehr als einem Vergleich abhängig machen, dann muss ich diese Vergleiche miteinander verbinden. Das mache ich mit den logischen Operatoren:
- AND &&
- OR ||
- XOR ^
- NOT !
AND gibt nur dann wahr zurück, wenn beide Ausdrücke wahr sind.
if(meineVariable >= 0 && meineVariable <= 100) {führe Code aus}
Der Code in diesem Beispiel läuft nur, wenn meineVariable einen Wert zwischen 0 und 100 hat. Kleine Warnung: Ein Vergleich meineVariable > 0 && <100 ist nicht eindeutig und kann vom Compiler nicht interpretiert werden.
OR gibt wahr zurück, wenn mindestens ein Ausdruck wahr ist.
if(hunger >= 100 || Wochentag == Montag) {pizza_bestellen}
Ich bestelle also Pizza wenn ich so RICHTIG hungrig bin. Ausserdem gibt es jeden Montag italienische Flachtorte, unabhängig davon, ob ich hungrig bin oder nicht.
XOR ist mein kleiner Favorit, weil XOR super ist, um z.B. Paritätsinformationen zu basteln. XOR gibt dann wahr zurück, wenn einer von zwei Ausdrücken wahr ist, nicht aber beide!
Ein Beispiel aus der Wirklichkeit: Eine Ampel an einer Straßenkreuzung soll entweder der einen, oder der anderen Straße grünes Licht geben. Es macht keinen Sinn wenn beide Straßen auf rot stehen, und die Ampel wäre ziemlich sinnlos, wenn beide Straßen grünes Licht bekämen.
NOT kehrt den Wahrheitsgehalt der Aussage um.
"Hiermit lehne ich ab, den Abbruch der nicht-Fortsetzung meiner Vertragskündigung wiederspruchslos zu verweigern..."
Oder:
if(!satt) {essen}
Wahrheitstabellen stellen die Wahrheitswerte dieser Operatoren dar. 0 bedeutet falsch, 1 bedeutet wahr.
AND
0 1
00 0
10 1
OR
0 1
0 0 1
1 1 1
XOR
0 1
0 0 1
1 1 0
NOT
0 1
1 0
Arrays
Arrays sind eine Art Listen, in denen eine Variable mehrere Werte speichern kann. Um einen bestimmten Wert anzusprechen, gebe ich die Position dieses Wertes im Index der Variable an.
Um ein Array zu definieren setze ich einfach die Zahl der zu speichernden Werte in eckige Klammern hinter den Namen:
int meinArray[5];
Arrays sind NULL-terminiert. Das bedeutet, dass auf die letzte, genutzte Stelle im Array ein NULL Character (\0) folgt. Dies hat zur Folge, dass ich ein Array immer mindestens um eins größer definieren muss, als ich vorhabe zu benutzen.
Um eine Position im Array anzusprechen, gebe ich in der eckigen Klammer den "Index" an. Hierbei ist wichtig, dass bei der Definition des Arrays "menschlich", also ab 1, gezählt wird. Bei der Positionierung zählt der Computer aber ab 0!
Das bedeutet: meinArray[4] ist die letzte Position im Array, das ich oben mit 5 möglichen Werten definiert habe.
meinArray ist bisher eindimensional, es ist also einfach nur eine Liste von Werten, die meine Variable annehmen kann. Ich kann ein Array aber auch mehrdimensional erstellen.
int meinKalenderArray[52][7];
Ich hätte so ein zweidimensionales Array definiert, das genug Plätze für alle Wochen des Jahre hat, und darüber hinaus hat es in jeder Woche genug Platz für 7 Tage.
Ich kann diesem Array beliebig viele Dimensionen geben, auch wenn ich bei über 3 Dimensionen Probleme damit habe, mir das ganze grafisch vorzustellen.
Bitverschiebung
C ist ein bisschen harwarenah; Ungefähr so, wie Fallschirmspringen ohne Schirm etwas riskant ist.
Darum kann ich, ganz wie zu Zeiten von Computern die solche Kleinigkeiten wie eine Tastatur noch nicht brauchten, Rechenoperationen auf der Bit-Ebene durchführen.
Left-shift:
verschiebe ich das Bitmuster einer Zahl nach links führe ich eine Multiplikation durch - und zwar verdopple bzw. halbiere ich jeweils den Wert mit jedem Schritt.
Die Anweisung zur Bitverschiebung ist ein doppelter Pfeil, der in die entsprechende Richtung weist, also << und >>.
Beispiel:
0000 1000 << 1 ( die Zahl 8 ) ergibt
0001 0000 ( 16 )
oder:
0010 1101 << 2 ( 45 ) wird zu
1011 0100 ( 180 )
WOW!!!
Right-shift
Anders herum funktioniert es auch:
0000 1000 >> 1 ( 8 )
0000 0100 ( 4 )
oder:
0011 1001 >> 2 (57)
0000 1110 (14)
Zement mal! Da fehlt doch was?!?
Genau! Welche Bits auch immer über die Begrenzung des Zahlentypen hinaus geschoben werden, werden einfach verworfen. Große Integer Werte werden plötzlich negativ (weil das Bit höchster Wertigkeit angibt, welches Vorzeichen die Zahl hat) und Gleitkommazahlen werden ganz unbrauchbar (in einer 32 Bit Gleitkommazahl codiert das erste Bit das Vorzeichen, 23 Bit die Ziffern der Zahl und 8 Bit den Exponenten, also praktisch die Position des Kommas - Wikipedia erklärts genauer). Diese Operationen sind also mit Vorsicht zu genießen.
Zeiger und Referenzen
Kommen wir zu den Gehirnknoten!
Eine Referenz gibt die Speicheradresse aus - ich könnte also z.B. mit &meineVariable den Hex-Code für die erste Speicherzelle auslesen, die von meineVariable belegt wird. Die erste Zelle deshalb, weil jede Speicherzelle ein Byte groß ist, die Variablen aber unterschiedliche Größen haben (z.B. int mit 4 Byte).
So weit so gut - nun kann ich mir aber auch einen Zeiger basteln - ein Zeiger ist eine Variable, die eine Referenz enthält.
z.B. meinSpeicher = &meineVariable;
Wenn ich nun diese Speicheradresse verwenden möchte, um direkt in die Speicherzelle zu schreiben oder daraus zu lesen, setze ich ein * vor den Namen.
z.B.
int meinSpeicher = &meineVariable;
*meinSpeicher = 12;
Ich speichere die Adresse von meineVariable in meinSpeicher. Daraufhin gebe ich den Befehl, an die Adresse, auf die meinSpeicher verweist, eine 12 zu schreiben. Damit ist meineVariable nun mit der Zahl 12 überschrieben.
Also: & = Speicheradresse, * = Wert, der an der Speicheradresse steht.
Funktionen und Methoden
Kommen wir zum spaßigen Teil des Abends: Den Code übersichtlich gestalten. Das können wir z.B. mit Funktionen und Methoden machen.
Eine Funktion ist eine Anweisung (oder eine Sammlung von Anweisungen), die dem Hauptprogramm irgendeinen Wert übergeben. Eine Methode gibt dem Hauptprogramm keine Werte zurück, macht aber sonst das Gleiche.
Ich definiere eine Funktion durch:
- Angabe des Rückgabetypen (bei Methoden "void")
- Den Namen der Funktion und
- Die Liste der Parameter, die die Funktion von uns bekommt.
z.B. int meineFunktion(int x, int y) {MAGIC}
Die Namen der Variablen, die ich meiner Funktion übergebe sind nur lokal gültig, das heißt, ich kann der Funktion eine Variable char Schrunz geben, und die Funktion lernt sie nur als den Wert ihrer eigenen Variable Schrompf kennen. Oder Meier. Oder einfach x.
Der Wert, den die Funktion zurückgibt, bestimmte ich mit dem Kennwort return. Also:
int meineFunktion(int x, int y)
{
if(x < y) x = y;
return x;
}
Ist x kleiner als y wird es auf den Wert von y gebracht und dann an das aufrufende Programm zurück gegeben. Ist x aber größer als y wird direkt der Wert von x zurück geliefert.
Fragt mich nicht, welches Problem damit gelöst werden soll, es ist viertel vor zehn abends und ich sauge mir die Beispiele aus den Fingern!
Stellen wir uns nun vor, ich hätte in meiner main Funktion folgenden Codeabschnitt:
int Autos = 44;
int Fahrraeder = 80;
printf("\nWelche Zahl ist höher? %i", meineFunktion(Autos, Fahrraeder));
Es steht %i dort, weil der erwartete Rückgabetyp der Funktion ein int ist, und weil die Funktion die übergebenen Werte kopiert, verändert sich trotz der radikalen Operation von x = y nichts an den Werten der Variablen Autos und Fahrraeder. GEIL!
areudirty
theartofmadeline
jbbartram-illu
ellievsbear
