• Was wollen wir speichern?
  • Name
  • Matrikelnummer
  • Temperatur
  • …
• Bestimmte Formen dieser Daten haben gemeinsame, typische Eigenschaften

Dies alles nennt man Datentypen

• Computer speichert Informationen im Binärformat:

  1 oder 0 (= genannt Bit)

• Kombination von mehreren Ziffern bildet Binärzahl: 1001

8 Bits ergeben dabei 1 Byte →
2⁸ = 256 mögliche Werte pro Byte

• Zahlen \(> 255\) werden genauso dargestellt, bestehen aber aus mehreren Bytes
• Beispiel: 591 = 512 + 79

• 591 =0000 0010 x 256 +0100 1111

• Byte mit dem höchsten/niedrigsten Wert heißt Most/Least Significant Byte (MSB bzw. LSB)
• Reihenfolge der Bytes heißt Byte Order: Entweder von MSB zu LSB (Big Endian) oder von LSB zu MSB (Little Endian)
• Analog für Bits: Most/Least Significant Bit (MSBit bzw. LSBit)

• 🚨 Achtung: Zahlen können gleich aussehen, aber in unterschiedlichen Zahlensystemen stehen
• Beispiel: 110 (Binär) ≠ 110 (Dezimal)

Vorteile der hexadezimalen Darstellung:

• 16 Werte → \(2^4\) → 4 Bit zur Darstellung → 2 x 4 Bit → 1 Byte

  → Darstellung von 1 Byte mit nur zwei Zeichen

• Deutlich leserlicher als eine Binärzahl!

• Hexadezimal ist vielfaches von Binärsystem → einfache Umwandlung

  • Besonders bei großen Zahlen sehr praktisch, weil Binärsystem unhandlich wird
  • Beispiel: FF FF_H besser als 1111 1111 1111 1111_B

• Bei Bytes gibt es oft Verwirrung bei den Präfixen für Einheiten: Kilo, Mega, …

• Hersteller verwenden Dezimalsystem!

  → 1000 Bytes = 1 Kilobyte

#include <stdio.h>

int main() {
    int i = 3; // Befehl 1: Erzeuge Variable mit Ganzzahl (Integer)
    i = i + 5; // Befehl 2: Addiere 5, weise die Summe i zu
    printf("%d", i); // Befehl 3: Nun gib i aus
    return 0;
}

• Diese Art der Programmierung heißt imperativ
• Jeder Befehl in C endet mit dem Semikolon (;)

• Kommentare sind wertvoll, um komplexeren Code zu erklären oder auf Tücken hinzuweisen
• Zwei Arten von Kommentaren: Einzeilig und Blockkommentar

#include <stdio.h>

int main() {
    int i = 3; // Einzeilen-Kommentar, beginnt immer mit //
    // und endet mit der Zeile
    /* Blockkommentar beginnt immer mit /* und endet mit */
    /*
        Beliebiger Text dazwischen möglich
    */
    return 0;
}

Anlegen der Variable num: int num = 3;

• int: Typ der Variable
• num: Bezeichner, führt den Namen num ein
• 3: Initialisierung, initialisiert num mit 3

• Einfache Datentypen sind elementar → nicht auf andere Typen zurückführbar

  (pod = plain old datatypes)

• Beispiele:

  • (nicht-negative) ganze Zahlen (Integers) → int i = 3;
  • Zahlen mit Nachkommastellen (Floats). → float f = 3.14;
  • Zeichen (Characters) → char c = 'c';

• Achtung: verzeichenlos ↔︎ verzeichenbehaftet

  • Zusatz signed bzw. unsigned beim Datentyp: unsigned int num = 3;
  • Bei signed wird ein Bit geopfert für das Vorzeichen

🚨 Breite in Bits ist abhängig von der Hardwarearchitektur! 🚨

🚨 Breite in Bits ist abhängig von der Hardwarearchitektur! 🚨

• Entstehen baukastenartig durch Zusammensetzen von elementaren Datentypen

struct Koordinate {
    int x;
    int y;
};

• Es dürfen nur Buchstaben a-z sowie A-Z, Ziffern 0-9 und der Unterstrich _ vorkommen
• Kein Leerzeichen erlaubt
• Das erste Zeichen muss ein Buchstabe oder ein Unterstrich sein
• Prinzipiell keine (in der Realität erreichbare) Längenbeschränkung
• Schlüsselwörter dürfen nicht verwendet werden
• Trennung zwischen Datentypen und Variablen über Whitespace-Zeichen (Leerzeichen, Tabulator, New Line)

Schlüsselwörter sind reservierte Wörter der jeweiligen Programmiersprache!

