C - Bezeichner: Dein Tor zur Namensgebung im Programmieren

Hallo da draußen, zukünftige Codewizardinnen und -wizards! Heute machen wir uns auf eine aufregende Reise in die Welt der C-Programmierung, und zwar speziell mit dem Fokus auf Bezeichner. Keine Sorge, wenn ihr vorher noch nie eine Zeile Code geschrieben habt – wir fangen ganz am Anfang an und arbeiten gemeinsam hinauf. Also, holt euch eure virtuellen Zauberstäbe (Tastaturen) und tauchen wir ein!

C - Identifiers

Was sind C-Bezeichner?

Stellen Sie sich vor, Sie sind in einem Raum voller Menschen und möchten jemanden ansprechen. Sie würden ihren Namen verwenden, oder? Nun, in der Programmierung dienen Bezeichner einem ähnlichen Zweck. Sie sind die Namen, die wir verschiedenen Elementen in unserem Code geben, wie Variablen, Funktionen oder Strukturen. Diese Namen helfen uns (und dem Computer), diese Elemente im gesamten Programm zu identifizieren und zu verwenden.

Warum sind Bezeichner wichtig?

Lesbarkeit: Gute Bezeichner machen Ihren Code einfacher zu verstehen.
Wartbarkeit: Klarer Names helfen beim Aktualisieren Ihres Codes später.
Fehlersuche: Wenn etwas schiefgeht, können gut benannte Bezeichner eine Lebensretter sein!

Sehen wir uns ein einfaches Beispiel an:

int alter = 25;

Hier ist alter ein Bezeichner. Es ist der Name, den wir einer Variable gegeben haben, die das Alter einer Person speichert.

Benennungsregeln für C-Bezeichner

Nun, genauso wie Ihre Schule wahrscheinlich Regeln hat, welche Namen Sie verwenden können (keine Spitznamen in offiziellen Dokumenten!), hat C Regeln für die Benennung von Bezeichnern. Lassen Sie uns diese auseinandernehmen:

Erlaubte Zeichen:

Kleinbuchstaben (a-z)
Großbuchstaben (A-Z)
Ziffern (0-9)
Unterstrich (_)

Erstes Zeichen: Muss ein Buchstabe oder ein Unterstrich sein. Darf nicht mit einer Ziffer beginnen.
Groß- und Kleinschreibung: alter, Alter und ALTER sind alles unterschiedliche Bezeichner in C.
Keine Schlüsselwörter: Sie dürfen C-Schlüsselwörter nicht als Bezeichner verwenden.
Länge: Während es kein offizielles Limit gibt, sind die ersten 31 Zeichen in den meisten C-Compilern erheblich.

Gemeinsame Benennungskonventionen

Obwohl dies keine strengen Regeln sind, helfen diese Konventionen, Ihren Code lesbarer zu machen:

Verwenden Sie Kleinbuchstaben für Variablennamen: int schueler_anzahl;
Verwenden Sie Großbuchstaben für Konstanten: #define MAX_GROESSE 100
Verwenden Sie CamelCase für Funktionsnamen: void berechneGesamt();

Beispiele für C-Bezeichner

Sehen wir uns einige gültige und ungültige Bezeichner an:

Gültige Bezeichner	Ungültige Bezeichner	Erklärung
`alter`	`2tePlatz`	Darf nicht mit einer Ziffer beginnen
`_anzahl`	`meine-variable`	Bindestriche sind nicht erlaubt
`vorName`	`float`	`float` ist ein Schlüsselwort
`MAX_GROESSE`	`$gesamt`	Dollarzeichen sind nicht erlaubt
`spieler1`	`benutzer name`	Leerzeichen sind nicht erlaubt

Nun sehen wir uns diese in der Praxis an:

#include <stdio.h>

#define MAX_GROESSE 100  // Gültig: Großbuchstaben für Konstanten

int main() {
int alter = 25;  // Gültig: Kleinbuchstaben für Variablen
char _initial = 'J';  // Gültig: Darf mit Unterstrich beginnen
float groesse_in_cm = 175.5;  // Gültig: Unterstriche erlaubt

// Ungültige Beispiele (auskommentiert, um Fehler zu vermeiden):
// int 2tePlatz = 2;  // Ungültig: Beginnt mit einer Ziffer
// float meine-variable = 175.5;  // Ungültig: Enthält Bindestrich
// char float = 'F';  // Ungültig: 'float' ist ein Schlüsselwort

printf("Alter: %d\nInitial: %c\nGröße: %.1f cm\n", alter, _initial, groesse_in_cm);

return 0;
}

