Betriebs- und Kommunikationssysteme, 22./23.10.2015

Organisatorisches

Kontakt

Modul bestehen

  • 3 Säulen (Klausur, aktive/passive Teilnahme)
  • Klausur
    • Modulnote = Klausurnote
  • passive Teilnahme
    • keine Anwesenheitspflicht
  • aktive Teilnahme
    • einmal vorrechnen
    • 8 Übungszettel mit mindestens (1,1) Punkten

Übungszettel

Abgabezyklus
Abgabezyklus
  • Wöchentliche Ausgabe der Zettel
  • 2 Wochen Bearbeitungszeit
  • Abgabe: Freitags 10:00 Uhr
  • Bearbeitung und Abgabe in 2er-Gruppen
  • Namen auf allen Abgaben

Abgabe der Übungszettel

  • Papierabgabe
    • In mein Fach (1. OG)
    • Tackern!
    • Namen und Tutorium (Wochentag) auf der Abgabe
    • Bei Rechercheaufgaben: Quellen angeben
  • Elektronische Abgabe
    • Per E-Mail schicken (nur einer aus der Gruppe)
    • Nur die C-Datei, ordentlich formatiert, nicht zippen, Dateiname: nachname1-nachname2.c
    • Namen und Tutorium (Wochentag) als Kommentar im Kopf
    • E-Mail-Betreff: [TI3] Abgabe 7, Nachname1, Nachname2
    • Programme müssen auf Poolrechnern kompilieren und laufen
  • Plagiate: Aberkennung der aktiven Teilnahme

Tutorenfächer

Tutorenfächer (vollständiger Grundriss)
Tutorenfächer (vollständiger Grundriss)

Bewertung der Übungszettel

  • Tupel-System
  • Die Theorie- und die Programmier-Aufgaben werden getrennt bewertet
  • Theorie-Aufgabe
    • 1 Punkt: ein sinnvoller Ansatz zu erkennen
    • 2 Punkte: mindestens gut (nur kleinere Fehler)
  • Programmier-Aufgaben
    • 1 Punkt: kompiliert und ein sinnvoller Ansatz ist zu erkennen
    • 2 Punkte: alle Teilaufgaben bearbeitet, Testfälle werden größtenteils erfüllt, (fast) keine Warnungen, sinnvolle Kommentare vorhanden
    • 3 Punkte: Aufgaben perfekt bearbeitet
  • Bestehen: Jeweils mindestens 1 Punkt

Klausur

  • Klausurtermin: 12.02.2015
  • neue Prüfungsordnung: 120 min Klausur
    • 60 min TI2 / Rechnerarchitektur
    • 60 min TI3 / Betriebs- und Kommunikationssysteme
  • alte Prüfungsordnung: 90 min Klausur
    • TI3-Teil aus der anderen Klausur + zusätzliche Aufgabe(n)
  • Anmeldung im Campus-Management absolut notwendig

C-Crashkurs

Erstes C-Programm

1
2
3
4
5
6
7
8
9
10
11
/*
    Ein erstes C-Programm, welches "Hallo Welt!"
    auf der Konsole ausgibt.
 */

#include <stdio.h>

int main(void)
{
    printf("Hallo Welt!\n");
}

Kompilieren

gcc -Wall -Wextra -Wpedantic -std=c99 -o hello hello.c

  • -Wall: schalte Warnungen an
  • -Wextra: schalte zusätzliche Warnungen an (nicht zwingend)
  • -Wpedantic: Warnungen bei nicht ISO-C-konformem Code
  • -std=c99: Lege verwendeten C-Standard fest
  • -o hello: ausführbare Datei soll hello heißen

Formatieren

  • Quellcode formatieren, sodass er gut lesbar ist
    • Einrücken von logischen Unterabschnitten
    • Nicht mehrere Befehle in einer Zeile
    • Kommentare
    • Immer geschweifte Klammern verwenden, auch bei einzeiligen Befehlen
  • Einheitliche Formatierung beibehalten

  • Formatierung mittels externem Programm AStyle möglich
    • astyle --style=linux --add-brackets datei.c
    • Leider (noch) nicht auf den Poolrechnern vorhanden

Tutorials

C-Beispiele

  • Hier ein kleines C-Programm, welches genau einen Kommandozeilenparameter erwartet und diesen wieder ausgibt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
    Ein kleines Programm, welches den ersten Kommandozeilenparameter wieder auf
    der Konsole ausgibt.

    Es werden demonstriert:
    - Einbinden von Funktionen aus Standardbibliotheken
    - Unterschied: Deklaration und Implementierung
    - Selbst Funktionen schreiben
    - Array-Zugriffe
 */