• Dies sind nur die relevantesten für C, siehe cppreference.com

Zusätzliche Schlüsselwörter in C++ (auszugsweise, siehe cppreference.com)

• Es gibt zahlreiche Möglichkeiten für die Benennung

• Am weitesten verbreitete Konventionen

  • Snake Case
  • Camel Case

• Snake Case

  • Variablen werden klein geschrieben
  • Leerzeichen durch _ ersetzt
  • Bsp.: int count_variable_1 = 0;

• Konstante Variablen, deren Wert sich nicht verändert, werden nur groß geschrieben

  (Bsp.: const int RESISTOR_VAL_470 = 470;)

• Camel Case
  • Bezeichner beginnt mit Kleinbuchstaben
  • Wörter werden aneinander gehängt
  • ein neues Wort mit Großbuchstaben signalisiert
• Bsp.: int countVariable2 = 0;
• Faustformeln
  • In C ist Snake Case weiter verbreitet → deswegen wird diese Notation auch hier verwendet
  • Interne oder temporäre Variablen beginnen meist mit _

• Modulo-Operation: Division zweier Zahlen, Ergebnis entspricht dem Rest

• Beispiel: Überlauf abfangen bei einer Uhr

#include <stdio.h>

int main() {
    int stunde = 22;
    int minute = 59;
    minute = (minute + 1) % 60;
    stunde = (stunde + 1) % 24;
    printf("%d:%d", stunde, minute);
    return 0;
}

Arithmetische Operation und Zuweisung in einem

• Ihr kennt bereits das erste C-Programm 🥳
• Ihr wisst, wie
  • Ihr Variablen anlegt,
  • man Zahlen abspeichert und
  • mit Variablen rechnet.

• Die häufigste Operation auf Zahlen: Addition / Substraktion von 1
• Es gibt dafür zwei eigene Operatoren
  • ++ (Increment)
  • -- (Decrement)

#include <stdio.h>

int main() {
    int i = 3;
    i = ((i + 13) * 5) / 8) % 3;
    printf("%d", i);
    return 0;
}

( Hier sind Klammern wichtig, die Operatoren haben wie in der Mathematik auch eine unterschiedliche Wichtigkeit)

• Spielt eine Rolle, wenn keine Klammerung vorhanden ist

• Beschreibt die Bindung an Operanden

• Operatoren sind in Gruppen eingeteilt

  • Von 1-17
  • 1 ist die höchste Präzedenz

• Je höher die Präzedenz, desto stärker binden sie an die Werte / Variablen

  (=„je größer die Präzedenz, desto stärker die Anziehungskraft”)

• Vollständige Tabelle aller Operatoren findet sich hier unter cppreference.com

• Muss nicht auswendig gelernt werden!

• Die meisten Präzendenzen ergeben sich intuitiv,

  aber am Anfang muss man ggf. häufiger nachschauen

• Tipp: Im Zweifelsfall Klammern setzen (erhöht auch meistens die Lesbarkeit)

Angenommen eine Variable hat den höchsten darstellbaren Wert

und wird dann erhöht: uint16_t i = 65535; ++i;

Was wird passieren?

• Tritt auf, wenn im Standard das Verhalten nicht definiert ist
• Kann alles bedeuten
  • Vom erwarteten Verhalten (Wrap-Around)
  • Absturz des Programms
  • Es erscheint ein Clown
  • …
• Abhilfe: Nächstgrößeren Datentyp nehmen
  • Bei der Zahl 256 nicht 1 Byte (8 Bit) sondern 2 Byte (16 Bit)
• Programmiert defensiv
  • Trefft lieber Vorkehrungen, wie Konsistenzprüfungen der Werte
  • „Macht der Wert so überhaupt Sinn?” 🤔

Verlasst euch nie auf undefiniertes Verhalten!

• In zwei Geschmacksrichtungen
  • Einfache Genauigkeit: 32 bit → float
  • Zweifache Genauigkeit: 64 bit → double
• Repräsentation ist standardisiert nach IEEE 754 (1985)
• Sind für viele Zwecke gut, aber auch kein Allheilmittel
• Zur internen Darstellung und Tücken von Gleitkommazahlen später mehr (→ Kapitel 6)

• Es gibt neben den bekannten Dezimal-, Hexdezimal- und Binärsystemen noch ein weiteres
• Oktalsystem Zahlen von 0-7

→ \(2 \cdot 8^2 + 2 \cdot 8^0 = 2 \cdot 64_D + 2 \cdot 1 = 130_D\)

• Häufig in Programmcode verwendet, gerade wenn Bitdarstellungen notwendig sind