Wenn Sie dieses Programm ausführen, werden Sie Folgendes sehen:

Alter: 25
Initial: J
Größe: 175.5 cm

Jeder Bezeichner in diesem Programm dient einem bestimmten Zweck, was den Code leicht verständlich und wartbar macht.

Gültigkeit von C-Bezeichnern

Nun, lassen Sie uns über etwas Fortgeschritteneres sprechen – die Gültigkeit von Bezeichnern. Stellen Sie sich die Gültigkeit als "Sichtbarkeit" eines Bezeichners in Ihrem Programm vor.

Arten der Gültigkeit

Block Gültigkeit: Variablen, die innerhalb eines Blocks (eingeklammert mit {}) deklariert werden, sind nur innerhalb dieses Blocks sichtbar.
Datei Gültigkeit: Variablen, die außerhalb aller Funktionen deklariert werden, sind im gesamten Datei sichtbar.
Funktion Gültigkeit: Labels in einer Funktion sind im gesamten Funktion sichtbar.
Funktionsprototyp Gültigkeit: Funktionsparameter in einem Prototyp sind bis zum Ende des Prototyps sichtbar.

Sehen wir uns dies in der Praxis an:

#include <stdio.h>

int globalVar = 10;  // Datei Gültigkeit

void exampleFunction() {
int localVar = 20;  // Block Gültigkeit
printf("Innerhalb der Funktion: globalVar = %d, localVar = %d\n", globalVar, localVar);
}

int main() {
printf("In main: globalVar = %d\n", globalVar);
// printf("localVar = %d\n", localVar);  // Dies würde einen Fehler verursachen

{
int blockVar = 30;  // Block Gültigkeit
printf("Innerhalb des Blocks: blockVar = %d\n", blockVar);
}
// printf("blockVar = %d\n", blockVar);  // Dies würde einen Fehler verursachen

exampleFunction();

return 0;
}

Dieses Programm zeigt verschiedene Gültigkeiten:

globalVar ist überall zugänglich.
localVar ist nur innerhalb von exampleFunction zugänglich.
blockVar ist nur innerhalb ihres Blocks in main zugänglich.

Beispiele für verschiedene Arten von C-Bezeichnern

Lassen Sie uns mit einem umfassenden Beispiel abschließen, das verschiedene Arten von Bezeichnern zeigt:

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

#define MAX_SCHUELER 50  // Konstantenbezeichner

// Funktionsprototyp
void printStudentInfo(char name[], int age);

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

int main() {
int schuelerAnzahl = 3;  // Variablenbezeichner
struct Student klasse1[MAX_SCHUELER];  // Array-Bezeichner

// Initialisieren der Schülerdaten
strcpy(klasse1[0].name, "Alice");
klasse1[0].age = 20;
klasse1[0].gpa = 3.8;

strcpy(klasse1[1].name, "Bob");
klasse1[1].age = 22;
klasse1[1].gpa = 3.5;

strcpy(klasse1[2].name, "Charlie");
klasse1[2].age = 21;
klasse1[2].gpa = 3.9;

// Ausgeben der Schülerinformationen
for (int i = 0; i < schuelerAnzahl; i++) {
printStudentInfo(klasse1[i].name, klasse1[i].age);
}

return 0;
}

// Funktionsdefinition
void printStudentInfo(char name[], int age) {
printf("Schüler: %s, Alter: %d\n", name, age);
}

In diesem Beispiel haben wir verschiedene Arten von Bezeichnern verwendet:

Konstantenbezeichner: MAX_SCHUELER
Funktionsbezeichner: main, printStudentInfo
Strukturbezeichner: Student
Variablenbezeichner: schuelerAnzahl, name, age, gpa
Array-Bezeichner: klasse1

Jeder Bezeichner spielt eine entscheidende Rolle dabei, unseren Code funktional und lesbar zu machen.

Und das war's, meine kodierenden Lehrlinge! Wir haben die Welt der C-Bezeichner durchquert, von ihrer grundlegenden Definition bis zu komplexen Beispielen. Denken Sie daran, dass die Wahl guter Bezeichner wie das Auswählen des richtigen Zauberzauber ist – es kann einen großen Unterschied in Ihren Kodierungsabenteuern machen. Bleibt am Üben, bleibt neugierig, und bevor ihr es wisst, werdet ihr C-Programmierzauberer wie ein Profi! Frohes Coden!

Credits: Image by storyset