Die Standard-Bibliotheks-Funktionen

if (fp= fopen("/etc/passwd","r") == NULL)
  { printf("Datei nicht gefunden!\n"); abort(); }

printf("abs(-8) = %d\n",abs(-8));
/* Ausgabe: abs(-8) = 8 */

printf("acos(-1.0) = %6.4f\n",acos(-1.0));
/* Ausgabe: acos(-1.0) = 3.1416 */

• int tm_sec Sekunden nach voller Minute (0-61)
• int tm_min Minuten nach voller Stunde (0-59)
• int tm_hour Stunden seit Mitternacht (0-23)
• int tm_mday Tag im Monat (1-31)
• int tm_mon Monat nach Januar (0-11)
• int tm_year Jahr minus 1900
• int tm_wday Wochentag (0-6, 0=Sonntag)
• int tm_yday Tag im Jahr nach 1. Januar (0-365)
• int tm_isdst >0: Sommerzeit, =0: Winterzeit, <0: unbekannt

struct tm *systime;
time_t sec;
time(&sec);
systime = localtime (&sec);
printf("Datum und Uhrzeit: %s\n",asctime(systime));
/* Ausgabe: Datum und Uhrzeit: Mon Jul 18 9:00:48 2005 */

printf("asin(-1.0) = %7.4f",asin(-1.0));
/* Ausgabe: asin(-1.0) = -1.5708 */

double x = -1.0, y, z;
y = sin(x) - cos(x);
assert(y > 0);
z = log(y); /* log(y) nur für positive y definiert */
/* Ausgabe: Assertion failed: y > 0, file ... */

printf("atan(-1.0) = %7.4f\n", atan(-1.0));
/* Ausgabe: atan(-1.0) = -0.7854 */

double x = 3, y = 3; /* y/x = 1 */
printf("atan2(y,x) = %10f\n",atan2(y,x));
/* Ausgabe: atan2(y,x) = 0.785398 */

void func1(void) 
  { printf("Das ist Funktion func1.\n");}

void func2(void) 
  { printf("Das ist Funktion func2.\n");}

main()
  {
  atexit(func1);
  atexit(func2);
  printf("\nEnde des Programms.\n");
  }
/* Ausgabe: 
  Ende des Programms.
  Das ist Funktion func2.
  Das ist Funktion func1. */ 

char *string = "-12.356e+2";
double z;
z= atof(string);
printf("z = %.2f\n",z);
/* Ausgabe: z = -1235.60 */

char *s= "+123 Autos";
printf("atoi(s) = %d\n",atoi(s));
/* Ausgabe: atoi(s) = 123 */

char *s= "12345678.-- Dollar";
printf("atol(s) = %ld\n",atol(s));
/* Ausgabe: atol(s) = 12345678 */

int scmp(char **s1, char **s2) { return strcmp(*s1, *s2); }

main()
  {
  char *farben[] = 
    {"rot","orange","gelb","grün","blau","violett"};
  char *key = "schwarz";

  ...
  
  if (bsearch(key,farben,5,sizeof(char*),scmp) == NULL)
    printf("Farbe %s nicht gefunden\n",key);
  ...
  }

if (calloc(5,sizeof(int)) == NULL)
  printf("Nicht genügend Speicher\n");

erg = chdir("/var/log/"); 

printf("ceil(2.3) = %4.1f\n", ceil(2.3));
/* Ausgabe: ceil(2.3) = 3.0 */

clearerr(fp); 

z = clock(); 
/* weist z die Anzahl von "Ticks" zu,
die seit Programmstart vergangen sind */

erg = closedir(dir); 

printf("cos(0.0) = %4.1f\n", cos(0.0));
/* Ausgabe: cos(0.0) = 1.0 */

printf("cosh(-2.0) = %6.4f\n", cosh(-2.0));
/* Ausgabe: cosh(-2.0) = 3.7622 */

time_t sec;
time(&sec);
printf("Datum und Zeit: %s\n", ctime(&sec));
/* Ausgabe: Datum und Zeit: Mon Oct 28 09:15:48 1996 */