• Hexadezimalzahlen fangen in C mit dem Präfix 0x an: 0x42 = 66_D
• Oktalzahlen beginnen mit einer 0: 042 = 34_D
• Binärzahlen haben das Präfix 0b: 0b101 = 5_D (nur C++; seit C++14)
• Ebenfalls nur in C++: Visuelle Trennung einer Zahl mit ' zwecks Leserlichkeit: 10'500'000

#include <stdio.h>

int main() {
    int i = 3;
    i = i + 5;
    printf("%d", i);
    return 0;
}

Jetzt fehlt nur noch printf()

• Durchnummerieren aller Zeichen (darstellbar und nicht-darstellbar)
• Festlegung durch ASCII (American Standard Code for Information Interchange)
  • Spendieren 7 Bit für die Darstellung (≠ 1 Byte!)
  • Bei 1 Byte werden unteren 7 Bit genutzt: 01101011
• Heute wird ein Zeichen durch 1 Byte (z. B. UTF-8) dargestellt
• In C/C++ durch ein char repräsentiert: char c = 'a';

• Darstellbar sind auch Sonderzeichen: !, @, >, <, ?, [, ], …
• Aber es gibt auch nicht-darstellbare Zeichen

• Aneinanderreihung von Zeichen zu einem festen Ausdruck (Literal)
• Gekennzeichnet durch Anführungszeichen: "
• Beispiel: char * text = "Hello World";
• Genaue Bedeutung von char * → Kapitel 9

Wir waren hiermit gestartet …

#include <stdio.h>

int main() {
    int i = 3;
    i = i + 5;
    printf("%d", i);
    return 0;
}

Zurück zu printf()!

• Eingabe analog zur Ausgabe mittels scanf()
• Benötigt ebenfalls Formatstring, um Text in gewünschten Datentyp umwandeln zu können

#include <stdio.h>

int main() {
    float f1; // Speicherort anlegen
    float f2;   // Speicherort anlegen
    scanf("%f %f", &f1, &f2); // Befüllung der Variablen
    printf("%f", f1 + f2);
    return 0;
}

Wir können nun mit unserem Programm interagieren 🥳

Wie lege ich z. B. fünfmal einen Integer an?

int a_1;
int a_2;
int a_3;
int a_4;
int a_5;

Das will man so nicht!

• Ermöglicht das Zusammenfassen von n Instanzen des gleichen Typs
• Alles landet in einer Variablen
• Variablendeklaration um Größe und eckige Klammern erweitern
  • Vorher: int num_array; → ein Integer
  • Jetzt: int num_array[5]; → ein Feld mit fünf Integern

int num_array[5];

• Erstellt Variable namens num_array als

  aufeinanderfolgende und zusammenhängende Menge von 5 int-Werten

• Zugriff auf einzelne Elemente über Index

  • Zählung beginnt bei 0
  • Indizes im Bereich [0, n-1]
  • Hier: [0,4]

• Zugriff auf erstes Element mit [0] → printf("%d", num_array[0]);

• Schreiben ist äquivalent dazu: num_array[0] = 1;

int num_array[5];

• Initialisierung erfolgt …
  • separat für jeden Index: num_arrays[0] = 1;
  • vollständig bei Deklaration: int num_arras[5] = {1, 2, 3, 4, 5};
  • teilweise bei der Deklaration: int num_arras[5] = {1, 2};

• Können von beliebigem Typ sein
• Alle Elemente sind vom gleichen Typ
• Typ kann nicht mehr geändert werden
• Länge ist ebenfalls fest!

Denkt vorher über die Array-Größe nach!

• Variable Length Arrays (VLAs) sind ein (gescheiterter) Versuch,

  Arrays mit dynamischer Länge zu ermöglichen

• Nur in C möglich (ab C99), nicht in C++

• Notation

#include <stdio.h>

int main() {
    int n = 10;
    int vla[n]; // Variable Length
    return 0;
}

• Hat eine Reihe von Problemen → Vermeiden!

• Bis hierhin wurden drei verschiedene Klammern eingeführt ((), {}, [])
• Im Englischen wird unterschieden
  • () → Parentheses (Parenthesen)
  • {} → Braces / Curly Braces (Akkoladen)
  • [] → Brackets (Eckige Klammern)
• Außerdem gibt es noch spitze Klammern bzw. Angled Brackets (<>) (Winkelklammern)

• Anhand von Hello World-Beispiel die Grundzüge
  • der Darstellung von Zahlen behandelt,
  • erläutert wie Zeichenketten abgelegt werden,
  • Felder vorgestellt und
  • das Zusammenfassen von mehreren Variablen zu einem Feld erklärt.