Ein Doppel-Axel in C (1) -- qsort, bsearch, lsearch

Ein Doppel-Axel in C (1) — qsort,
bsearch, lsearch
Axel-Tobias Schreiner, Universität Ulm
Kernighan und Ritchie’s fünftes Kapitel 1 ist für jeden C Programmierer natürlich
Pflicht. Die Kür besteht bei System V offensichtlich darin, Suchfunktionen nicht
mehr selbst zu programmieren, sondern die verschiedenen Lösungen zu diesem
Thema aus der Standard-Bücherei korrekt einsetzen zu können. In dieser und der
nächsten Ausgabe der Sprechstunde möchte ich Beispiele für die Verwendung der
Funktionen qsor t(), bsearch(), hsearch(), lsearch() und tsearch() zeigen und ein
bißchen ihre Stärken und Schwächen diskutieren.
Das Problem wird durch die System V Interface Definition nicht unbedingt
vereinfacht: zu den Suchfunktionen gibt es Beispiele, aber die sind nicht immer
korrekt programmiert. Bei ähnlicher Funktionalität ist außerdem die Benutzung der
verschiedenen Funktionen ziemlich verschieden, und die Beschreibung gibt keinen
Hinweis, welche Lösung und Problemstellung am besten harmonieren. Die
eigentliche Schwierigkeit liegt aber darin, daß die Funktionen zur Manipulation
nahezu beliebiger Information eingerichtet sind, und daß dies natürlich mit Hilfe einer
recht ‘‘flexiblen’’ Interpretation von Zeigern erreicht wird.
1 ...über Zeiger und Vektoren.

Sor tieren — ‘‘qsor t()’’
qsor t() gab es ‘‘schon immer’’: mit dieser Funktion kann man die Elemente eines
beliebigen Vektors nach beliebigen Kriterien sortieren. Zu beachten ist, daß die
Elemente selbst vertauscht werden (je nach Größe ist das aufwendig, denn es
finden nicht nur die minimal notwendige Anzahl Tauschoperationen statt), und daß
die Sortierung nicht stabil ist, das heißt, daß die ursprüngliche Reihenfolge von zwei
gleichen Elementen nicht notwendigerweise erhalten bleibt — auch gleiche
Elemente werden möglicherweise vertauscht. qsor t() hat folgende Deklaration:
void qsort(base, nel, width, compar)
char * base; /* Anfang des Vektors */
unsigned nel, width; /* Anzahl Elemente, Groesse */
int (* compar)(); /* Vergleichsfunktion */
Oft ist base der Name eines Vektors — praktisch nie mit Elementen vom Typ char
— und width ist die Elementgröße. Eine einfachere Schnittstelle, die auch die
(unnötigen) Umwandlungen erzwingt, könnte man zum Beispiel so definieren:
void qsort();
#define Qsort(base, nel, compar) \
(qsort((char *) (base), /* Anfang der Tabelle */ \
(unsigned) (nel), /* Anzahl Elemente */ \
(unsigned) sizeof *(base), /* Elementgroesse */ \
(int (*)()) (compar))) /* Vergleichsfunktion */
Bei einem Vektor könnte man zwar die Anzahl der Elemente vom C Compiler
berechnen lassen und so auf den Parameter nel auch noch verzichten, aber es wird
sich bei unseren Beispielen zeigen, daß wir oft nur teilweise gefüllte oder mit Hilfe
von Zeigern dynamisch angelegte Vektoren sortieren, bei denen der Compiler die