printf("Arbeitszeit: %.0f Sekunden\n", difftime(stoptime,starttime));
/* Ausgabe der Differenz zwischen starttime und stoptime */

Protoyp: div_t div(int x,int y);

div_t res;
res = div(10,3);
printf("10/3 = %d, Rest %d\n",res.quot,res.rem);
/* Ausgabe: 10/3 = 3 Rest 1 */

exit(1); /* beendet das Programm und liefert den 
Exit-Code 1 zurück */

printf("exp(-3.0) = %7.4f\n", exp(-3.0));
/* Ausgabe: exp(-3.0) = 0.0498 */

printf("fabs(-3.8) = %3.1f\n", fabs(-3.8));
/* Ausgabe: fabs(-3.8) = 3.8 */

if (fclose(fp) == 0)
  printf("Datei wurde geschlossen\n");

while (!feof(fp))
  /* führt nachfolgenden Befehl solange aus,
  bis das Dateiende erreicht ist */

if (ferror(fp)) 
  printf("Fehler beim Zugriff\n");

if (fflush(fp) == EOF)
  printf("Puffer nicht geschrieben\n");

c = fgetc(fp); 
/* weist c das nächste Zeichen der Datei zu */

fgetpos(fp,&pos);
/* sichert aktuelle Position in pos */

if (fgets(name,21,fp) != NULL) 
  printf("1. Name: %s\n", name);
  /* Ausgabe: 1. Name: xxxx */

printf("floor(1.9) = %4.1f\n", floor(1.9));
/* Ausgabe: floor(1.9) = 1 */

printf("fmod(9.5,4.5) = %3.1f\n", fmod(9.5,4.5));
/* Ausgabe: fmod(9.5,4.5) = 0.5 */

"r"	Lesen (Datei muß existieren)
"r+"	Lesen/Schreiben (Datei muß existieren)
"w"	Schreiben (wenn Datei nicht existiert, wird sie angelegt)
"w+"	Lesen / Schreiben (wenn Datei nicht existiert, wird sie angelegt)
"a"	Schreiben ab Dateiende
"a+"	Schreiben ab Dateiende / Lesen

fp = fopen("bsp.txt","r");
/* öffnet die bereits existierende Datei bsp.txt
zum Lesen (fp wird mit der Datei verbunden) */

fprintf(fp,"2 * 2 = %d \n",2*2);
/* Ausgabe von: 2 * 2 = 4 in die Datei */

fputc(c,fp); 
/* schreibt das Zeichen c an die
aktuelle Position in die Datei */

fputs(string,fp); 
  /* schreibt string in die Datei */

fread(puffer,sizeof(pufferelement),100,fp);
/* liest 100 Elemente aus der Datei in den puffer */

free(ptr); 

freopen("bsp.txt","w",stdout);
/* lenkt die Standardausgabe in die Datei bsp.txt um */ 

m = frexp(9.5,&exp);
printf("Mantisse m = %f, exp = %d\n",m,exp);
/* Ausgabe: Mantisse m = 0.5937..., exp = 4 */

fscanf(fp,"%10s %ld",name,&nummer);
printf("name = %s nummer = %ld\n",name,nummer);

Protoyp: int fseek(FILE *fp, long offset, int basis);

• vom Dateianfang, falls basis = 0
• von der aktuellen Position, falls basis = 1
• vom Dateiende, falls basis = 2

Der Zeiger darf nicht vor den Anfang der Datei gesetzt werden.

fseek(fp,48L,0);
/* setzt den Seek-Zeiger 48 Bytes nach Dateianfang */

fsetpos(fp,&pos);
/* setzt den Seek-Pointer der Datei an die durch pos 
gekennzeichnete Stelle */

pos = ftell(fp);
/* pos wird die aktuelle Position 
in der Datei zugewiesen */

fwrite(puffer,sizeof(pufferelement),4,fp);
/* schreibt 4 pufferelemente aus puffer in die Datei */

c = getc(fp);
/* weist c das nächste Zeichen aus der Datei zu */

