You are here

C - Reference

// Literatur:
//     C++ Referenz (http://www.cplusplus.com)
//     C von A bis Z (http://openbook.galileocomputing.de/c_von_a_bis_z)
 
 
// Programm Einsprung-Punkt
    int main(int argc, char **argv)
    {
        return 0;
    }
 
    // argc ... Argumenten Counter
    // argv ... Argumenten Liste
 
 
// reservierte Schluesselwoerter
    auto      break      case      char       complex  const     continue
    default   do         double    else       enum     extern    float
    for       goto       if        imaginary  inline   int       long
    register  restrict  return     short      signed   sizeof    static
    struct    switch    typedef    union      unsigned  void     volatile
    while
 
 
// Verfuegbare Zeichen
    // Ziffern:
    //     1 2 3 4 5 6 7 8 9 0
    // Buchstaben:
    //     A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
    //     a b c d e f g h i j k l m n o p q r s t u v w x y z
    // Sonderzeichen:
    //     ! " % & / ( ) [ ] { } \ ? = ’ # + * ~ – _ . : ; , | < > ^
    // Steuerzeichen:
    //     \a    ... bell            – akustisches Warnsignal
    //     \b    ... backspace       – Cursor nach links
    //     \f    ... formfeed        – Seitenvorschub durchfuehren
    //     \n    ... newline         – Cursor zur naechsten Zeile
    //     \r    ... carriage return – Cursor zum Anfang der
    //                                 aktuellen Zeile
    //     \t    ... horizontal tab  – Cursor zur naechsten horizontalen
    //                                 Tabulatorposition
    //     \v    ... vertical tab    – Cursor zur naechsten vertikalen
    //                                 Tabulatorposition
    //     \"    ... Ausgabe: "
    //     \’    ... Ausgabe: '
    //     \?    ... Ausgabe: ?
    //     \\    ... Ausgabe: \
    //     \0    ... Stringabschluss (Byte-Wert 0 wird gespeichert)
    //     \nnn  ... Ausgabe eines Oktalwerts
    //     \xhh  ... Ausgabe eines Hexdezimalwerts
 
 
// Kommentare
    // Zeilenkommentar
    /* Blockkommentar,
       kann auch ueber mehrere Zeilen gehen */
 
 