tatsächliche Anzahl der Elemente nicht feststellen kann.
Im Makro Qsor t() wird die Elementgröße vom Compiler mit sizeof aus dem Typ
der Anfangsadresse bestimmt. Die expliziten Umwandlungen provozieren zum
Beispiel eine Fehlermeldung, wenn weder ein Vektorname noch ein Zeiger als erstes
Argument übergeben wird, oder wenn kein Funktionsname oder Zeiger als drittes
Argument steht. Sollte die Anzahl der Elemente versehentlich als long-Wert
angegeben sein, wird sie stillschweigend umgewandelt. (Ähnliche Effekte werden
in Zukunft die Funktions-Prototypen von ANSI-Standard-C erzielen.)
Betrachten wir sicherheitshalber ein einfaches Beispiel auch für qsor t(): eine
kleine Tabelle aus Namen und Zahlen soll je nach Wunsch sortiert werden. Hier ist
das Hauptprogramm:
#include
#include "main.h" /* unix/mail 3/84 */
#define DIM(x) (sizeof (x) / sizeof *(x)) /* Elemente in Vektor */
typedef struct { /* Beispiel fuer Objekt */
char string[30]; /* Name */
int number; /* Zahl */
int info; /* eindeutige, andere Information */
} Object;
/*** hierher gehoeren die Vergleichsfunktionen —— siehe unten ***/
MAIN
{ Object table[100]; register int t = 0, i;
while (scanf("%s %d", table[t].string, & table[t].number) == 2)
{ table[t].info = t;
if (++ t >= DIM(table))
break;
}

Mit scanf() lesen wir einfach abwechselnd einen Namen und eine Zahl jeweils in ein
Tabellenelement ein. Läuft die Tabelle über, oder finden wir kein geeignetes Paar
mehr, wird der Lesevorgang beendet. In der .info-Komponente speichern wir noch
die Eingabeposition des Tabellenelements, damit wir anschließend gewisse Effekte
beim Sortieren demonstrieren können.
Worte wie MAIN wurden in der ersten Sprechstunde in unix/mail 3/1984 definiert.
Unser Hauptprogramm soll mit der Option -n die .number-Komponenten, mit der
Option -s die .string-Komponenten und mit der Option -= beide Komponenten
sortieren:
}
OPT
ARG ’n’: Qsort(table, t, cmpn); /* —n .number sortieren */
ARG ’s’: Qsort(table, t, cmps); /* —s .string sortieren */
ARG ’=’: Qsort(table, t, cmp); /* —= kombiniert sortieren */
OTHER fputs("q [—ns=] < testdata\n", stderr), exit(1);
ENDOPT
for (i = 0; i < t; ++ i)
printf("%d %s %d\n",
table[i].info, table[i].string, table[i].number);
table[] ist unsere Tabelle, ein Vektor von Object-Strukturen, und in t haben wir die
eingelesenen Elemente gezählt — dieser Wert kann Null sein. Die verschiedenen
Aufrufe von qsor t() unterscheiden sich nur in den Vergleichsfunktionen: cmpn() und
cmps() sortieren in bezug auf eine Komponente, cmp() in bezug auf zwei. Aus der
Beschreibung von qsor t() weiß man, daß die Vergleichsfunktion jeweils mit zwei
Zeigern auf Tabellenelemente aufgerufen wird und sich dann wie strcmp() verhalten
muß. Man kann es sich auch so merken: jeder der beiden Parameter der
Vergleichsfunktion hat den Typ, den auch das erste Argument — der Zeiger auf den

Tabellenanfang — von qsor t() hat. Hier sind die Vergleichsfunktionen für unser
Beispiel:
int cmps(a, b) /* .string vergleichen */
register Object * a, * b;
{
return strcmp(a—>string, b—>string);
}
int cmpn(a, b) /* .number vergleichen */
register Object * a, * b;
{
return a—>number < b—>number ? —1 : a—>number > b—>number;
}
int cmp(a, b) /* kombinierter Vergleich */
register Object * a, * b;
{ register int cond;
return (cond = cmps(a, b)) ? cond : cmpn(a, b);
}
Strings vergleicht man natürlich mit strcmp(). Bei Zahlen muß man aufpassen: nicht
einmal für zwei int-Werte sollte man die Differenz als Resultat des Vergleichs
liefern! Auf einer 16-Bit Maschine hat 32767 - (-2) angeblich den Wert -32767, und
der repräsentiert nicht gerade die Tatsache, daß 32767 größer als -2 ist. cmp()
vergleicht zuerst die .string-Komponenten; sind sie gleich, hängt das Resultat von
den .number-Komponenten ab.
Das Beispiel sollte vor allem demonstrieren, daß man mit qsor t() beliebige
Vektoren sortieren kann. Außer den Sortierschlüsseln können die Vektorelemente
auch andere Information enthalten — das Sortierkriterium ist völlig unter Kontrolle
der Vergleichsfunktion. Betrachten wir noch ein paar Probeläufe:

