© Liashko/Shutterstock.com
Objektorientierte Programmierung in C - Teil 2

ANSI C goes OOP - jetzt erst recht


Im vorherigen Artikel haben wir uns mit der Geschichte und den Grundlagen von objektorientierter Programmierung beschäftigt. In diesem Artikel vertiefen wir das Thema. Ich demonstriere anhand eines komplexeren Beispiels (einer einfachen Job Queue) das Zusammenspiel mehrerer Klassen und gehe dabei auch auf das Thema der Wiederverwendung und Vererbung ein.

Am Beispiel einer einfachen Stringklasse habe ich in der letzten Ausgabe einfache Techniken der OOP in C in verschiedenen Variationen demonstriert. Im Mittelpunkt standen dabei Konzepte wie die Trennung von Schnittstelle und Implementierung, Information Hiding (Verbergen privater Daten), sowie die Bereitstellung von Methoden für entsprechende Datenstrukturen. Damit sind alle Grundsteine gesetzt, um tiefer in die Materie einzutauchen.

Fallbeispiel: eine Job Queue

Als Beispiel für eine vertiefende Betrachtung der OOP in C soll uns eine einfache Job Queue dienen. Eine Job Queue kann benutzt werden, um den Vorgang der Erstellung von Aufgaben von deren Ausführung zu entkoppeln und so die asynchrone Verarbeitung zu ermöglichen. Näheres zu Job Queues findet sich unter [1].

Um das Beispiel einfach zu halten, gehen wir von folgendem Anwendungsfall aus: Es werden Jobs für Systemverwaltungsaufgaben generiert, die Dateien entweder löschen oder ein Backup einer Datei in einem übergebenen Pfad anlegen. Diese werden zunächst alle in die Job Queue eingestellt. Nachdem alle Jobs eingestellt wurden, wird die Jobverarbeitung der Job Queue gestartet, die die eingestellten Jobs nacheinander abarbeitet.

In einer realen Anwendung würden die Joberzeugung und die Jobverarbeitung in separaten Prozessen erfolgen. Dazu müssten Kommunikationsmöglichkeiten zwischen diesen Prozessen geschaffen werden, indem die Jobs in eine Datei oder eine Datenbank geschrieben würden. Das Erzeugerprogramm könnte die Jobs z. B. tagsüber in eine Jobdatei schreiben, die ein Job-Queue-Prozessor dann nachts ausliest und verarbeitet. Ein anderer Weg wäre das Ablegen in einer Datenbank. In unserem Beispiel werden wir darauf aber nicht eingehen, d. h. Joberzeugung und -verarbeitung geschehen durch dasselbe Programm. Abbildung 1 zeigt ein UML-Klassendiagramm für die beteiligten Klassen.

schmidt_oop_1.tif_fmt1.jpgAbb. 1: UML-Diagramm für die beteiligten Klassen

Das Hauptprogramm („Clientcode“) erstellt eine Instanz der Klasse JobQueue und benutzt dann die Klassen DeleteJob und BackupJob, um Lösch- bzw. Sicherungsjobs zu erstellen. Diese werden dann der Job Queue hinzugefügt. Abschließend wird die Jobverarbeitung über die Methode run() der Job Queue gestartet. Diese iteriert über die Jobs und ruft jeweils deren process()-Methode auf. Für die interne Datenspeicherung der Jobs wird eine Klasse JobList benutzt.

Wiederverwendung und Vererbung – die „Job“-Klassen

Wiederverwendung stellt einen wichtigen Aspekt der OOP dar. Wiederwendung kann auf verschiedenen Ebenen betrachtet werden:

  • Wiederverwendung von Implementierungen

  • Wiederverwendung von Schnittstellen