// Datentypen
    // Speicherorte
        // Code     ... Programmcode
        // Daten    ... statische und globale Variablen
        // Stack    ... lokale Variablen
        // Heap     ... dynamische Variablen
 
    // Initialisierung
    int wert;
    int wert = 5;
    int wert1, wert2 = 10;
    int wert1 = wert1 = 10;
    int wert1 = 20, wert2 = 30;
 
    int wert;           // globale Variable
    void main()
    {
        int wert;       // lokale Variable
 
        if ()
        {
            int wert;   // blendet in diesem Anweisungsblock
        }               // andere lokale Variable aus
    }
 
    short       // Ganzzahl                             ... Datentyp
                // min 2 Byte                           ... ANSI-C
                // -32.768                              ... Min
                // +32.767                              ... Max
 
    int         // Ganzzahl (%d, %i)
                // min 2 Byte
                // -32.768
                // +32.767
 
    long        // Ganzzahl (%ld, %li)
                // min 4 Byte
                // –2.147.483.648
                // +2.147.483.647
 
    long long   // Ganzzahl
                // min 8 Byte
                // –9.223.372.036.854.755.807
                // +9.223.372.036.854.755.807
 
    float       // Gleitkommazahl (%f)
                // min 4 Byte
                // 1.2E-38
                // 3.4E+38
                // Vorzeichen 1 Bit, Exponent 8 Bits, Mantisse 23 Bits
 
    double      // Gleitkommazahl (%lf)
                // min 8 Byte
                // 2.3E-308
                // 1.7E+308
                // 15-stellig
                // Vorzeichen 1 Bit, Exponent 11 Bits, Mantisse 52 Bits
 
    long double // Gleitkommazahl (%Lf)
                // min 10 Byte
                // 3.4E-4932
                // 1.1E+4932
                // 19-stellig
 
    char        // Zeichen (%c)
                // 1 Byte
                // -128
                // +127
 
 
    signed          // ... negative und positive Zahl
    unsigned        // ... positive Zahl
    const           // ... Wert kann nicht veraendert werden
    volatile        // ... Variable kann sich auch asserhalb des Programms
                    //     aendern (z.B. durch HW)
                    //     -> Wert wird jedesmal neu eingelesen
    static          // ... bei Wiedereintritt bleibt Variable erhalten /
                    //     Variable gilt nur im aktuellen Kontext
    extern          // ... Variable wurde in einer anderen Datei definiert
    register        // ... Variable sollte moeglichst lange in den internen
                    //     Registern gehalten werden
    (float) intVal  // Typcast
    float (intVal)  // Typcast
 
    int arr[10];                // Array-Definition (0-9)
    arr[0] = *(arr + 0)         // Zugriff auf Elemente
    int arr[4][4];              // mehrdimensionale Arrays:
                                //     [0][0] [0][1] [0][2] [0][3]
                                //     [1][0] [1][1] ...
                                //     ...
    int Matrix[4][4] = {{1 ,2 ,3 ,4 },
                        {4 ,5 ,6 ,7 },
                        {8 ,9 ,10,11},
                        {12,13,14,15}};
    sizeof(arr)/sizeof(int)     // Array Elemente ermitteln
    int memcmp(const void *ptr1, const void *ptr2, size_t num);
    void *memcpy(void *destination, const void *source, size_t num);
 
    char str[] = "hello world\0";
    // String verbinden
        char *strcat(char *destination, const char *source);
    // Zeichen in String suchen
        const char *strchr( const char *str, int character);
    // String vergleichen
        int strcmp(const char *str1, const char *str2);
    // String kopieren
        char *strcpy(char *destination, const char *source);
    // Teilstring ermitteln
        size_t strcspn(const char *str1, const char *str2);
    // String-Laenge ermitteln
        size_t strlen(const char *str);
    // String mit n Zeichen verbinden
        char *strncat(char *destination, char *source, size_t num);
    // String mit n Zeichen vergleichen
        int strncmp(const char *str1, const char *str2, size_t num);
    // String mit n Zeichen kopieren
        char *strncpy(char *destination, const char *source, size_t num);
    // erste Auftreten eines Zeichens
        const char *strpbrk(const char *str1, const char *str2);
    // letzte Auftreten eines Zeichens
        const char *strrchr(const char *str, int character);
    // erstes Auftreten eines Zeichens, das nicht vorkommt
        size_t strspn(const char *str1, const char *str2);
    // String nach Teilstring durchsuchen
        const char *strstr(const char *str1, const char *str2);
    // String anhand bestimmter Zeichen zerlegen
        char *strtok(char *str, const char *delimiters);
 
    sizeof(int)     // ... Groesse des Datentyps in Byte
 
    #include <limits.h>
    CHAR_BIT
    SCHAR_MIN  SCHAR_MAX
    UCHAR_MAX
    CHAR_MIN   CHAR_MAX
    SHRT_MIN   SHRT_MAX
    USHRT_MAX
    INT_MIN    INT_MAX
    UINT_MAX
    LONG_MIN   LONG_MAX
    ULONG_MAX
 
    #include <float.h>
    FLT_RADIX    FLT_MANT_DIG    FLT_DIG  FLT_MIN_EXP  FLT_MIN_10_EXP
    FLT_MAX_EXP  FLT_MAX_10_EXP  FLT_MAX  FLT_MIN      FLT_EPSILON
 
    DBL_MANT_DIG    DBL_DIG  DBL_MIN_EXP  DBL_MIN_10_EXP   DBL_MAX_EXP
    DBL_MAX_10_EXP  DBL_MAX  DBL_MIN      DBL_EPSILON
 
    LDBL_MANT_DIG    LDBL_DIG  LDBL_MIN_EXP  LDBL_MIN_10_EXP  LDBL_MAX_EXP
    LDBL_MAX_10_EXP  LDBL_MAX  LDBL_MIN      LDBL_EPSILON
 
    int integer = 0;
    int *pInt;              // Pointer auf Integer-Datentyp
    pInt = &integer;        // Zeiger auf Variable
    *pInt = 1;              // Dereferenzieren - Wert aendern
    pInt = 1;               // Zeiger-Wert aendern
 
    const int *pInt         // Pointer auf konstanten Integer
    int const *pInt         // konstanter Pointer auf Integer
    const int const *pInt   // konstanter Pointer auf konstanten Integer
 
    int Int;
    int *pInt = &Int;
    int **ppInt = &pInt;
    **ppInt = 10;
    *pInt = 20;
 
    // dynamischen Speicher anfordern
        void *malloc(size_t size);
    // dynamischen Speicher anfordern
        void *calloc(size_t anzahl, size_t groesse);
    // Speichergroesse anpassen
        void *realloc(void *zgr, size_t neuegroesse);
    // Speicher freigeben
        free(void *p);
    // Speicher vom Stack anfordern (braucht nicht freigegeben zu werden)
        void *alloca(size_t size);
 
 