$ q < data $ q -s < data $ q -n < data
0 string 10 5 String 20 0 string 10
1 string 20 4 String 10 2 string 10
2 string 10 0 string 10 4 String 10
3 string 20 3 string 20 3 string 20
4 String 10 1 string 20 5 String 20
5 String 20 2 string 10 1 string 20
Links wird die Eingabe unsortiert ausgegeben. Rechts wird numerisch, in der Mitte
werden die Namen sortiert. Man sieht in beiden Beispielen, daß die
Eingabereihenfolge ‘‘gleicher’’ Elemente zerstört werden kann.
$ q -= < data $ q -sn < data $ q -nn < data
4 String 10 0 string 10 0 string 10
5 String 20 4 String 10 2 string 10
2 string 10 2 string 10 4 String 10
0 string 10 3 string 20 3 string 20
1 string 20 5 String 20 1 string 20
3 string 20 1 string 20 5 String 20
Links wird mit cmp() nach Namen und sekundär nach Zahlen sortiert. Das ist völlig
anders, als wenn (wie in der Mitte) erst einmal ganz nach Namen und dann das
Resultat nach Zahlen sortiert wird. Im mittleren Beispiel wird eigentlich die mittlere
Ausgabe von vorher nochmals neu nach der .number-Komponente sortiert. Man
sieht auch hier sehr deutlich, daß qsor t() instabil ist.
Im rechten Beispiel wird zweimal numerisch sortiert, also die vorhergehende
rechte Ausgabe nochmals neu nach dem gleichen Sortierkriterium. Man sieht, daß
sogar bei einer ursprünglich sortierten Tabelle noch zwei Einträge vertauscht

werden!
Tausch-Puzzle — sortieren mit Index-Vektor
In dieser Ausgabe der unix/mail habe ich auch über ein SpreadSheet berichtet, das
eine Sortierfunktion besitzt. Im Spreadsheet kann das Vertauschen von Teilzeilen
oder -spalten eine sehr teure Operation sein. Meine Lösung besteht darin,
stellvertretend für den SpreadSheet-Ausschnitt einen Vektor p[] mit Indizes der
betroffenen SpreadSheet-Zeilen oder -Spalten von qsor t() sortieren zu lassen:
int n; /* Anzahl zu sortierende Objekte */
int low; /* Index des ersten Objekts */
int (* cmp)(); /* zustaendige Vergleichsfunktion */
short * p; /* dynamisch angelegter Vektor der Indizes */
int i, j, k;
if (! (p = (short *) malloc(n * sizeof(short))))
fatal("no room");
for (j = 0; j < n; ++ j)
p[j] = j+low;
qsort(p, n, sizeof(short), cmp);
Zuerst werden n, low und cmp aus dem Aufruf im SpreadSheet decodiert. Der
Vektor p[] wird so initialisiert, daß p[j] der Index (Zeilen- oder Spaltennummer) des
Objekts im SpreadSheet ist, das sozusagen auf Platz j in der zu sortierenden Tabelle
steht. Der durch cmp festgelegten Vergleichsfunktion werden Zeiger auf zwei
solche Indexwerte angeboten, und die Funktion kann damit im SpreadSheet die
Objekte finden und vergleichen.
Ist qsor t() fertig, wurden die Indexwerte in p[] so vertauscht, daß in p[j] jetzt der
Index des Objekts im SpreadSheet steht, das eigentlich in Indexposition low+j im

