Variable

Variablen erlauben es Daten strukturiert zu speichern. Um eine Variable einzubringen muss man sie erst deklarieren, d.h., dass man ihr einen Typen wie int oder char geben muss. Dann kann man der Variable einen "Wert" zuweisen bzw. die Variable initialisieren.

Initialisieren

• Variablen können frei gewählt werden mit folgenden Einschränkungen
  • Erste Zeichen: a-z, A-Z, _
  • weitere Zeichen: 0-9, a-z, A-Z, _
  • keine Schlüsselbegriffe wie z.B. int, while, for, if, ...

Typen von Variablen

Typen definieren

• Art der Werte
  • int $i\in \mathbb{Z}$
• Wertebereich
  • int $i\in [-2^{32},2^{31}-1]\in \mathbb{Z}$
  • wird standardmäßig vom Speicherplatz festgelegt
• 1 Byte = 8 Bit $⟹$ 256 unterschiedliche Bitmuster
• Typ legt fest, was das Bitmuster bedeuten soll
• Operationen, die auf den Werten ausgeführt werden können
  • z.B. +, -, * , /, %, etc.

Expliziter Typ:

• unit8_t
  • u: Unsigned
  • int: Integer
  • 8: 8 Bit = 1 Byte Speicherplatz
  • _ t: "Ich bin ein Typ" (Schreibkonvention)

  • uint8_t i = 17; // gültige Operation 
  • uint8_t i = -100; // ungültige Operation
  

einfache Typen

• int: Ganze Zahl ("integer")
  • Erlaubt das Speichern eines Integer (ganzahligen Wertes in einer Variable)
  • typischerweise 32 Bit
  • Wertebereich: -2.147.483.648 ($-2^{32}$ ) bis 2.147.483.647 ($2^{32}-1$) oder auch INT_MIN bis INT_MAX
• char: Zeichen ("character")
  • Erlaubt das Speichern eines Zeichens
  • Typischer Weise: 8 Bit
  • "Wertebereich": -128 bis 127
  • a = 97
• boolean: Wahrheitswerte
• float: Gleitkommazahlen
  • hat meist 32 Bit -> nicht alle reelle Zahlen darstellbar
  • geeignet, wenn kleine Rundungsfehler akzeptabler sind
• enum: Aufzählungen
  • Nicht alles lässt sich mit Zahlen gut darstellen
  • z.B. Ampel: Rot, Gelb, Grün
  • -> Enumerations ("enums") erlauben es eigene Typen als Liste von möglichen Werten („variants“) zu definieren
  • Beispiel:

    enum TrafficLightColor {
    	Red,
    	Yellow,
    	Green
    };
    

    • Datentyp heißt nun: enum TrafficLightColor und nicht nur TrafficLightColor
• typedef: man kann hiermit Typ umbenennen, damit er vereinfacht wird
  • mit einem Unterstrich hinter einem enum deutet man an, dass später im Programm eine Vereinfachung stattfindet -> Schreibkonvention

  enum CoinFace_ {
  	Heads,
  	Tails
  };
  typedef enum CoinFace_ CoinFace;
  CoinFace x = Heads;  // äquivalent zu `enum CoinFace_ x = Heads;`
  
  //Kompaktere Syntax:
  typedef enum CoinFace_ {
  	Heads,
  	Tails
  } CoinFace;
  

strukturierte Typen

• struct: Strukturierte Datentypen
  • Point3d als Beispiel für x-, y- und z-Koordinaten eines Punktes

    struct Point3d {
    	float x;
    	float y;
    	float z;
    }; //erstellt neunen Typ namens `struct Point3d`
    

  • So kann man einen Punkt dann initialisieren und implementieren:

    // Wert erstellen
    struct Point3d my_point = { .x = 1,5, .y = 2, .z = -3 };
    
    float a = 5.0 + my_point.y; // Felder zuweisen
    my_pioint.z = 1;            // Felder zuweisen
    

  • struct-Werte können genauso kopiert werden wie andere Werte auch
  • Funktionen können mit structs arbeiten
  • struct in einer struct
  • rekursive struct sind nicht möglich!

Wahrheitswerte

• in C ist alles, was Null ergibt falsch und alles andere richtig
• der Programmiersprachenübergreigenden Typ "Boolean" hat nur der Werte "true" und "false"
• boolean ist eindeutiger

Pointertypen

• Pointer: Eine Variable, die eine Speicheradresse als ihren Wert speichert
  • Auch Pointer haben einen Typ und werden mit "< Typ >* " definiert
  • Der Typ eines Pointers ist Pointer zeigt: "* < Pointervariable > "

int x = 5;  // declare x as an integer variable 
int *p, *q; // declare p and q as pointers to an integer 
				// int* p; and int * p; are OK as well 
p = &x;     // store address of x in p 
int y = *p; // assign y the value p points to, i.e., x, i.e., 5 
q = p;      // q points to the same location as p, i.e., x 
printf(“Value of x: %d (at address %p)”, *p, q);

Arbeiten mit Pointern

• Pointer und struct
  • Pointer können auf alles zeigen
  • Zugriff auf Komponenten einer struct:
    • Variablen: mit „.“, z.B.: my_point.x
    • Pointer: mit „->“, z.B.: p->x
• Parameterübergabe an Funktionen
  • Call by Value
    • Parameterübergabe als Wert
    • Werte der Variablen werden übergeben
    • Werte der Variablen stehen als lokale Kopie zur Verfügung
    • Damit sind Änderungen nur innerhalb der Funktion sichtbar
  • Call by Reference
    • Parameterübergabe als Adresse
    • Adressen der Variablen werden übergeben
    • Adresse steht damit lokal zur verfügung und der Zugriff auf den Speicherort ist möglich
    • Damit sind Änderungen über die Funktion hinaus sichtbar