c = getchar();
/* weist c das nächste Zeichen von stdin zu */

ptr = getenv("PATH");
/* weist ptr den Inhalt des "PATH"-Eintrages 
in der Umgebung zu */

char buffer[100];
gets(buffer);
/* liest Textzeile in buffer ein */

• int tm_sec Sekunden nach voller Minute (0-61)
• int tm_min Minuten nach voller Stunde (0-59)
• int tm_hour Stunden seit Mitternacht (0-23)
• int tm_mday Tag im Monat (1-31)
• int tm_mon Monat nach Januar (0-11)
• int tm_year Jahr minus 1900
• int tm_wday Wochentag (0-6, 0=Sonntag)
• int tm_yday Tag im Jahr nach 1. Januar (0-365)
• int tm_isdst >0: Sommerzeit, =0: Winterzeit, <0: unbekannt

time_t sec;
time(&sec);
printf("GMT: %s\n", asctime(gmtime(&sec)));

if (isalnum(c))
  printf("%c ist alphanumerisch\n",c);

if (isalpha(c))
  printf("%c ist ein Buchstabe\n",c);

if (iscntrl(c))
  printf("Steuerzeichen\n");

if (isdigit(c))
  printf("%c ist eine Ziffer\n", c);

if (isgraph(c))
  printf("%c ist ein grafisches Zeichen\n",c);

if (islower(c))
  printf("%c ist ein Kleinbuchstabe\n",c);

if (isprint(c))
printf("%c ist ein druckbares Zeichen\n",c);

if (ispunct(c))
  printf("%c ist ein Interpunktionszeichen",c);

if (isspace(c))
  printf("%c ist ein Leerzeichen\n",c);

if (isupper(c))
  printf("%c ist ein Großbuchstabe\n",c);

if (isxdigit(c))
  printf("%c ist eine Hexadezimalziffer\n",c);

printf("labs(-9876543) = %ld",labs(-9876543));
/* Ausgabe: labs(-9876543) = 9876543 */

printf("ldexp(3.0,4) = %.1f",ldexp(3.0,4));
/* Ausgabe: ldexp(3.0,4) = 48 */

ldiv_t result;
result = ldiv(1000000,45000);
printf("ldiv(1000000,45000) = %ld Rest %ld",
       result.quot,result.rem);
/* Ausgabe: ldiv(1000000,45000) = 22 Rest 10000 */

• int tm_sec Sekunden nach voller Minute (0-61)
• int tm_min Minuten nach voller Stunde (0-59)
• int tm_hour Stunden seit Mitternacht (0-23)
• int tm_mday Tag im Monat (1-31)
• int tm_mon Monat nach Januar (0-11)
• int tm_year Jahr minus 1900
• int tm_wday Wochentag (0-6, 0=Sonntag)
• int tm_yday Tag im Jahr nach 1. Januar (0-365)
• int tm_isdst >0: Sommerzeit, =0: Winterzeit, <0: unbekannt

struct tm *zeit;
time_t sec;
time(&sec);
printf("Datum/Uhrzeit: %s\n", 
       asctime(localtime(&sec)));
/* das lokale Datum und Uhrzeit wird ausgegeben */ 

printf("ln(0.5) = %7.4f\n",log(0.5));
/* Ausgabe: ln(0.5) = -0.6931 */

printf("lg(10) = %4.1f\n", log10(10));
/* Ausgabe: lg(10) = 1.0 */

jmp_buf env;
int retwert;
...
if (setjmp(env) == 0)
printf("Zielmarke initialisiert\n");
else printf("longjmp-Sprung erfolgt\n");
...
longjmp(env,retwert);
/* Ausgabe: Zielmarke initialisiert, wenn TRUE oder
longjmp-Sprung erfolgt, wenn FALSE */

int *feld
feld = (int *) malloc(10*sizeof(int));

Zeiger = memchr(puffer,'!',55);
/* Zeiger = Adresse des ersten Auftretens 
des Zeichens '!' in den vorderen 55 Bytes 
des Puffers */