SpreadSheet stehen sollte um das Sortierkriterium zu erfüllen. Gilt (wie das vor
Aufruf von qsor t() ja der Fall war) p[j] == low+j, sitzt das Objekt schon richtig; gilt
das nicht, müssen wir Objekte tauschen. Das Puzzle besteht darin, wie man
Ordnung mit möglichst wenig Tauschoperationen erreicht:
for (i = 0; i < n; ++ i)
if (p[i] != i+low)
for (j = i; k = j, j = p[k]—low, p[k] = k+low, p[j] != j+low; )
/* Objekte j+low, k+low tauschen */
Zugegeben, Thomas Mandry und ich haben Tage gebraucht, um diese Lösung zu
erfinden und zu formulieren, aber sie ist dafür doch auch sehr leicht zu verstehen —
oder? 2
Binär suchen — ‘‘bsearch()’’
Muß man ein Element in einem sortierten Vektor finden, kann man bsearch()
verwenden. Diese Funktion vergleicht ein Suchobjekt mit dem mittleren Element
eines Vektorbereichs, und setzt je nach Resultat die Suche in der linken oder rechten
Hälfte fort. Mit höchstens zehn Vergleichen kann man so einen Wert unter tausend
finden. bsearch() verwendet Argumente, die an qsor t() erinnern, und liefert als
Resultat einen Zeiger auf das gesuchte Objekt in der Tabelle oder einen Nullzeiger:
char * bsearch();
#define Bsearch(key, base, nel, compar) \
2 Fans sei soviel verraten: Die äußere Schleife behandelt jedes Element in p[]
einmal. Wenn etwas nicht stimmt, löst die innere Schleife einen der
Permutationszyklen auf, aus denen p[] besteht.

((Object *) bsearch((char *) (key), /* gesuchtes Object */ \
(char *) (base), /* Anfang der Tabelle */ \
(unsigned) (nel), /* Anzahl Elemente */ \
(unsigned) sizeof *(base), /* Elementgroesse */ \
(int (*)()) (compar))) /* Vergleichsfunktion */
Als erstes Argument erwartet bsearch() einen Zeiger auf das Suchobjekt; die
restlichen vier Argumente sind exakt die gleichen wie bei qsor t(). Der Makro
Bsearch() vermeidet wieder die Angabe der Größe eines Elements und sorgt mit
expliziten Umwandlungen für eine gewisse Typenprüfung. Als Resultat liefert
bsearch() einen Zeigerwert; er hat den gleichen Typ wie das erste Argument — der
Zeiger auf das Suchobjekt — und das zweite Argument — der Zeiger auf den
Tabellenanfang — und wie die Zeiger, die an die Vergleichsfunktion übergeben
werden.
In unserem früheren Beispiel können wir das Hauptprogramm so abändern, daß
bei jeder Option noch ein Wert übergeben wird, der dann entsprechend gesucht
wird:
Object table[100]; int t; /* Beispiel einer Tabelle */
static look(str, num, cmp)
char * str; int num; /* Suchargument */
int (* cmp)(); /* Vergleichsfunktion */
{ Object key, * kp; /* Suchobjekt, Resultat */
Qsort(table, t, cmp);
strcpy(key.string, str), key.number = num;
if (kp = Bsearch(& key, table, t, cmp))
printf("%d %s %d\n", kp—>info, kp—>string, kp—>number);
}
MAIN
{ char * str;

}
/*** einlesen, wie im qsort()—Beispiel ***/
OPT
ARG ’n’: PARM look("", atoi(*argv), cmpn); NEXTOPT
ARG ’s’: PARM look(*argv, 0, cmps); NEXTOPT
ARG ’=’: PARM str = *argv; NEXTOPT
PARM look(str, atoi(*argv), cmp); NEXTOPT
OTHER fputs("b [—n num] [—s str] [—= str num] < testdata\n",
stderr), exit(1);
ENDOPT
Object und die drei Vergleichsfunktionen stammen aus dem ersten Abschnitt.
Diesmal muß table[] global definiert werden, damit die Tabelle auch für look()
implizit zur Verfügung steht. look() erhält die zu suchende Information und die
nötige Vergleichsfunktion. Zuerst wird die Tabelle mit qsor t() entsprechend sortiert,
dann wird bsearch() verwendet.
Unsere Tabellenelemente enthalten wieder mehr Information als nur das
Suchargument. Man sieht aber, daß an bsearch() als Suchgegenstand nicht etwa
nur der gesuchte Name oder die Zahl übergeben wird, sondern ein Zeiger auf ein
ganzes Tabellenelement. In dem Tabellenelement muß natürlich nur der Teil
initialisiert sein, den die Vergleichsfunktion tatsächlich betrachtet. Wir initialisieren
nur deshalb immer die .string- und die .number-Komponente, da wir look() für alle
drei möglichen Suchen verwenden.
$ b < data -n 10; $ b < data -n 20 $ b < data -n 10 -n 20
4 String 10 4 String 10
5 String 20 1 string 20
Bei diesen Beispielen werden die gleichen Daten wie für die Beispiele zu qsor t()
verwendet. Links wird jeweils einmal numerisch sortiert und dann gesucht.

