> ## Documentation Index
> Fetch the complete documentation index at: https://docs.baenninger.me/llms.txt
> Use this file to discover all available pages before exploring further.

# Datentypen

| `char`                                          | -128 bis 127                                             | 1 Byte  | `%c`, `%d` oder `%s` |
| ----------------------------------------------- | -------------------------------------------------------- | ------- | -------------------- |
| `unsigned char`                                 | 0 bis 255                                                | 1 Byte  | `%c`, `%d` oder `%s` |
| `short int` (`short`)                           | -32'768 bis 32'767                                       | 2 Byte  | `%hd`                |
| `unsigned short int` (`unsigned short`)         | 0 bis 65'535                                             | 2 Byte  | `%hu`                |
| `int`                                           | -2'147'483'648 bis 2'147'483'647                         | 4 Byte  | `%d`                 |
| `unsigned int`                                  | 0 bis 4,294,967,295                                      | 4 Byte  | `%u`                 |
| `long int` (`long`)                             | -2'147'483'648 bis 2'147'483'647                         | 4 Byte  | `%ld`                |
| `unsigned long int` (`unsigned long`)           | 0 bis 4,294,967,295                                      | 4 Byte  | `%lu`                |
| `long long int` (`long long`)                   | -9'223'372'036'854'755'808 bis 9'223'372'036'854'755'807 | 8 Byte  | `%lld`               |
| `unsigned long long int` (`unsigned long long`) | 0 bis 18,446,744,073,709,551,615                         | 8 Byte  | `%llu`               |
| `float`                                         | 1.2E-38 bis 3.4E+38 (6 Kommastellen)                     | 4 Byte  | `%f`                 |
| `double`                                        | 2.3E-308 bis 1.7E+308 (15 Kommastellen)                  | 8 Byte  | `%lf`                |
| `long double`                                   | 3.4E-4932 bis 1.1E+4932 (19 Kommastellen)                | 16 Byte | `%Lf`                |
| `bool`                                          | 0 bis 1                                                  | 1 Byte  | `%d`                 |

## Spezielle Verhaltensweisen

### Overflow

Wenn der Wert einer Variablen grösser als ihr Typbereich ist, läuft sie über, d. h. der Wert wird auf den Mindestwert des Typs zurückgesetzt und von dort aus weiter erhöht. Das Gleiche gilt für den umgekehrten Fall.

```c theme={null}
int num = 3147483647;
printf("%d\n", num);
```

### Falscher Datentyp

Wenn ein falscher Wert einem falschen Variablentyp zugewiesen wird, wird der Wert in den Typ der Variablen umgewandelt.

```c theme={null}
int character = 'a';
short boolean = true;

printf("%c\n", character); // a
printf("%d\n", boolean); // 1
```

### Floats und Integer

Wenn ein Float-Wert einer Integer-Variable zugewiesen wird, werden die Zahlen nach den Kommas ganz einfach abgeschnitten.

```c theme={null}
int num = 12.6;
printf("%d\n", num); // 12
```

### Float und Double

Sowohl `float`, als auch `double` werden standardmässig mit 6 Dezimalstellen gedruckt.

```c theme={null}
float floatNum = 12.6;
double doubleNum = 12.6;

printf("%f\n", floatNum); // 12.600000
printf("%lf\n", doubleNum); // 12.600000
```

Wenn man jedoch die Anzahl der Dezimalstellen ändern möchte, kann man `%.nf` verwenden, wobei `n` die Anzahl der Dezimalstellen ist.

```c theme={null}
printf("%.2f\n", floatNum); // 12.60
printf("%.10lf\n", doubleNum); // 12.6000000000
```

## Zeichen

Der Datentyp `char` hat noch eine weitere wichtige Funktion, nämlich das Speichern von Zeichen und Zeichenketten.

```c theme={null}
char num = 23;
char character = 'a';
char string[] = 'Hallo';
```

Wenn wir ein Zeichen oder eine Zeichenkette in die Konsole printen wollen, dann benutzt man das Formatzeichen %c oder %s:

```c theme={null}
printf("%c", character);
printf("%s", string);
```

Wenn wir aber die Nummer von einem `char` drucken wollen, dann benutzt man `%d`.

```c theme={null}
printf("%d", num); // 23
```

Würde man bei einem Zeichen `%d` benutzen, würde die entsprechende Zahl auf der ASCII-Tabelle ausgegeben werden.

```c theme={null}
printf("%d", character); // 97
```

Man kann auch eine Nummer als Eingabe übergeben und erhält das dazu passende ASCII-Zeichen zurück.

```c theme={null}
char num = 98;
printf("%c", num); // b
```

## Strings

Man kann direkt mitgeben, wie viel Speicherplatz C für einen String benutzen soll.

```c theme={null}
char word[20] = "Hello";
```

Wenn man char im Nachhinein initialisieren möchte, braucht man eine weitere Bibliothek, `<string.h>`.

```c theme={null}
#include <stdio.h>
#include <string.h>

int main() {
    char word[100];
    strcpy(word, "Hello");

    printf("%s", word); // Hello
}
```

## Booleans

Es gibt noch den Datentyp `bool`, welcher anzeigen kann, ob eine Aussage `true` oder `false` ist. Man muss diesen Datentyp über eine externe Bibliothek hinzufügen.

```c theme={null}
#include <stdbool.h>
```

Jetzt kann man mit dem Keyword `bool` eine Variable deklarieren.

```c theme={null}
bool isProgrammingFun = true;
bool isVegetableTasty = false;
```

Diese Variablen kann man mit dem Formatzeichen `%d` ausgeben.

```c theme={null}
printf("%d", isProgrammingFun); // 1
printf("%d\n", isVegetableTasty); // 0
```