// Typdefinitionen
    typedef unsigned char BYTE;
    typedef unsigned int WORD;
 
 
// Strukturen, Unions, ...
    struct Struct
    {
        int Value1;
        char Value2;
    };
    struct Struct Struct1;
    Struct1.Value1 = 0;
    Struct1.Value2 = 'a';
 
    typedef struct Struct
    {
        ...
    } Struct_t;
    Struct_t Struct1;
 
    struct Struct
    {   ...
    } Struct1;
 
    struct Struct
    {   ...
    } Struct1 = {0, 'a'};
 
    struct Struct
    {
        int *ptr;
    } Struct1;
    Struct1->ptr = 10;
 
 
    union Union
    {
        int Int;
        long Long;              // int und long werden am selben
    };                          // Speicherplatz abgelegt
 
 
    enum Zahl {EINS, ZWEI};
    enum Zahl {EINS=1, ZWEI};
    enum Zahl nr = EINS;
 
    typedef enum Zahl {EINS, ZWEI} Zahl_t;
    Zahl_t nr = EINS;
 
 
    typedef struct bit8struct
    {
        unsigned char b0:1;        // Bit-weiser Zugriff
        unsigned char b1:1;
        unsigned char b2:1;
        unsigned char b3:1;
        unsigned char b4:1;
        unsigned char b5:1;
        unsigned char b6:1;
        unsigned char b7:1;
    } BITDEF8;
 
    typedef union bit8union
    {
        BITDEF8 bit;
        unsigned char byte;
    } BIT8;
 
 
// Operationen
    // unaer            ... ein Operanden
    // binaer           ... zwei Operanden
    // ternaer          ... drei Operanden
 
    // infix            ... Operand zwischen Operanden
    // praefix          ... Operand vor Operand
    // postfix          ... Operand nach Operand
 
    // linksassoziativ  ... a + b - c = (a + b) - c
    // rechtsassoziativ ... a + b - c = a + (b - c)
 
    // Berechnungsoperationen
    a = a+b;            // Addition
    a = a-b;            // Subtraktion
    a = a*b;            // Multiplikation
    a = a/b;            // Division
    a = a%b;            // Modulo (Rest)
 
    a += b;
    a -= b;
    a *= b;
    a /= b;
    a %= b;
 
    a++;                // postfix - alte Wert wird ausgegeben und
                        // anschliessend wird incrementiert
    ++a;                // praefix - Wert wird inkrementier und
                        // anschliessend ausgegeben
    b--;                // dekrementieren
    --b;
 
    // Bitoperationen
    &                   // bitweises Und
    |                   // bitweises Oder
    ^                   // bitweises XOR
    ~                   // bitweises Komplement
    >>                  // shift right
    <<                  // shift left
 
    // Vergleichsoperatoren
    ==                  // gleich
    !=                  // ungleich
    <                   // kleiner
    >                   // groesser
    <=                  // kleiner gleich
    >=                  // groesser gleich
 
    !                   // negation
    ||                  // Oder
    &&                  // Und
 
 
// Kontrollanweisungen
    if (CONDITION)
    {}
    else if (CONDITION)
    {}
    else
    {}
 
    if (a>b)        ==      c = (a>b) ? a : b;
        c = a;
    else
        c = b;
 
    switch(a)
    {
    case 0:
        break;
    default:
        break;
    }
 
    while (CONDITION)
    {}
 
    do
    {}
    while (CONDITION);
 
    for (i=0; i<MAX; i++)
    {}
 
 
// Funktionen
    void FuncName (int Param);  // Vorwaertsdeklaration
    void FuncName (int Param)   // Implementierung
    {}
 
    void FuncName (int Value)   // call by value
    {}                          //     Kopie wird uebertragen,
                                //     Aenderung wirkt sich ausserhalb
                                //     nicht aus
 
    void FuncName (int *Value)  // call by reference
    {}                          //    Pointer wird uebertragen,
                                //    Aenderung wirkt sich ausserhalb aus
 
    void FuncName (int Arr[])
    {
        Arr[0] = ...
    }
    void FuncName (int Arr[][10])
    {
        Arr[0][0] = ...
    }
 
    int *FuncName ()
    {
        int asdf = 0;
        return asdf;            // !Fehler!
                                // -> Variable nach Funktionsende
                                //    nicht mehr am Stack
 
        int *asdf = (int *) malloc(sizeof(int));
        *asdf = 0;
        return asdf;            // Richtig -> Variable bleibt erhalten
    }
 
 
