C - Datenarten

Hallo da drüben, zukünftige Programmierer! Willkommen auf unserer aufregenden Reise in die Welt der C-Programmierung. Heute werden wir den faszinierenden Bereich der Datenarten in C erkunden. Keine Sorge, wenn du neu im Programmieren bist; ich werde dein freundlicher Guide sein, und wir werden dieses Thema Schritt für Schritt angehen. Also hol dir dein liebstes Getränk, setz dich bequem hin, und Tauchen wir ein!

Ganzzahl-Datenarten in C

Lassen Sie mit etwas beginnen, das wir alle kennen - ganze Zahlen. In C nennen wir sie Ganzzahlen, und sie kommen in verschiedenen Größen und Sorten.

Die grundlegenden Ganzzahltypen

Hier ist eine Tabelle der häufigsten Ganzzahltypen in C:

Datenart	Größe (Bytes)	Bereich
char	1	-128 bis 127 oder 0 bis 255
short	2	-32.768 bis 32.767
int	4	-2.147.483.648 bis 2.147.483.647
long	4 oder 8	-2.147.483.648 bis 2.147.483.647 oder -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807

Sehen wir uns diese in Aktion an:

#include <stdio.h>

int main() {
    char my_char = 65;
    short my_short = 32000;
    int my_int = 2000000000;
    long my_long = 9000000000L;

    printf("char: %c\n", my_char);
    printf("short: %d\n", my_short);
    printf("int: %d\n", my_int);
    printf("long: %ld\n", my_long);

    return 0;
}

Wenn Sie diesen Code ausführen, werden Sie Folgendes sehen:

char: A
short: 32000
int: 2000000000
long: 9000000000

Lassen Sie uns das herunterbrechen:

• Der char-Wert 65 entspricht 'A' in der ASCII-Tabelle. Überraschung! char kann auch Zahlen speichern!
• short und int funktionieren wie erwartet für mittlere Zahlen.
• Für long fügen wir eine 'L' an das Ende hinzu, um C zu sagen, dass es eine lange Zahl ist.

Unsignierte Ganzzahlen

Manchmal brauchen wir nur positive Zahlen. Das ist, wo unsignierte Ganzzahlen nützlich sind:

unsigned char my_uchar = 255;
unsigned short my_ushort = 65000;
unsigned int my_uint = 4000000000U;

printf("unsignierter char: %u\n", my_uchar);
printf("unsignierter short: %u\n", my_ushort);
printf("unsignierter int: %u\n", my_uint);

Ausgabe:

unsignierter char: 255
unsignierter short: 65000
unsignierter int: 4000000000

Durch die Verwendung von unsigned können wir größere positive Zahlen im gleichen Speicherplatz speichern. Es ist wie Magie, aber es ist nur die clevere Nutzung von Bits!

Fließkomma-Datenarten in C

Nun tauchen wir in die Welt der Dezimalzahlen ein. C bietet drei Fließkommatypen:

Datenart	Größe (Bytes)	Genauigkeit
float	4	6-7 Dezimalstellen
double	8	15-16 Dezimalstellen
long double	16	19-20 Dezimalstellen

Sehen wir uns diese in Aktion an:

#include <stdio.h>

int main() {
    float pi_float = 3.14159265358979323846f;
    double pi_double = 3.14159265358979323846;
    long double pi_long_double = 3.14159265358979323846L;

    printf("float: %.7f\n", pi_float);
    printf("double: %.16f\n", pi_double);
    printf("long double: %.20Lf\n", pi_long_double);

    return 0;
}

Ausgabe:

float: 3.1415927
double: 3.1415926535897931
long double: 3.14159265358979323846

Beachten Sie, wie float nach 7 Dezimalstellen an Genauigkeit verliert, während double und long double mehr Genauigkeit beibehalten. Es ist wie ein Zoom in ein Digitales Foto - irgendwann beginnen Sie, Pixel zu sehen!

Benutzerdefinierte Datenarten in C

C ermöglicht es uns, unsere eigenen Datenarten zu erstellen. Es ist wie ein Koch, der seine eigenen Rezepte erstellt!

Strukturen

Strukturen ermöglichen es uns, verwandte Daten zusammen zu gruppieren:

#include <stdio.h>
#include <string.h>

struct Student {
    char name[50];
    int age;
    float gpa;
};

int main() {
    struct Student alice;
    strcpy(alice.name, "Alice");
    alice.age = 20;
    alice.gpa = 3.8;

    printf("Name: %s\n", alice.name);
    printf("Alter: %d\n", alice.age);
    printf("Notendurchschnitt: %.1f\n", alice.gpa);

    return 0;
}

Ausgabe:

Name: Alice
Alter: 20
Notendurchschnitt: 3.8

Hier haben wir eine Student-Art erstellt, die einen Namen, ein Alter und einen Notendurchschnitt zusammenfasst. Es ist wie das Erstellen eines Formulars für Studenteninformationen!

Aufzählungen

Aufzählungen sind großartig zum Erstellen eines Sets von benannten Konstanten:

#include <stdio.h>

enum Days {SUN, MON, TUE, WED, THU, FRI, SAT};

int main() {
    enum Days today = WED;
    printf("Heute ist Tag Nummer %d\n", today);
    return 0;
}

Ausgabe:

Heute ist Tag Nummer 3

Aufzählungen weisen automatisch zunehmende Ganzzahlen beginnend mit 0 zu. Es ist wie das Geben von Spitznamen für Zahlen!

Der void-Datenart in C

void ist eine besondere Art in C. Es ist wie eine leere Leinwand - es repräsentiert das Fehlen von Daten. Wir verwenden es hauptsächlich in drei Szenarien:

1. Funktion gibt nichts zurück:

   void sayHello() {
    printf("Hallo, Welt!\n");
   }

2. Funktion nimmt keine Parameter an:

   int getRandomNumber(void) {
    return 4;  // gewürfelt mit fairem Würfel. garantiert zufällig.
   }

3. Allgemeine Zeiger (wir werden das im Abschnitt Zeiger behandeln)

Array-Datenart in C

Arrays sind wie eine Reihe von Taubenschlägen, die jeweils einen Wert desselben Typs enthalten:

#include <stdio.h>

int main() {
    int scores[5] = {85, 92, 78, 90, 88};

    printf("Erste Punktzahl: %d\n", scores[0]);
    printf("Letzte Punktzahl: %d\n", scores[4]);

    float average = 0;
    for(int i = 0; i < 5; i++) {
        average += scores[i];
    }
    average /= 5;

    printf("Durchschnittliche Punktzahl: %.2f\n", average);

    return 0;
}

Ausgabe:

Erste Punktzahl: 85
Letzte Punktzahl: 88
Durchschnittliche Punktzahl: 86.60

Denken Sie daran, dass Array-Indizes in C bei 0 beginnen. Es ist wie Stockwerke in Europa - das Erdgeschoss ist 0!

Zeiger-Datenart in C

Zeiger sind wie Schilder, die auf Speicherorte zeigen. Sie sind mächtig, aber können knifflig sein:

#include <stdio.h>

int main() {
    int x = 10;
    int *p = &x;

    printf("Wert von x: %d\n", x);
    printf("Adresse von x: %p\n", (void*)&x);
    printf("Wert von p: %p\n", (void*)p);
    printf("Wert auf den p zeigt: %d\n", *p);

    *p = 20;
    printf("Neuer Wert von x: %d\n", x);

    return 0;
}

Ausgabe (Adressen werden variieren):

Wert von x: 10
Adresse von x: 0x7ffd5e8e3964
Wert von p: 0x7ffd5e8e3964
Wert auf den p zeigt: 10
Neuer Wert von x: 20

Hier ist p ein Zeiger, der die Adresse von x speichert. Wir können *p verwenden, um den Wert an dieser Adresse zu lesen oder zu ändern. Es ist wie eine Fernbedienung für x!

Und das war's! Wir haben die wichtigsten Datenarten in C abgedeckt. Denken Sie daran, dass das Verständnis von Datenarten entscheidend ist, da es Ihnen hilft, Speicher effizient zu verwalten und Fehler zu vermeiden. Üben Sie weiter und bald werden Sie diese Typen wie ein Profi jonglieren! Frohes Coden!

Credits: Image by storyset