halo

Modul4/automat.c

@@ -8,9 +8,9 @@
 *
 *
 \**********************************************************************/
-#include <stdio.h>              // Standard Ein-/Ausgabe
+#include <stdio.h>
-#include <stdlib.h>             // Standardbibliothek (z.B. für malloc)
+#include <stdlib.h>
-#include "automat.h"            // Eigene Headerdatei für Automatentypen und -funktionen
+#include "automat.h"
 /*--- #defines -------------------------------------------------------*/
 /* Macro zur Ermittlung der Array Groesse */
 #define SIZE_OF(a) (sizeof((a))/ sizeof(*(a))) // Gibt die Anzahl der Elemente eines Arrays zurück

dualrech.c

@@ -9,22 +9,22 @@ int ist_dual(const char *s) {
             return 0; // Nicht erlaubt, also keine Dualzahl
         else
             s++; // Nächstes Zeichen prüfen
-    return 1; // Alles ok, Dualzahl
+    return 1; // Passt, Dualzahl
 }
 
-/*Gibt die 32-Bit-Binärdarstellung einer Zahl aus. Es werden immer 32 Zeichen (Bits) ausgegeben, auch führende Nullen.*/
+/*Gibt die 32-Bit-Binärdarstellung einer Zahl aus.
+Beginnt beim höchsten Bit (31) und prüft jedes Bit.
+Gibt für jedes Bit ‘1’ oder ‘0’ aus (auch führende Nullen).*/
 void print_bin(int n) {
     for (int i = 31; i >= 0; i--)
         putchar((n >> i) & 1 ? '1' : '0');
 }
 
-/*
+/*Erwartet 3 Argumente:
- * Hauptprogramm: Erwartet 3 Argumente:
+  1. Operand (als Dualzahl, z.B. "1011")
- * 1. Operand (als Dualzahl, z.B. "1011")
+  2. Operator (als einzelnes Zeichen: + - * / & ^)
- * 2. Operator (als einzelnes Zeichen: + - * / & ^)
+  3. Operand (als Dualzahl)
- * 3. Operand (als Dualzahl)
+  Führt die Operation aus und gibt das Ergebnis als Binärzahl und Hexadezimalzahl aus.*/
- * Führt die Operation aus und gibt das Ergebnis als Binärzahl und Hexadezimalzahl aus.
- */
 int main(int argc, char *argv[]) {
     // Prüfen, ob genau 3 Argumente übergeben wurden (Programmname + 3 = 4)
     if (argc != 4) {
@@ -33,8 +33,12 @@ int main(int argc, char *argv[]) {
     }
 
     // Argumente zuweisen
+    /*a: erster Operand (als String)
+    op: Operator (als String)
+    b: zweiter Operand (als String)
+    ok: Flag, ob alles gültig ist*/
     char *a = argv[1], *op = argv[2], *b = argv[3];
-    int ok = 1; // Flag, ob alles gültig ist
+    int ok = 1;
 
     // Prüfen, ob beide Operanden gültige Dualzahlen sind
     if (!ist_dual(a)) {

numausg.c

@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[]) { //Kommandozeilenargumente und Array der Argumente als strings
     // Prüfen, ob ein Dateiname als Argument übergeben wurde
     if (argc < 2) {
         printf("Bitte Dateinamen als erstes Argument angeben.\n");

queue.c

@@ -10,33 +10,30 @@
 #include "queue.h"
 
 /*--- Struktur eines Listenelements ----------------------------------*/
-/*
+
- * Ein Listenelement (Node) besteht aus:
+/*Ein Listenelement (Node) besteht aus:
- * - value: dem gespeicherten Wert (hier ein int)
+ - value: dem gespeicherten Wert (hier ein int)
- * - next:  Zeiger auf das nächste Element in der Liste
+ - next:  Zeiger auf das nächste Element in der Liste
  */
 typedef struct Node {
    int value;
    struct Node *next;
-} Node;
+} Node_t;
 
 /*--- Modulglobale Variablen: Zeiger auf Kopf und Ende der Liste -----*/
-/*
+
- * head: Zeigt auf das erste Element der Queue (Kopf)
+/*head: Zeigt auf das erste Element der Queue (Kopf)
- * tail: Zeigt auf das letzte Element der Queue (Ende)
+ tail: Zeigt auf das letzte Element der Queue (Ende)
- * Sind beide NULL, ist die Queue leer.
+ Sind beide NULL, ist die Queue leer.*/
- */
+static Node_t *head = NULL;
-static Node *head = NULL;
+static Node_t *tail = NULL;
-static Node *tail = NULL;
 
 /*--- put(): Einfügen am Ende der Liste ------------------------------*/
-/*
+/*Fügt eine neue Zahl am Ende der Queue ein.
- * Fügt eine neue Zahl am Ende der Queue ein.
+ Rückgabewert: TRUE bei Erfolg, FALSE bei Speicherfehler.*/
- * Rückgabewert: TRUE bei Erfolg, FALSE bei Speicherfehler.
- */
 Bool put(int zahl) {
    // Speicher für neues Element reservieren
-   Node *newNode = (Node *)malloc(sizeof(Node));
+   Node_t *newNode = (Node_t *)malloc(sizeof(Node_t));
    if (newNode == NULL) {
        fprintf(stderr, "Speicher konnte nicht freigegeben werden.\n");
        return FALSE; // Fehler: kein Speicher verfügbar
@@ -57,17 +54,16 @@ Bool put(int zahl) {
 }
 
 /*--- get(): Entfernt das erste Element ------------------------------*/
-/*
+
- * Entfernt das erste Element (Kopf) der Queue und gibt dessen Wert zurück.
+/*Entfernt das erste Element (Kopf) der Queue und gibt dessen Wert zurück.
- * Ist die Queue leer, wird QLEER zurückgegeben und eine Fehlermeldung ausgegeben.
+ Ist die Queue leer, wird QLEER zurückgegeben und eine Fehlermeldung ausgegeben.*/
- */
 int get(void) {
    if (head == NULL) {
        // Die Queue ist leer
        fprintf(stderr, "Fehler: Queue ist leer.\n");
        return QLEER;
    }
-   Node *tmp = head;         // Temporärer Zeiger auf das erste Element
+   Node_t *tmp = head;         // Temporärer Zeiger auf das erste Element
    int value = tmp->value;   // Wert des ersten Elements speichern
    head = head->next;        // Kopf auf das nächste Element setzen
    if (head == NULL) {