Wiederverwendung von Implementierungen wird benutzt, um existierende Algorithmen und Datenstrukturen im Sinne von DRY (Don’t Repeat Yourself), vgl. [2], nutzen zu können. Vor der Einführung der OOP wurde Wiederverwendung im Wesentlichen über Funktionen, Prozeduren und Module realisiert. In der OOP wird Wiederverwendung von Implementierungen über die Wiederverwendung von Klassen und Schnittstellen realisiert. Als Beispiel kann die im letzten Artikel vorgestellte wiederverwendbare Stringklasse dienen.

Wiederverwendung von Schnittstellen ist dann von Interesse, wenn eine Menge von Klassen dieselben Methodensignaturen haben soll (im Smalltalk-Jargon: auf dieselben Nachrichten reagieren können soll), es also entscheidend ist, dass an einer bestimmten Stelle Instanzen verschiedener Klassen verwendet werden können sollen. Diese Art von Wiederverwendung ist insbesondere für unsere Job Queue von Interesse, die verschiedene Arten von Jobs aufnehmen soll. Abbildung 2 zeigt als Ausschnitt ein UML-Klassendiagramm für die Hierarchie der Job-Klassen.

schmidt_oop_2.tif_fmt1.jpgAbb. 2: UML-Diagramm für die „Job“-Klassen

Ganz oben in der Jobhierarchie befindet sich die Klasse Job. Sie hat als Attribute eine eindeutige Identifikation id und eine Priorität priority als Integer. Es gibt Methoden zur Erzeugung eines Jobs (Job_new()), zur Erzeugung der ID (getId()), zur Freigabe des Speichers (delete()) sowie eine Methode zur Abarbeitung eines Jobs (process()).

Listing 1

/* job.h */
 
#include "cstring.h"
 
#ifndef JOB_H
  #define JOB_H
 
  /* class definition */
  struct JobStruct {
    char *jobClass;
    CStringPtr id;
    int priority;
    int (*process) (void *jobPtr);
    void (*delete) (void *jobPtr);
  };
 
  typedef struct JobStruct Job;
 
  /* constructor */
  Job Job_new(int priority);
 
  /* process() base implementation */
  int Job_process(void *self);
 
  /* destructor */
  void Job_delete(void *self);
 
#endif

Listing 1 zeigt die Headerdatei für die Job-Klasse. Die Klasse wird in der im letzten Artikel beschriebenen Weise als struct modelliert, die Methoden als Funktions-Pointer des struct, denen Funktionen mit passender Signatur entsprechen. Das Konstrukt

#ifndef JOB_H
  #define JOB_H
  <Quellcode>
#endif 

stellt mithilfe des Präprozessors sicher, dass der Headercode bei mehrfacher Inklusion nur einmal kompiliert wird, da es sonst beim Kompilieren wegen vermeintlicher Neudefinition zu Fehlermeldungen kommt.

Ansonsten ist der Code an dieser Stelle selbsterklärend. Eine Besonderheit stellt hier das Attribut jobClass dar, das eine Beschreibung der Klasse des Jobs als char Pointer aufnimmt.

Listing 2

/* file job.c */
 
#include <stdlib.h>
#include <stdio.h>
 
#include "job.h"
 
/* job class */
static char* JOBCLASS = "BaseJob";
 
/* private method to create an ID */
static char *getJobId() {
  char* jobIdCharPtr = malloc(sizeof(char[5]));
  static int jobNo = 0;
  sprintf(jobIdCharPtr, "%05d", jobNo);
  jobNo++;
  return jobIdCharPtr;
}
 
/* constructor */
Job Job_new(int priority) {
  Job job;
  job.jobClass = JOBCLASS;
  job.id = CString_new(getJobId());
  job.priority = priority;
  job.process = &Job_process;
  job.delete = &Job_delete;
  return job;
}
 
/* process() base implementation */
int Job_process(void *self) {
  Job* job = (Job*) self;
  printf(
    "processing Job class '%s' #%s\n", 
    job->jobClass,
    CString_asCharPtr...

headline from sands settings