// Funktionspointer
    int (*FuncName)(void);
    int (*FuncName)(int Value);
    int (*FuncName)(int Value, ...);
    FuncName pFunc = ...
 
    int (*ptr[])(const char *, ...) = { scanf, printf };
    (*ptr[1])("output");
    (*ptr[0])("%d",&value);
 
 
// formatierte Ausgabe
    printf("hello world");
    printf("hello \
    world");
 
    printf("%FW.GU", &value);
    // F        ... Flags
    // W        ... Weite
    // G        ... Genauigkeit
    // U        ... Formatierungszeichen
 
    // Flags:
    // -        ... linksbündig
    // 0          ... mit 0en fuellen
    // +        ... Vorzeichen ausgeben
    // blank    ... positive Zahlen mit Leerzeichen beginnen
    // #         ... verschiedene Bedeutung:
    //              %#o (Oktal) 0 Präfix einfuegen
    //              %#x (Hex)   0x Präfix einfuegen (Wert ungl. Null)
    //              %#X (Hex)   0X Präfix einfuegen (Wert ungl. Null)
    //              %#e         Dezimalpunkt anzeigen
    //              %#E         Dezimalpunkt anzeigen
    //              %#f         Dezimalpunkt anzeigen
    //              %#g         Dezimalpunkt immer anzeigen. 0en nach dem 
    //                          Dezimalpunkt werden nicht beseitigt
    //              %#G         Dezimalpunkt immer anzeigen. 0en nach dem 
    //                          Dezimalpunkt werden nicht beseitigt
 
    // Formatierungszeichen:
    // %d, %i   ... vorzeichenbehaftete ganze Dezimalzahl
    // %o       ... vorzeichenlose ganze Oktalzahl
    // %u       ... vorzeichenlose ganze Dezimalzahl
    // %x, %X   ... vorzeichenlose ganze Hexzahl
    //              (a,b,c,d,e,f) bei x; (A,B,C,D,E,F) bei X
    // %f       ... Gleitpunktzahl (ddd.dddddd)
    // %e, %E   ... Gleitpunktzahl (d.ddde+-dd, d.dddE+-dd)
    // %g, %G   ... float
    // %c       ... Zeichen
    // %s       ... Zeichenkette
    // %p       ... Zeigerwerte
    // %%       ... das Zeichen %
 
 
// formatiere Eingabe
    #include <stdio.h>
    nrCorrect = scanf("%d %c",&i, &c);
    // nrCorrect ... Nummer der korrekt eingelesenen Werte
 
    // Suchmengen
    %[Liste]            // Zeichen welches in der Liste befindet
                        // %[A-Z]  %[a-z]  %[a-fA-F]
    %[^Liste]           // Zeichen welches nicht in der Liste befindet
 
    fflush(stdin);      // Eingabe-Puffer leeren
 
 
// standard Libraries
    // assert.h       ... Fehlersuche und Debugging
    // ctype.h        ... Zeichentest und Konvertierung
    // errno.h        ... Fehlercodes
    // float.h        ... Limits/Eigenschaften für Gleitpunkttypen
    // limits.h       ... Implementierungskonstanten
    // locale.h       ... Laenderspezifische Eigenschaften
    // math.h         ... Mathematische Funktionen
    // setjmp.h       ... Unbedingte Spruenge
    // signal.h       ... Signale
    // stdarg.h       ... Variable Parameteruebergabe
    // stddef.h       ... Standard-Datentyp
    // stdio.h        ... Standard-I/O
    // stdlib.h       ... Nuetzliche Funktionen
    // string.h       ... Zeichenkettenoperationen
    // time.h         ... Datum und Uhrzeit
    // complex.h      ... Komplexe Arithmetik
    // inttypes.h     ... Fuer genauere Integer-Typen
    // stdbool.h      ... Boolschen Datentypen
    // stdint.h       ... Ganzzahlige Typen mit vorgegebener Breite
    // tgmath.h       ... Generische Mathematik-Funktionen
    // wchar.h        ... für den erweiterten Zeichensatz:
    //                        - Umwandlung von Strings zu Zahlwerten
    //                        - String- und Speicherbearbeitung
    //                        - Ein- und Ausgabe
    // wctype.h       ... für den erweiterten Zeichensatz:
    //                        - Zeichenuntersuchung
 
 