• < 0, wenn buf1 "kleiner" buf2 ist
• = 0, wenn beide identisch sind
• > 0, wenn buf1 "größer" als buf2 ist

if (memcmp(s1,s2,20) != 0)
  printf("Strings sind ungleich\n");
else
  printf("Strings sind gleich\n");

zeiger = memcpy(ziel,quelle,100);
/* kopiert 100 Bytes von quelle nach ziel,
zeiger erhält die Adresse von ziel */

zeiger = memmove(ziel,quelle,30);
/* kopiert 30 Bytes von quelle nach ziel, 
zeiger erhält die Adresse von ziel */

memset(s,' ',strlen(s));
/* der String wird mit Leerzeichen überschrieben */

• int tm_sec Sekunden nach voller Minute (0-61)
• int tm_min Minuten nach voller Stunde (0-59)
• int tm_hour Stunden seit Mitternacht (0-23)
• int tm_mday Tag im Monat (1-31)
• int tm_mon Monat nach Januar (0-11)
• int tm_year Jahr minus 1900
• int tm_wday Wochentag (0-6, 0=Sonntag)
• int tm_yday Tag im Jahr nach 1. Januar (0-365)
• int tm_isdst >0: Sommerzeit, =0: Winterzeit, <0: unbekannt

time_t heute;
struct tm *morgen;
time(&heute);
morgen = localtime(&heute);
morgen->tm_mday += 1;
if (mktime(morgen) != -1)
  printf("Morgen ist: %s\n",asctime(&zukunft));
else 
  printf("Fehler bei mktime()");

gebr = modf(3.432,&ganz);
printf("gebr = %f, ganz = %d\n",gebr,ganz);
/* Ausgabe: gebr = 0.432, ganz = 3 */

dir = opendir("/var/log/"); 

perror("Hilfe");
/* erzeugt eine Fehlermeldung der Art:
"Hilfe: bla bla bla" */

• x^y
• bei Unter- oder Überlauf: +/-HUGE_VAL
• bei unzulässigen Argumenten: 0

printf("pow(2.0,2.0) = %4.1f\n",pow(2.0,2.0));
/* Ausgabe: pow(2.0,2.0) = 4.0 */

% [Flags] [Feldbreite] [.Genauigkeit] Typ

Flags:
'+'    positive Zahlen mit Vorzeichen
' '    positive Zahlen mit führendem Leerzeichen
'-'    linksbündige Ausgabe

Feldbreite:
Länge des Ausgabefeldes (Ausgabe > Feld: Feld wird vergrößert). Bei Zahlen werden führende Leerzeichen mit Nullen aufgefüllt. Wird als Feldbreite '*' angegeben, bestimmt ein zusätzliches Argument vom Typ int die Feldbreite.

Genauigkeit:
Anzahl der Ziffern hinter dem Dezimalpunkt bei Ausgaben vom Typ f oder e. Anzahl der signifikanten Stellen bei Ausgaben mit g. Mindestzahl an auszugebenden Ziffern bei Ganzzahl-Ausgabe Höchstzahl der auszugebenden Zeichen bei Stringausgabe.

Typ:
gibt Interpretationsart für das Argument an; folgenden Angaben sind möglich

c	Zeichen(-folge) (auch blanks, tabs und newlines werden gelesen) Default (keine Feldgrößenangabe): 1 Zeichen
d	Integer (dezimal)
i	Integer (dezimal) oder oktal (mit führender "0") oder sedezimal (mit führendem "0x" bzw "0X")
o	Integer (oktal, mit oder ohne führende "0")
x	Integer (sedezimal, mit oder ohne führendem "0x" bzw "0X")
u	Integer (dezimal, nur positiv)
e, f, g	Gleitpunktzahl (beliebige Darstellung)
s	String (Ergänzung mit abschließendem '\0')
p	Pointer
h vor d,i,o,u,x	Kurze Integerzahl (short)
l vor d,i,o,u,x	Lange Integerzahl (long)
l vor e,f,g	double
L vor e,f,g	long double