Vergleicht man mit der entsprechenden früheren Ausgabe, sieht man, daß bsearch()
von mehreren ‘‘gleichen’’ Tabellenelementen eben das liefert, das durch die
fortgesetzte Halbierung zuerst erreicht wird; das ist nicht unbedingt das erste oder
letzte einer Folge gleicher Elemente. Rechts wird für 20 positionell das gleiche
Tabellenelement wie im linken Beispiel gefunden; look() hat aber dann zweimal
numerisch sortiert und, wie bei qsor t() schon demonstriert, hat damit 1 an die Stelle
von 5 gebracht.
Die eigentliche Falle besteht bei bsearch() wohl darin, daß man die falschen
Zeigertypen in der Vergleichsfunktion erwartet. Hier ist noch ein Beispiel, bei dem
Strings, nämlich die Argumente des Kommandos, verwendet werden:
typedef char * Object; /* Objekte sind Strings */
static int cmp(a, b) Object * a, * b; /* Zeiger auf Objekte,... */
{
return strcmp(*a, *b); /* ...erst *a ist ein String! */
}
main(argc, argv) Object argv[]; /* (Object[]) ist (char **) */
{ char buf[100];
Object key = buf;
Qsort(argv, argc, cmp);
while (gets(buf))
if (! Bsearch(& key, argv, argc, cmp))
puts("not found");
}
argv[] ist der Vektor, der sortiert wird, und in dem gesucht wird. Das erste
Argument zu bsearch() muß den gleichen Typ besitzen wie das zweite Argument,
argv, und dieser Typ wird auch an cmp() geliefert. buf[] muß wirklich ein Vektor
sein, denn gets() hinterlegt dort die Eingabezeichen. buf ist zwar ein Zeigerwert,

kann aber nicht erstes Argument für bsearch() sein, denn buf hat den Typ char *
und argv ist char **. Fehlt ein Sternchen, kann man prinzipiell mit & eins erzeugen:
& buf müßte nach diesem Rezept den richtigen Typ, ein Sternchen mehr, also char
**, besitzen — als Vektorname ist buf aber eine Adreßkonstante, und von der kann
und darf man keine Adresse bilden. Die korrekte Lösung besteht, wie gezeigt, in der
Verwendung von key, einer Variablen, in der die konstante Adresse buf hinterlegt ist,
und deren Adresse wieder an bsearch() übergeben werden kann.
Linear suchen — ‘‘lsearch()’’ und ‘‘lfind()’’
lfind() hat fast die gleichen Argumente wie bsearch() und exakt den gleichen Effekt:
Ein Objekt wird in einem Vektor unter Kontrolle einer Vergleichsfunktion gesucht. Ist
das Objekt vorhanden, liefert lfind() einen Zeiger als Resultat, ist’s nicht da, gibt’s
einen Nullzeiger. Der kleine Unterschied ist, daß bsearch() die Anzahl der
Tabellenelemente als drittes Argument erhält, lfind() aber einen Zeiger auf diese
Anzahl. Der große Unterschied ist, daß lfind() linear sucht, also vom ersten
Tabellenelement sequentiell bis zum letzten. Das kann extrem lang dauern, aber
dafür braucht die Tabelle nicht sortiert zu sein.
Außer lfind() gibt’s in der Bücherei auch noch lsearch(), mit den gleichen
Argumenten, der gleichen Suchtechnik, und fast dem gleichen Resultat:
char * lsearch(), * lfind();
#define Lsearch(key, base, nelp, compar) \
((Object *) lsearch((char *) (key), /* gesuchtes Object */ \
(char *) (base), /* Anfang der Tabelle */ \
(unsigned *) (nelp), /* Anzahl Elemente */ \
(unsigned) sizeof *(base), /* Elementgroesse */ \
(int (*)()) (compar))) /* Vergleichsfunktion */