// Dateioperationen
    // Datenstrom oeffnen
        FILE *fopen(const char *pfadname, const char *modus);
        // r  ... read
        // w  ... write (anlegen einer Datei)
        // a  ... write/add (falls nicht vorhanden -> NULL)
        // r+ ... read+write
        // w+ ... write (falls vorhanden -> zuvor loeschen)
        // a+ ... write/add (falls nicht vorhanden -> anlegen)
        //
        // b  ... Binaermodus
        // t  ... Textmodus
        //
        // stdin  ... Standardeingabe
        // stdout ... Standardausgabe
        // stderr ... Standardfehlerausgabe
    // Datenstrom schliessen
        int fclose(FILE *stream);
    // Testet auf Dateiende im Stream
        int feof(FILE *stream);
    // Testet auf Fehler im Stream
        int ferror(FILE *stream);
    // Leert den Puffer im Datenstrom
        int fflush(FILE *stream);
    // Zeichenweise lesen vom Stream
        int fgetc(FILE *stream);
    // Zeilenweise lesen vom Stream
        char *fgets(char *str, int num, FILE *stream);
    // Position im Stream ermitteln
        int fgetpos(FILE *stream, fpos_t *position);
    // Formatierte Ausgabe an Stream
        int fprintf(FILE *stream, const char *format, ... );
    // Zeichenweise schreiben in den Stream
        int fputc(int character, FILE *stream);
    // Schreibt einen String in den Stream
        int fputs(const char *str, FILE *stream);
    // Datenstrom erneut oeffnen
        FILE *freopen(const char *filename, const char *mode, FILE *stream);
    // Formatierte Eingabe vom Stream
        int fscanf(FILE *stream, const char *format, ... );
    // Dateizeiger neu positionieren
        int fseek(FILE *stream, long int offset, int origin);
    // Dateizeiger neu positionieren
        int fsetpos(FILE *stream, const fpos_t *pos);
    // Position im Stream ermitteln
        long int ftell(FILE *stream);
 
    // Zeichenweise lesen vom Stream
        int getc(FILE *stream);
    // Zeichenweise lesen von stdin
        int getchar(void);
    // Liest String von stdin (unsichereFunktion)
        char *gets(char *str);
    // Formatierte Ausgabe an stdout
        int printf(const char *format, ... );
    // Zeichenweise schreiben in den Stream
        int putc(int character, FILE *stream);
    // Zeichenweise schreiben an stdout
        int putchar(int character);
    // Zeichenkette an Stream stdout
        int puts(const char *str);
    // Formatierte Eingabe von stdin
        int  scanf(const char *format, ... );
    // Streampuffer einrichten
        void setbuf(FILE *stream, char *buffer);
    // Streampuffer veraendern
        int setvbuf(FILE *stream, char *buffer, int mode, size_t size);
    // Formatierte Ausgabe in einem String
        int sprintf(char *str, const char *format, ... );
    // Formatierte Eingabe aus einem String
        int sscanf(const char *str, const char *format, ...);
    // Zeichen zurueck in den Stream
        int ungetc(int character, FILE *stream );
 
 
// Fehlercodes
    <errno.h>
    strerror(), perror()
    // EDOM        ... Unzulaessiges Argument für eine
    //                 mathematische Funktion
    // ERANGE      ... Ergebnis außerhalb des darstellbaren Bereichs 
    // EZERO       ... Fehler 0
    // EINVFNC     ... Ungueltige Funktionsnummer
    // ENOFILE     ... Datei nicht gefunden
    // ENOPATH     ... Pfad nicht gefunden
    // ECONTR      ... Speicherbloecke zerstoert
    // EINVMEM     ... Ungueltige Speicherblockadresse
    // EINVENV     ... Ungueltiges Environment
    // EINVFMT     ... Ungueltiges Format
    // EINVACC     ... Ungueltiger Zugriffscode
    // EINVDAT     ... Ungueltige Daten
    // EINVDRV     ... Ungueltige Laufwerksangabe
    // ECURDIR     ... Versuch, das aktuelle Verzeichnis zu loeschen
    // ENOTSAM     ... Nicht das gleiche Geraet
    // ENMFILE     ... Keine weiteren Dateien mehr
    // ENOENT      ... Datei oder Verzeichnis existiert nicht
    // EMFILE      ... Zu viele geoeffnete Dateien
    // EACCES      ... Zugriff verweigert
    // EBADF       ... Ungueltiger Datei-Deskriptor
    // ENOMEM      ... Zu wenig Speicher
    // ENODEV      ... Geraet existiert nicht
    // EINVAL      ... Ungueltiges Argument
    // E2BIG       ... Argumentliste ist zu lang
    // ENOEXEC     ... Fehler beim Exec-Format
    // EXDEV       ... Kreuzverbindung von Geraeten
    // EFAULT      ... Unbekannter Fehler
    // EEXIST      ... Datei existiert bereits