Code-Bibliothek — Capypad · Code Zeile für Zeile lesen

C · ExperteSnippet

Strict Aliasing und das restrict-Schlüsselwort

Strict Aliasing erlaubt es dem Compiler anzunehmen, dass Zeiger unterschiedlicher Typen nicht denselben Speicherbereich referenzieren. Der 'restrict'-Qualifizierer (C99) informiert den Compiler explizit darüber, dass während der Lebensdauer des Zeigers nur dieser (und davon abgeleitete Zeiger) für den Zugriff auf das Objekt verwendet wird. Dies ermöglicht aggressive Optimierungen, wie das einmalige Laden von Werten in Register, anstatt sie aufgrund potenzieller Seiteneffekte erneut aus dem Speicher zu lesen.

snippet.c

c

1

2

3

4

5

6

void vector_add(int * restrict a, int * restrict b, const int * restrict src, int n) {
    for (int i = 0; i < n; i++) {
        a[i] += src[i];
        b[i] += src[i];
    }
}

PerformanceBest Practices

C · ExperteSnippet

Flexible Array-Member (C99)

Ein flexibles Array-Member ist eine Array-Deklaration ohne Größe am Ende einer Struktur. Es ermöglicht eine einzige zusammenhängende Speicherreservierung sowohl für die Metadaten (Header) als auch für die Nutzlast (Daten). Dies vermeidet die doppelte Zeiger-Indirektion, vereinfacht die Speicherverwaltung und verbessert die Cache-Lokalität erheblich.

snippet.c

c

1

2

3

4

5

6

7

8

struct Packet {
    int header_id;
    size_t length;
    unsigned char data[]; // Flexible array member
};
 
struct Packet *p = malloc(sizeof(struct Packet) + 1024);
p->length = 1024;

Arrays & ListenMemory Management

C · ExperteSnippet

Volatile und Signalsicherheit

Der 'volatile'-Qualifizierer verhindert, dass der Compiler den Wert einer Variablen in einem Register zwischenspeichert, und zwingt ihn, jedes Mal aus dem Speicher zu lesen. 'sig_atomic_t' ist ein Typ, auf den selbst bei asynchronen Interrupts atomar zugegriffen werden kann. Zusammen sind sie essenziell für Variablen, die zwischen dem Haupt-Thread und Signal-Handlern geteilt werden.

snippet.c

c

1

2

3

4

5

6

7

8

9

#include <signal.h>
 
volatile sig_atomic_t keep_running = 1;
 
void handle_sigint(int sig) {
    keep_running = 0;
}
 
// In main: while(keep_running) { /* loop */ }

SyntaxMemory Management

C · ExperteSnippet

X-Makros für synchronisierte Definitionen

Das X-Makro-Muster ist eine leistungsstarke Präprozessor-Technik, um mehrere zusammengehörige Listen (wie Enums, Strings oder Switch-Cases) synchron zu halten. Man definiert eine Liste einmal und 'wendet' sie an, indem das 'X'-Makro vor jeder Verwendung neu definiert wird. Dies verhindert Fehler, bei denen ein Enum aktualisiert, aber das zugehörige String-Array vergessen wird.

snippet.c

c

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

#define STATUS_LIST \
    X(IDLE, "System is waiting") \
    X(BUSY, "Processing task") \
    X(ERROR, "Fault detected")
 
// Generate Enum
typedef enum { 
    #define X(a, b) STATUS_##a, 
    STATUS_LIST 
    #undef X 
} status_t;
 
// Generate String Table
const char* status_msg[] = { 
    #define X(a, b) b, 
    STATUS_LIST 
    #undef X 
};

SyntaxBest Practices

C · ExperteSnippet

Kapselung mit Opaque Pointern (ADTs)

Opaque Pointer (oft als 'Handles' oder PIMPL-Idiom bezeichnet) ermöglichen eine vollständige Datenkapselung in C. Indem im Header nur eine Vorwärtsdeklaration bereitgestellt und die Struktur in der Quelldatei definiert wird, können Clients nicht direkt auf interne Felder zugreifen. Dies verbessert die binäre Kompatibilität (ABI), da sich das Layout der Struktur ändern kann, ohne dass Clients neu kompilieren müssen.

snippet.c

c

1

2

3

4

5

6

7

8

9

10

11

// In header (public interface)
typedef struct connection_s* connection_t;
connection_t conn_create(const char *url);
void conn_send(connection_t c, const char *msg);
 
// In source (implementation details hidden)
struct connection_s {
    int socket_fd;
    char buffer[1024];
    bool is_encrypted;
};

FunktionenBest Practices

C · ExperteSnippet

Atomares Compare-and-Swap (CAS) mit stdatomic.h

Verwendet C11's stdatomic.h für ein lock-freies Update. atomic_compare_exchange_weak prüft, ob der aktuelle Wert mit 'expected' übereinstimmt; falls ja, wird er auf 'desired' gesetzt. Falls nicht, wird 'expected' mit dem tatsächlichen aktuellen Wert aktualisiert, was eine Wiederholungsschleife ermöglicht.

snippet.c

c

1

2

3

4

5

6

7

8

9

10

#include <stdatomic.h>
#include <stdbool.h>
 
void safe_update(atomic_int *val) {
    int expected = atomic_load(val);
    int desired;
    do {
        desired = expected + 1;
    } while (!atomic_compare_exchange_weak(val, &expected, desired));
}

Memory ManagementPerformance

C · ExperteSnippet

C99 Compound Literals für temporäre Objekte

Compound Literals ermöglichen die Erstellung unbenannter Objekte im laufenden Betrieb. Sie sind L-Werte, was bedeutet, dass man sogar ihre Adresse abrufen kann. Dies ist äußerst nützlich, um komplexe Argumente an Funktionen zu übergeben, ohne den Scope mit temporären Variablen zu belasten.

snippet.c

c

1

2

3

4

5

6

7

8

typedef struct { int r, g, b; } Color;
void apply_color(Color c);
 
int main() {
    // Passing an anonymous struct object without a variable
    apply_color((Color){255, 128, 0});
    return 0;
}

SyntaxMemory Management

C · ExperteSnippet

Variadische Makros mit __VA_ARGS__

Der Identifikator __VA_ARGS__ wird in der Makro-Expansion verwendet, um die an das Makro übergebenen variablen Argumente darzustellen. Dies erlaubt die Erstellung mächtiger Wrapper um Funktionen wie printf, während automatisch Metadaten wie Dateinamen und Zeilennummern eingefügt werden.

snippet.c

c

1

2

3

4

5

6

7

8

9

#include <stdio.h>
 
#define DEBUG_LOG(fmt, ...) \
    fprintf(stderr, "[DEBUG] %s:%d: " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)
 
int main() {
    DEBUG_LOG("Processing %d items", 42);
    return 0;
}

SyntaxFunktionen