putc(c,fp); 
/* schreibt das Zeichen c an die aktuelle Position
der Datei, die mit fp verbunden ist */

putchar(c); /* gibt das Zeichen c über stdout aus */

puts("Hello World!");

• kleiner 0 : 1. Element < 2. Element
• gleich 0 : 1. Element = 2. Element
• größer 0 : 1. Element > 2. Element

#define MAX 1000
...

 int intcmp(const void *v1, const void *v2)
   { return (*(int *)v1 - *(int *)v2); }

main()
  {
  int arr[MAX], count, suche, *zgr;
  ...

  /* Sortiert das Array in aufsteigender Reihenfolge. */
  qsort(arr, MAX, sizeof(arr[0]), intcmp);
  ...
  
  }

DIR * dp;
struct dirent *entry;
dp = opendir("/var/log/");
while ((entry = readdir(dp)) != NULL)
  {
  printf("*s\n",entry->d_name);
  }
closedir(dp); 

realloc(zeiger,anzahl*sizeof(typ));

remove("bsp.txt");
/* löscht die Datei 'bsp.txt' */

rename("/home/meier/bsp.c","/home/meier/src/bsp1.c");

rewind(fp);

[arg1,...,argn]);

% [Feldbreite] Typ (siehe auch printf).

Eingabefelder werden durch Leerzeichen getrennt

• wird mit Typ s ein String eingelesen, so wird ein Stringende-Zeichen angehängt
• anstelle von s kann auch ein Scanset (Folge von sog. Suchzeichen) angegeben werden, welcher in eckige Klammern eingeschlossen wird; jedes einzulesende Zeichen muß dann mit einem der Suchzeichen übereinstimmen. Ist den Suchzeichen ein '^' vorangestellt, wird das Einlesen beendet, sobald ein Suchzeichen auftritt.
• steht hinter '%' ein '*', wird das entsprechende Eingabefeld überlesen. Es darf kein Argument angegeben werden.

pos = telldir(dir);
/* ... */
seekdir(dir,pos); 

char puffer[BUFSIZ];
setbuf(fp,puffer);

setjmp(env); 

_IOFBF: Ein-/Ausgabe werden vollständig gepuffert
_IOLBF: Ausgaben werden zeilenweise gepuffert, Eingaben werden vollständig gepuffert
_IONBF: Ein-/Ausgaben sind ungepuffert

Falls buffer ein NULL-Zeiger ist, so wird durch einen Aufruf von malloc ein Puffer der Größe size dynamisch angelegt