#define Lfind(key, base, nelp, compar) \
((Object *) lfind((char *) (key), /* gesuchtes Object */ \
(char *) (base), /* Anfang der Tabelle */ \
(unsigned *) (nelp), /* Anzahl Elemente */ \
(unsigned) sizeof *(base), /* Elementgroesse */ \
(int (*)()) (compar))) /* Vergleichsfunktion */
Leider wurden die Funktionen nicht so arg logisch benannt: lfind() sucht, muß aber
nicht unbedingt finden, und liefert unter Umständen einen Nullzeiger. lsearch()
sucht, findet bestimmt, und liefert nie einen Nullzeiger: ist das gesuchte Objekt nicht
in der Tabelle, trägt es lsearch() am Ende des Vektors ein, korrigiert die Anzahl der
Elemente entsprechend (deshalb muß ein Zeiger auf diese Anzahl übergeben
werden!), und liefert schließlich einen Zeiger auf das gefundene — neu eingetragene
— Objekt. Das Wortspiel zum ‘‘gefundenen Fressen’’ liegt nahe: lsearch() hat nicht
genügend Information um das verfügbare Ende der Tabelle zu erkennen. Es bleibt
dem Progammierer überlassen, lsearch() nur dann aufzurufen, wenn wenigstens
noch ein Element in den angebotenen Vektor paßt.
lsearch() eignet sich auch nicht zum Einsatz in kleinen Compilern: zur
Implementierung einer Blockstruktur für den Geltungsbereich von Namen fügt man
neue Namen jeweils zu einer linearen Liste hinzu, die aber wie ein Stack rückwärts
durchsucht werden muß, damit man neue (innere) Namen zuerst findet. lsearch()
sucht vorwärts...

Binär einfügen — ‘‘binary()’’
lsearch() hat gegenüber bsearch() den Vorteil, daß ein nicht vorhandenes Element in
die Tabelle eingefügt wird. Die lineare Suche ist jedoch ein gravierender Nachteil:
bsearch() merkt nach 10 Vergleichen bei 1000 Elementen, daß ein gesuchtes
Element fehlt; lsearch() merkt das erst nach 1000 Vergleichen. Die folgende
Funktion binary() kombiniert die Vorteile der beiden anderen Funktionen: sie sucht
binär und fügt bei Bedarf das gesuchte Element so ein, daß die Tabelle sortiert
bleibt:
char * binary(key, base, nelp, width, compar)
char * key, * base; unsigned * nelp, width; int (* compar)();
{ unsigned nel = * nelp; int c;
char * lim = base + nel * width, * mid, * high;
for (high = lim — width; base >= 1)
{ mid = base + (nel >> 1) * width;
if ((c = (* compar)(key, mid)) < 0)
high = mid — width;
else if (c > 0)
base = mid + width, —— nel;
else
return mid;
}
for (high = lim, lim += width; high > base; )
*——lim = *——high;
for (c = width; c——; )
base[c] = key[c];
++ *nelp;
return base;
}

