Mit „C“ ist hier die Programmiersprache „C“ gemeint, um die CPU-Last auszulesen.

Die Geschichte von C

Die Programmiersprache C wurde im Jahre 1972 von Dennis Richie und Bell Labs entwickelt. Sie war zu dieser Zeit eine moderne Sprache. Witzigerweise aus heutiger Sicht wurde sie aus der Programmiersprache B entwickelt, die im Jahre 1969 erstmals erschien.

Laut einer kurzen Recherche gab es in dieser Form keine Programmiersprache A, was jetzt eine fast logische Reihenfolge wäre, A -> B -> C.

Combined Programming Language – eine sehr mächtige Sprache

Im Jahre 1963 wurde die sehr mächtige Sprache CPL (Combined Programming Language) entwickelt. Sie gilt als Vorläufer von B und dann schließlich C.

Streng genommen gab es vor CPL noch die Sprachen ALGOL 60 (1960), ALGOL58 (1958), FORTRAN (1957), Speedcoding (1953), Assembler (1947) und irgendwann landen wir bei Konrad Zuse und ganz am Schluss der Reihe beim Urknall.

CPL war anscheinend so mächtig, dass es schwer war einen geeigneten Compiler zu entwickeln. Also wurde eine neue Programmiersprache entwickelt.

Mit BCPL wurde es einfacher – selbst für Experten

Um einen Compiler zu entwickeln, also die Sprache in Maschinencode umzuwandeln, wurde schließlich die etwas schlankere Sprache BCPL entwickelt von Martin Richards von der Universität Cambridge in England (Großbritannien).

Im Jahre 1967 erschien dann die Basic Combined Programming Language, was die Abkürzung von BCPL ist.

B ist ein Mix aus verschiedenen Programmiersprachen

Die Programmiersprache B, der unmittelbarer Vorgänger von „C“ ist ein Mix aus dem bekannten Fortran (1957), BCPL (1967), PL/I (1964) und TMG (1963).

Man hat also das Beste vom Besten aus diesen vier verschiedenen Programmiersprachen genommen und als neue B Programmiersprache entwickelt.

Auch schon hier war Dennis Richie an der Entwicklung von B (mit Ken Thompson) beteiligt.

C ist die Grundlage von allen Unix-basierten Betriebssytemen

Aus diesem Grund kann man heutzutage immer noch sehr viel mit C und Linux programmieren. Natürlich gibt es keine sehr schönen und bunten Weboberflächen, aber 1972 war man noch weit entfernt von einer grafischen Benutzeroberfläche zu denken.

Vielleicht hat man schon daran gedacht, aber Computer standen immer noch in Universitäten und anderen Forschungsinstituten. Sie brauchten große Maschinen mit einem kleinen Bildschirm und einer Tastatur. Dort haben sie dann die Aufgaben erledigt.

Heutzutage wäre das mit Sicherheit selbst in Universitäten undenkbar, nur einem Terminalfenster operieren.

Es ist auch eigentlich aus meiner Sicht zumindest faszinierend, dass man nicht viel mehr braucht.

Welcher Compiler?

Für C (und andere Sprachen) gibt es bei Linux den GCC (GNU Compiler Collection), der standardmäßig auch bei den grundlegensten Installationen immer dabei ist.

Die Version, die 07.08.2026 herausgekommen ist, trägt die Versionsnummer 16.2

In meiner AlmaLinux Installation habe ich aktuell die Version 11.5.0 installiert.

Wie bekommt man die Versionsnummer heraus?

gcc –version ist der Schlüssel dazu.

Kommen wir jetzt endlich zur Sache

Im Gegensatz der Programmierung mit Python braucht man hier nur das Verzeichnis /proc/stat, welches in Linux vorhanden ist, auszulesen für die CPU-Last.

Das Script zum Auslesen von /proc/stat für die Auslastung der CPU

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

int main() {
    unsigned long long a[4], b[4];
    double loadavg;
    FILE *fp;

    printf("Überwachung gestartet. Beenden mit Strg+C...\n\n");

    // Die Endlosschleife für die fortlaufende Anzeige
    while (1) {
        // 1. Messung am Anfang des Intervalls
        fp = fopen("/proc/stat", "r");
        if (!fp) {
            perror("Fehler beim Öffnen von /proc/stat");
            return 1;
        }
        fscanf(fp, "%*s %llu %llu %llu %llu", &a[0], &a[1], &a[2], &a[3]);
        fclose(fp);

        // Intervallzeit: Wartet 1 Sekunde bis zur Folgemessung
        sleep(1);

        // 2. Messung am Ende des Intervalls
        fp = fopen("/proc/stat", "r");
        if (!fp) return 1;
        fscanf(fp, "%*s %llu %llu %llu %llu", &b[0], &b[1], &b[2], &b[3]);
        fclose(fp);

        // Berechnung der Differenzen
        double user_sys_diff = (double)((b[0] + b[1] + b[2]) - (a[0] + a[1] + a[2]));
        double idle_diff = (double)(b[3] - a[3]);
        double total_diff = user_sys_diff + idle_diff;

        if (total_diff > 0) {
            loadavg = (user_sys_diff / total_diff) * 100;
            // Das '\r' am Anfang setzt den Cursor an den Zeilenanfang zurück
            // Das fflush(stdout) erzwingt die sofortige Ausgabe im Terminal
            printf("\rAktuelle CPU-Auslastung: %6.2f%%", loadavg);
            fflush(stdout);
        }
    }

    return 0;
}

Wichtige Ergänzung zum Script

Es ist ratsam den Editor gedit, wenn man einen grafischen Editor verwenden möchte, zu benutzen. Ich hatte das erst im Editor Mousepad gemacht. Der GCC Compiler gab mir dann viele Fehlermeldungen. Erst als ich zum gedit gewechselt bin, verschwanden sie.