setvbuf(fp,buffer,_IONBF,sizeof(buffer);
/* setzt für die mit fp verbundene Datei 
ungepufferte Ein-/Ausgabe (buffer und 
sizeof(buffer) werden ignoriert) */

• SIG_DFL: Standardroutine (default) für die Signalnummer wird aufgerufen; danach im allgemeinen Programmende
• SIG_IGN: Signal wird ignoriert, das Programm fortgesetzt
• Adresse einer Funktion: signal(sig,SIG_DFL) wird aufgerufen, dann die Funktion (*func)(sig) (für nächstes sig wird die Standardroutine eingesetzt, dann die eigentliche Reaktion auf das momentane Signal ausführt).

• SIGABRT: abnormale Programmbeendigung (z.B. durch abort; Beenden des Programms)
• SIGHUB: Programmbeendigung durch Elternprozess
• SIGFPE: Divisions-,Coprozessor- oder Emulationsfehler
• SIGINT: durch Drücken von Ctrl-C
• SIGSEGV: durch ungültigen Speicherzugriff
• SIGTERM: Software-Beendigung des Programms (unter UNIX Standardsignal des Kill-Kommandos)

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
void sig_handler(int sig);
main()
  {
  if (signal(SIGINT,sig_handler) == SIGERR)
    { perror("Signal-Funktion"); exit(3); }
  for(;;) /* forever */ 
    puts("Abbruch mit Strg-C!\n");
  }

void sig_handler(int sig)
  {
  char c;
  if (sig != SIGINT) exit(1);
  signal(SIGINT,SIG_IGN);
  fputs("\nProgramm beenden(j/n)?",stderr);
  while((c = toupper(getchar())) != 'J' && c != 'N');
  if(c == 'J') exit(0);
  signal(SIGINT,sig_handler);
  }

printf("sin(0.0) = %4.1f\n", sin(0.0));
/* Ausgabe: sin(0.0) = 0.0 */

printf("sinh(0.0) = 8.4f\n",sinh(0.0));
/* Ausgabe: sinh(0.0) = 0.0000 */

sprintf(text,"%15s %20s",vorname,name);

printf("sqrt(9) = %f\n",sqrt(9));
/* Ausgabe: sqrt(9) = 3.0 */

srand(5); /* initialisiert den Generator mit 5 */

sscanf(adresse,"%[^,],%[^,],%d",ort, straße, &hausnr);
/* liest aus dem String adresse:
1. Teilstring (bis zu einem Komma) in  ort, 
2. Teilstring (bis zu einem Komma) in straße 
und den Rest (eine Zahl) in hausnr */

strcat(s1,s2); /* hängt s2 an s1 an */

P = strchr(text,'.');
/* sucht im String text nach dem ersten 
Auftreten eines Punktes */

x = strcmp("HALLO","hallo");
/* Ergebnis: x = -32 
(da in ASCII die Kleinbuchstaben 
höheren Code haben) */

/* kopiert s2 in den Speicher von s1 */
strcpy(s1,s2);

x = strnspn("Das Ergebnis ist 5","0123456789");

fehlertext = strerror(42);
/* Ausgabe: 
   'Protocol driver not attached' */

x = strlen("Beispiel");
/* Ergebnis: x = 8 */

char s1[20] = "Hello ";
char s2[10] = "Worldwide";
strncat(s1,s2,5);
/* Ergebnis: 'Hello World' */

strncmp(s1,s2,10);

strncpy(s1,"Testphase",4);

zeiger = strpbrk("Blumenweg 3","1234567890");
/*                   zeiger ^              */

P = strchr(text,'.');
/* sucht im String text nach dem letzten 
Auftreten eines Punktes */

laenge = strspn("4500 Naegel","1234567890");
/* Ergebnis: laenge = 4 */

puts(strstr("Heute ist es sehr heiß","sehr"));
/* gibt 'sehr heiß' aus */

• umgewandelte double-Zahl
• keine Umwandlung: 0
• Überlauf: +/- HUGE_VAL
• Unterlauf: 0

printf("Zahl: %f\n",strtod("200,5 Km",&rest));
/* Ausgabe: Zahl: 200.5; rest zeigt auf 'Km' */

zeiger1 = strtok("Hallo, wie geht es"," ");
zeiger2 = strtok(0," ");
/* zeiger1 zeigt auf 'Hallo,' 
   zeiger2 zeigt auf 'wie' */

• umgewandelte long-Zahl
• keine Umwandlung: 0;
• Überlauf: LONG_MIN bzw. LONG_MAX

x = strtol(10 Prozent",&rest,10);
printf("***%ld*** %s\n",x,rest);
/* Ausgabe: ***10*** Prozent */

x = strtoul("2000 Autos",&rest,10)
printf("Zahl : %ld\n", x);
/* Ausgabe: 2000; rest zeigt auf den Reststring 'Autos' */

• NULL-Zeiger: Kommandointerpreter nicht verfügbar
• 0 bei korrekter Ausführung
• ungleich 0 bei einem Fehler

system("/bin/ls -l");
/* Ausgabe des aktuellen Verzeichnisses */

printf("tan(1.0) = %7.4f\n",tan(1.0));
/* Ausgabe: tan(1.0) = 1.5574 */

printf("tanh(2.0) = %7.4f\n",tanh(2.0));
/* Ausgabe: tanh(2.0) = 0.9640 */

pos = telldir(dir);
/* ... */
seekdir(dir,pos); 

time(&zeit);
/* speichert die Anzahl der Sekunden 
seit dem 1.1.1970 0 Uhr in zeit */