#include <stdlib.h> // EXIT_SUCCESS, EXIT_FAILURE
#include <stdio.h>  // printf()
#include <stdint.h> // Standard-Integer

/*  Funktion wird nur deklariert, jedoch nicht implementiert.
    Ohne diese Deklaration könnten wir die Funktion nicht in der main-Funktion
    benutzen. */
int myPrintFunction(char *string);

int main(int argc, char *args[])
{
    // argc == <#Elemente in args>
    // argv[0] == <Name des Programms>
    // argv[i] == <i-ter Kommandozeilen-Parameter>
    if (argc != 2) {
        return EXIT_FAILURE;
    }

    return myPrintFunction(args[1]);
}

// Funktion wird nun implementiert.
int myPrintFunction(char *string)
{
    int32_t result;
    result = printf("%s\n", string);
    // printf gibt negative Zahl zurück,
    if (result < 0) {
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}
  • Hier ein weiteres Beispiel, welches das Lesen und Schreiben in Dateien demonstriert.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/*
    Ein kleines Programm um zu zeigen, wie man Dateien einliest.

    Das ganze baut ziemlich direkt hierauf auf:
    https://de.wikibooks.org/wiki/C-Programmierung:_Dateien
 */

#include <stdlib.h>
#include <stdio.h>
#include <inttypes.h>

int main(void)
{
    /*  Wenn wir eine Datei öffnen bekommen wir einen Zeiger (daher der Stern)
        vom Datentyp FILE zurück -- dafür legen wir eine Variable an */
    FILE *datei;

    /*  Wir legen zusätzlich ein Char-Array (^= String) mit 101 Einträgen an, in
        dem wir beim Einlesen Daten zwischenspeichern können. Ebenso legen wir
        dafür eine int-Variable an. */
    char text[100 + 1];
    int zahl;

    /*  Wir öffnen die Datei. Zuerst benötigen wir den Dateinamen und dann, wie
        sie geöffnet werden soll (lesend, schreibend, …). Wir wollen jetzt erst
        mal etwas in die Datei schreiben. */
    datei = fopen("testdatei", "w");

    /*  fopen gibt NULL zurück, wenn die Datei nicht geöffnet werden konnte. */
    if (datei == NULL) {
        printf("Konnte Datei nicht zum schreiben öffnen.\n");
        return EXIT_FAILURE;
    }

    /*  fprintf funktioniert analgo zu printf, schreibt jedoch die Ausgabe in
        die Datei statt auf die Standardausgabe. */
    fprintf(datei, "Die_Antwort_auf_alles_ist?\n");
    fprintf(datei, "%d\n", 42);

    /*  Wenn wir fertig sind, müssen wir die Datei schließen. */
    fclose(datei);


    printf("Datei erfolgreich geschrieben.\n");


    /*  Wir öffnen die Datei zum lesen. */
    datei = fopen("testdatei", "r");

    /*  fopen gibt NULL zurück, wenn die Datei nicht geöffnet werden konnte. */
    if (datei == NULL) {
        printf("Konnte Datei nicht zum lesen öffnen.\n");
        return EXIT_FAILURE;
    }

    /*  fscanf versuch das angegebene Muster (gegenteilig zu fprintf) aus der
        Datei zu lesen und in die übergebenen Variablen zu speichern.
        Da die Variable "text" schon ein Zeiger ist (Arrays und Strings sind
        immer Zeiger) können wir einfach "text" übergeben. */
    fscanf(datei, "%s\n", text);
    /*  Wir schreiben in das letzte Feld unser Zeichenkette ein Null-Byte, damit
        bei der Ausgabe nicht zu viel ausgegeben wird, falls der String in der
        Datei länger war als 100 Zeichen (dann haben wir aber auch noch ein
        anderes Problem, nämlich einen Pufferüberlauf). */
    text[100] = '\0';
    printf("In der ersten Zeile stand: %s\n", text);

    /*  Aus der nächsten Zeile wollen wir die Zahl einlesen. Hier ist es
        wichtig, dass wir einen Zeiger auf die eigentliche Variable übergeben,
        um fscanf zu sagen, wo er das Ergebnis hinspeichern soll. */
    fscanf(datei, "%d\n", &zahl);
    printf("In der zweiten Zeile stand: %d\n", zahl);

    /*  Wenn wir fertig sind, müssen wir die Datei schließen. */
    fclose(datei);
}