lim wird auf den Punkt unmittelbar nach den vorhandenen Elementen eingestellt.
Die erste for-Schleife realisiert die konventionelle binäre Suche. Die einzige
Schwierigkeit liegt darin, daß mid nicht nur auf den Mittelpunkt zwischen base und
high — also dem ersten und letzten Element im aktuellen Vektorbereich — zeigen
kann, sondern möglichst genau dort auf ein Element zeigen muß. nel ist die Anzahl
der Elemente im Vektorbereich. Ist sie gerade, zeigt mid auf das Element, das am
Mittelpunkt beginnt, und nach dem Element bei mid folgen weniger Elemente als
davor. Ist die Anzahl der Elemente ungerade, zeigt mid auf das Element, das das
Byte am Mittelpunkt enthält, und davor und danach sind gleich viele Elemente.
Wechselt man in die rechte ‘‘Hälfte’’ über, muß nel sorgfältig korrigiert werden,
sonst zeigt man am Schluß möglicherweise ins Leere!
Geht die erste for-Schleife erfolglos zu Ende, zeigt base gerade auf den Punkt, wo
das gesuchte Element sein sollte. Die zweite for-Schleife geht von rechts nach links
und schiebt den Rest des Vektors nach rechts, und die dritte for-Schleife kopiert die
gesuchte Information an die richtige Stelle in der nach wie vor sortierten Tabelle.
Messen — ‘‘bench()’’
Ein typisches Problem zum Vergleichen von Suchfunktionen ist die
Häufigkeitsanalyse von Worten in einem Text. Als Treiber für die nachfolgenden
Vergleiche verwenden wir folgendes Programm:
int inc; /* Parameter fuer Speicherverwaltung */
MAIN
{ char buf[100]; register char * cp;
OPT
ARG ’i’: PARM inc = atoi(*argv); NEXTOPT

}
OTHER fputs("[—i inc]\n", stderr), exit(1);
ENDOPT
bench("");
while (scanf("%s", buf) == 1)
if (cp = word(buf))
count(cp);
bench("count");
alpha();
bench("alpha");
frequency();
bench("frequency");
scanf() extrahiert Worte, also Zeichenfolgen, die nicht aus Zwischenraumzeichen
bestehen, aus der Standard-Eingabe. word() kann dazu dienen, zum Beispiel nur
alphanumerische Worte oder nur genügend lange Worte zu selektieren. count()
muß ein Wort mit Hilfe einer der Suchfunktionen finden und zählen; neue Worte
müssen jeweils dynamisch gespeichert werden. alpha() soll zum Schluß alle Worte
sortiert ausgeben, frequency() soll sie nach Häufigkeit sortiert ausgeben. bench()
dient dazu, die Ausführungszeit der verschiedenen Phasen des Tests und den
tatsächlichen dynamischen Speicherverbrauch zu messen:
#include
#include
#include
bench(s) register char * s; /* Zeitstempel ausgeben */
{ static struct tms told; static long old; /* letzte Marke */
struct tms tnew; long new, times(); /* neue Marke */
static char * bold; char * bnew, * sbrk(); /* Speicher */
new = times(& tnew); bnew = sbrk(0);

}
if (old)
fprintf(stderr,
"%s: %d/%d/%d (user/sys/real in ticks), %u (heap bytes)\n",
s, (int) (tnew.tms_utime — told.tms_utime),
(int) (tnew.tms_stime — told.tms_stime),
(int) (new — old), (unsigned) bnew — bold);
bold = bnew; old = times(& told);
times() ist ein Systemaufruf, der als Resultat jeweils eine Uhrzeit liefert. In struct
tms werden außerdem die CPU-Zeiten hinterlegt, die der aufrufende Prozeß (mit
etwa vorhandenen Abkömmlingen) bisher selbst und durch Systemaufrufe
verbraucht hat. sbrk(0) zeigt die Adresse, die der Systemkern bei der nächsten
3
Anforderung von dynamischem Speicherplatz liefern würde. Verwendet man für
count(), alpha() und frequency() leere Funktionen, liefert unser Programm etwa
folgendes:
$ f0 < spreadsheet.ms
count: 87/6/135 (user/sys/real in ticks), 0 (heap bytes)
alpha: 0/0/0 (user/sys/real in ticks), 0 (heap bytes)
frequency: 0/0/0 (user/sys/real in ticks), 0 (heap bytes)
spreadsheet.ms ist dabei die Quelle zu meinem SpreadSheet-Artikel in diesem Heft:
word() selektiert 966 verschiedene Worte mit etwa 8 KB Zeichen; der Text enthält
insgesamt etwa 2750 ‘‘Worte’’ mit 18 KB Text.
Die Bedeutung der clock ticks bleibt eigentlich undefiniert. Bei XENIX enthält die
Environment-Variable HZ die Anzahl der clock ticks pro Sekunde; auf dem hier
3 Das ist nicht unbedingt das nächste Resultat von malloc(), denn diese Funktion
verwaltet eine freie Liste und fordert außerdem Speicher bei sbrk() nur in größeren
Blöcken an.

verwendeten System sind das 50. Der Systemkern mißt auch die CPU-Zeiten nicht
vollkommen exakt; die gezeigten Zeiten sollten also nur als qualitative Aussage
betrachtet werden.
(Fortsetzung folgt)