fputc

#include <stdio.h>

Prototyp:

int fputc(int c,FILE *fp);

Rückgabewert:

Fehlerfall: EOF; andernfalls: ausgegebenes Zeichen

Beschreibung:

schreibt das Zeichen c auf die aktuelle Dateiposition (wirkungsgleich mit Makro putc)

Beispiel:

fputc(c,fp); /* schreibt das Zeichen c an die

aktuelle Position in die Datei */

 

fputs

#include <stdio.h>

Prototyp:

int fputs(const char *string, FILE *fp);

Rückgabewert:

Fehlerfall: EOF; andernfalls: von EOF verschiedener Wert

Beschreibung:

schreibt die Zeichenkette string in Datei. Das Stringende-Zeichen '\0' wird nicht in die Datei geschrieben.

Beispiel:

fputs(string,fp); /* schreibt string ohne Stringende-Zeichen

in die mit fp verbundene Datei */

 

fread

#include <stdio.h>

Prototyp:

size__t fread(void *buffer,

size__t size, size__t n, FILE *fp);

Rückgabewert:

Anzahl der tatsächlich gelesenen Datenobjekte (ist diese kleiner n -> Fehler oder EOF)

Beschreibung:

liest bis zu n Datenobjekte der Länge size aus der Datei ein und schreibt sie in den Speicherbereich mit Startadresse puffer . size__t ist in stdio.h als unsigned int definiert.

Beispiel:

fread(puffer,sizeof(pufferelement),100,fp);

/* liest 100 Pufferelemente aus der Datei in puffer */

 

free

#include <stdlib.h>

Prototyp:

void free(void *ptr);

Rückgabewert: keiner

Beschreibung:

gibt den Speicherbereich frei, auf dessen Anfang ptr zeigt (Speicher muss zuvor durch malloc, calloc oder realloc reserviert worden sein). Ist ptr ein NULL-Pointer, passiert nichts.

Beispiel:

free(ptr); /* gibt den Speicherbereich frei,

auf dessen Anfang ptr zeigt */

 

freopen

#include <stdio.h>

Prototyp:

FILE *freopen(const char *name,

const char *modus, FILE *fp);

Rückgabewert:

File-Pointer für die neu geöffnete Datei; Fehlerfall: NULL-Zeiger

Beschreibung:

schließt die mit fp verbundene Datei und öffnet die Datei name mit der Zugriffsart modus unter Verwendung des alten Filepointers (Beschreibung der Zugriffsarten bei fopen)

Beispiel:

freopen("bsp.txt","w",stdout);

/* lenkt die Standardausgabe in die Datei bsp.txt um */

 

frexp

#include <math.h>

Prototyp:

double frexp(double x, int *ptr);

Rückgabewert:

Wert der Mantisse

Beschreibung:

zerlegt den double-Wert x in Mantisse m und Exponent exp (zur Basis 2) so dass gilt: x = m * 2.

Der Exponent exp wird an der durch ptr adressierten Speicherstelle abgelegt. Ist x= 0, dann erhalten m und exp den Wert 0.

Beispiel:

m = frexp(9.5,&exp);

printf("Mantisse m = %f, exp = %d\n",m,exp);

/* Ausgabe: Mantisse m = 0.5937..., exp = 4 */

 

fscanf

#include <stdio.h>

Prototyp:

int fscanf(FILE *fp, const char

*formatstring[,arg1,arg2,..]);

Rückgabewert:

Anzahl der tatsächlich gelesenen Datenfelder; Dateiende erreicht: EOF

Beschreibung:

liest Elemente aus der Datei, interpretiert sie unter Kontrolle des formatstrings und legt sie in den durch arg1, arg2, ... adressierten Speicherplätzen ab. formatstring wird in der bei scanf beschriebenen Weise gebildet arg1, ... ist ein Zeiger auf eine Variable, deren Typ mit der entsprechenden Typangabe im Format-String übereinstimmen muss.

Beispiel:

fscanf(fp,"%10s %ld",name,&nummer);

printf("name = %s nummer = %ld\n",name,nummer);

/* Ausgabe des Strings "name" und der long-Zahl "nummer" */

 

fseek

#include <stdio.h>

Protoyp:

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

Rückgabewert:

Fehlerfall: Wert ungleich 0; andernfalls: 0

Beschreibung:

verschiebt den Seek-Zeiger um offset Bytes

- 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.

Beispiel:

fseek(fp,48L,0);

/* setzt den Seek-Zeiger 48 Bytes nach Dateianfang */

 

fsetpos

#include <stdio.h>

Prototyp:

int fsetpos(FILE *fp,const fpos__t *ppos);

Rückgabewert:

0; Fehlerfall: von 0 verschiedener Wert

Beschreibung:

setzt den Seek-Zeiger der Datei an die neue Position *ppos (z.B. durch fgetpos() ermittelt). fpos__t ist in stdio.h als long definiert. Tritt ein Fehler auf, so erhält errno den Wert EINVAL oder EBADF.

Beispiel:

fsetpos(fp,&pos);

/* setzt den Seek-Pointer der Datei an die durch pos

gekennzeichnete Stelle */

 

ftell

#include <stdio.h>

Prototyp:

long ftell(FILE *fp);

Rückgabewert:

aktuelle Position des Seek-Zeigers; Fehlerfall: -1L

Beschreibung:

ermittelt die aktuelle Position in der Datei. Im Fehlerfall erhält errno den Wert EINVAL (invalid argument) oder EBADF (bad file number).

Beispiel:

pos = ftell(fp);

/* pos wird die aktuelle Position in der Datei zugewiesen */

 

fwrite

#include <stdio.h>

Prototyp:

size__t fwrite(void *buffer,

size__t size, size__t n, FILE *fp);

Rückgabewert:

Anzahl der Datenobjekte, die tatsächlich in die Datei geschrieben wurden.

Beschreibung:

schreibt n Datenobjekte der Größe size aus dem durch buffer adressierten Puffer in die Datei. size__t ist in stdio.h als unsigned int definiert.

Beispiel:

fwrite(puffer,sizeof(pufferelement),4,fp);

/* schreibt 4 pufferelemente aus puffer in die mit fp

verbundene Datei */

 

getc

#include <stdio.h>

Prototyp:

int getc(FILE *fp);

Rückgabewert:

eingelesenes Zeichen, Fehler oder Dateiende: EOF

Beschreibung:

Der Makro liest das nächste Zeichen aus der Datei

Beispiel:

c = getc(fp);

/* weist c das nächste Zeichen aus der Datei zu */

 

getchar

#include <stdio.h>

Prototyp:

int getchar(void);

Rückgabewert:

eingelesenes Zeichen, Fehler oder Dateiende: EOF

Beschreibung:

Der Makro liest das nächste Zeichen von stdin

Beispiel:

c = getchar();

/* weist c das nächste Zeichen von stdin zu */

 

getenv

#include <stdlib.h>

Prototyp:

char *getenv(const char *name);

Rückgabewert:

Zeiger auf den entsprechenden Eintrag; kein Name: NULL

Beschreibung:

sucht die Tabelle der Umgebungsvariablen nach dem zu name gehörenden Eintrag ab

Beispiel:

ptr = getenv("PATH");

/* weist ptr den Inhalt des "PATH"-Eintrages in der Umgebung zu */

 

gets

#include <stdio.h>

Prototyp:

char *gets(char *buffer);

Rückgabewert:

Funktion liefert ihr Argument als Rückgabe, Fehler oder Dateiende: NULL-Zeiger

Beschreibung:

liest eine Textzeile bis zum Newline-Zeichen "\n" von der stdin und schreibt sie in den durch buffer adressierten Speicherbereich. "\n" wird durch "\0" ersetzt

Beispiel:

char buffer[100];

gets(buffer);

/* liest Textzeile in buffer ein */

 

gmtime

#include <time.h>

Prototyp:

struct tm *gmtime(const time__t *sec);

Rückgabewert:

Zeiger auf Struktur vom Typ tm

Beschreibung:

wandelt die mit sec angegebene Anzahl von Sekunden, die seit 1.1.1970 0 Uhr vergangen sind, in das entsprechende Datum um. GMT - Greenwich Mean Time. tm ist in time.h definiert (Erläuterung bei mktime).

Beispiel:

time__t sec;

time(&sec);

printf("Datum und Uhrzeit (GMT): %s\n", asctime(gmtime(&sec)));

/* gibt aktuelles Datum und Uhrzeit nach GMT aus */

 

isalnum

#include <ctype.h>

Prototyp:

int isalnum(int c);

Rückgabewert:

alphanumerisches Zeichen: Wert ungleich 0; andernfalls 0

Beschreibung:

Makro überprüft, ob das Zeichen in c ein alphanumerisches Zeichen ist, d.h. ein Buchstabe des englischen Alphabets oder eine Ziffer (Zeichen 0 bis 127 im ASCII).

Beispiel:

if (isalnum(c))

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

/* gibt Meldung aus, wenn c alphanumerisch ist */

 

isalpha

#include <ctype.h>

Prototyp:

int isalpha(int c);

Rückgabewert:

kein Buchstabe: 0; Buchstabe: Wert ungleich 0

Beschreibung:

Makro prüft ob das Zeichen c ein Buchstabe des englischen Alphabets ist

Beispiel:

if (isalpha(c))

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

/* gibt ein Meldung aus, wenn c ein Buchstabe ist */

 

iscntrl

#include <ctype.h>

Prototyp:

int iscntrl(int c);

Rückgabewert:

Steuerzeichen: Wert ungleich 0; andernfalls : 0

Beschreibung:

Makro prüft, ob das Zeichen c ein Steuerzeichen ist (Zeichen 0 bis 31 und 127 im ASCII)

Beispiel:

if (iscntrl(c))

printf("Steuerzeichen\n");

/* gibt eine Meldung aus, wenn c ein Steuerzeichen ist */

 

isdigit

#include <ctype.h>

Prototyp:

int isdigit(int c);

Rückgabewert:

Ziffer: Wert ungleich 0; andernfalls: 0

Beschreibung:

Makro prüft, ob das Zeichen c eine Ziffer (0, 1, ..., 9) ist.

Beispiel:

if (isdigit(c))

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

/* gibt eine Meldung aus, wenn c eine Ziffer ist */

 

isgraph

#include <ctype.h>

Prototyp:

int isgraph(int c);

Rückgabewert:

grafisches Zeichen: Wert ungleich 0; andernfalls: 0

Beschreibung:

Makro prüft, ob das Zeichen c ein grafisches Zeichen ist (Zeichen 33 bis 126 im ASCII)

Beispiel:

if (isgraph(c))

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

/* gibt eine Meldung aus, wenn c ein grafisches Zeichen ist */

 

islower

#include <ctype.h>

Prototyp:

int islower (int c);

Rückgabewert:

Kleinbuchstabe: Wert ungleich 0; andernfalls: 0

Beschreibung:

Makro prüft, ob das Zeichen c ein Kleinbuchstabe ist (ä, ö, ü und ß bleiben unberücksichtigt)

Beispiel:

if (islower(c))

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

/* gibt eine Meldung aus, wenn c ein Kleinbuchstabe ist */

 

isprint

#include <ctype.h>

Prototyp:

int isprint(int c);

Rückgabewert:

druckbares Zeichen: Wert ungleich 0; andernfalls: 0

Beschreibung:

Makro prüft, ob das Zeichen c ein druckbares Zeichen ist (Zeichen 32 bis 127 im ASCII)

Beispiel:

if (isprint(c))

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

/* gibt eine Meldung aus,

wenn c ein druckbares Zeichen ist */

 

ispunct

#include <ctype.h>

Prototyp:

int ispunct(int c);

Rückgabewert:

Interpunktionszeichen: Wert ungleich 0; andernfalls: 0

Beschreibung:

Makro prüft, ob das Zeichen c ein Interpunktionszeichen ist (alle grafischen Zeichen ohne Ziffern und Buchstaben).

Beispiel:

if (ispunct(c))

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

/* gibt eine Meldung aus, wenn c ein Interpunktions-

zeichen ist */

 

isspace

#include <ctype.h>

Prototyp:

int isspace (int c);

Rückgabewert:

Zwischenraumzeichen: Wert ungleich 0; andernfalls: 0

Beschreibung:

Makro prüft, ob das Zeichen c ein Zwischenraumzeichen ist, d.h. ein horizontales oder vertikales Tabulatorzeichen, ein Zeichen für Zeilen- oder Seitenvorschub, ein Carriage-Return- oder ein Leerzeichen ist

Beispiel:

if (isspace(c))

printf("%c ist ein Zwischenraumzeichen\n",c);

/* gibt eine Meldung aus, wenn c ein Zwischenraumzeichen ist */

 

isupper

#include <ctype.h>

Prototyp:

int isupper(int c);

Rückgabewert:

Großbuchstabe: Wert ungleich 0; andernfalls: 0

Beschreibung:

Makro prüft, ob das Zeichen c ein Großbuchstabe ist (Ä, Ö und Ü bleiben unberücksichtigt)

Beispiel:

if (isupper(c))

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

/* gibt eine Meldung aus, wenn c ein Großbuchstabe ist */

 

isxdigit

#include <ctype.h>

Prototyp:

int isxdigit(int c);

Rückgabewert:

Hexadezimalziffer: Wert ungleich 0; andernfalls: 0

Beschreibung:

Makro prüft, ob das Zeichen c eine Hexadezimalziffer ist (0 bis 9, a bis f und A bis F)

Beispiel:

if (isxdigit(c))

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

/* gibt eine Meldung aus, wenn c eine Hexadezimalziffer ist */

 

labs

#include <stdlib.h>

Prototyp:

long labs(long x);

Rückgabewert:

| x |

Beschreibung:

liefert den Absolutwert des long-Wertes x

Beispiel:

printf("labs(-9876543) = %ld",labs(-9876543));

/* Ausgabe: labs(-9876543) = 9876543 */

 

ldexp

#include <math.h>

Prototyp:

double ldexp(double m, int exp);

Rückgabewert:

m * 2; bei Überlauf:

HUGE__VAL mit Vorzeichen

Beschreibung:

berechnet den Wert m * 2; im Falle eines Überlauf erhält errno den Wert ERANGE

Beispiel:

printf("ldexp(3.0,4) = %.1f",ldexp(3.0,4));

/* Ausgabe: ldexp(3.0,4) = 48 */

 

ldiv

#include <stdlib.h>

Prototyp:

ldiv__t ldiv(long x, long y);

Rückgabewert:

Struktur von Typ ldiv__t

Beschreibung:

dividiert die beiden long-Werte x/y, dabei werden der ganzzahlige Anteil des Ergebnisses und der Rest in einer Variablen vom Typ ldiv__t abgelegt. ldiv__t wird in stdlib.h definiert.

Beispiel:

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 */

 

localtime

#include <time.h>

Prototyp: struct tm *localtime(const time__t *sec);

Rückgabewert:

Zeiger auf Struktur vom Typ tm

Beschreibung:

wandelt die Anzahl der Sekunden (sec) seit 1.1.1970 0 Uhr in das lokale Datum und Uhrzeit um time__t ist in time.h als long definiert tm ist ebenfalls in time.h definiert (Erklärung bei mktime).

Beispiel:

struct tm *zeit;

time__t sec;

time(&sec);

printf("Datum und Zeit : %s\n", asctime(localtime(&sec)));

/* das lokale Datum und Uhrzeit wird ausgegeben */

 

log

#include <math.h>

Prototyp:

double log(double x);

Rückgabewert:

ln(x); bei negativem Argument oder 0: HUGE__VAL

Beschreibung:

liefert den natürlichen Logarithmus von x bei negativen Argumenten erhält errno den Wert EDOM. Ist x = 0 so erhält errno jedoch ERANGE

Beispiel:

printf("ln(0.5) = %7.4f\n",log(0.5));

/* Ausgabe: ln(0.5) = -0.6931 */

 

log10

#include <math.h>

Prototyp:

double log10(double x);

Rückgabewert:

lg(x); bei negativem Argument oder 0: HUGE__VAL

Beschreibung:

liefert den dekadischen Logarithmus von x. Bei negativen Argumenten erhält errno den Wert EDOM, ist x = 0 so erhält errno den Wert ERANGE.

Beispiel:

printf("lg(0.1) = %4.1f\n", log10(0.1));

/* Ausgabe: lg(0.1) = -1.0 */

 

longjmp

#include <setjmp.h>

Prototyp: void longjmp(jmp__buf env, int retwert);

Rückgabewert:

keiner

Beschreibung:

ermöglicht Sprünge, die nicht an eine feste Zeile im Programm gebunden sind. Das Programm verzweigt zu der Stelle, an der zuvor die Funktion setjmp aufgerufen wurde. Der alte Maschinenzustand und die Stack-Umgebung, welche in env gespeichert sind, werden wiederhergestellt.

retwert stellt einen Wert ungleich 0 dar (um von setjmp unterscheidbar zu sein). jmp__buf ist in setjmp.h definiert.

Beispiel für longjmp und setjmp:

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 */

 

malloc

#include <stdlib.h>

Prototyp:

void *malloc(size__t size);

Rückgabewert:

typenloser Zeiger auf Startadresse des bereitgestellten Speichers; im Fehlerfall: NULL-Zeiger

Beschreibung:

reserviert einen Speicherbereich von size Bytes. size__t ist in stdlib.h als unsigned int definiert.

Beispiel:

int *feld

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

/* reserviert Speicherplatz für ein Feld mit 10 Integer-Werten */

 

memchr

#include <string.h>

Prototyp:

void *memchr(const void *buffer,

int c, size__t n);

Rückgabewert:

Zeiger auf erstes Auftreten des Zeichens c im Puffer

Beschreibung:

bestimmt in den ersten n Bytes des Puffers buffer das erste Auftreten des Zeichens c. size__t ist in string.h als unsigned int definiert.

Beispiel:

zeiger = memchr(puffer,c,55);

/* weist zeiger die Adresse des ersten Auftretens des

Zeichens c in den ersten 55 Bytes des Puffers puffer zu */

 

memcmp

#include <string.h>

Prototyp:

int memcmp(const void *buf1,

const void *buf2, size__t n);

Rückgabewert:

< 0 : wenn buf1 "kleiner" buf2 ist

= 0 : wenn beide identisch sind

> 0 : wenn buf1 "größer" als buf2 ist

Beschreibung:

vergleicht die ersten n Bytes des Puffers buf1 mit denen des buf2. Der Vergleich bricht beim ersten verschiedenen Zeichen ab. size__t ist in string.h als unsigned int definiert.

Beispiel:

if (memcmp(s1,s2,20) != 0)

printf("Strings sind ungleich\n");

else

printf("Strings sind gleich\n");

 

memcpy

#include <string.h>

Prototyp:

void *memcpy(void *dest,

const void *src, size__t n);

Rückgabewert:

Zeiger auf dest

Beschreibung:

kopiert Anzahl n Bytes von der Quelle src zum Ziel dest. size__t ist in string.h als unsigned int definiert. Im Unterschied zu memmove wird bei einer eventuellen Überlappung der Speicherbereiche nicht sichergestellt, dass zuerst gelesen und dann geschrieben wird.

Beispiel:

zeiger = memcpy(ziel,quelle,100);

/* 100 Bytes werden von quelle nach ziel kopiert,

zeiger erhält die Adresse von ziel */

 

memmove

#include <string.h>

Prototyp:

void *memmove(void *dest,

const void *src,size__t n);

Rückgabewert:

Zeiger auf dest

Beschreibung:

kopiert n Bytes von src nach dest. size__t ist in string.h als unsigned int definiert. Im Unterschied zu memcpy wird bei einer eventuellen Überlappung der Speicherbereiche zuerst gelesen und dann überschrieben.

Beispiel:

zeiger = memmove(ziel,quelle,30);

/* kopiert 30 Bytes von quelle nach ziel und zeiger

erhält die Adresse von ziel */

 

memset

#include <string.h>

Prototyp:

void memset(void *dest, int c,

unsigned int n);

Rückgabewert:

Zeiger auf dest

Beschreibung:

füllt die ersten n Bytes von dest mit dem Wert von c

Beispiel:

memset(s,' ',3);

/* die ersten 3 Byte des Strings s werden mit

Leerzeichen überschrieben */

 

mktime

#include <time.h>

Prototyp:

time__t mktime(struct tm *ptr);

Rückgabewert:

Anzahl der Sekunden; im Fehlerfall: -1

Beschreibung:

wandelt die durch den Zeiger ptr adressierten Zeitangaben in die Anzahl von Sekunden seit dem 1.1.1970 0 Uhr um. tm ist in time.h definiert.

Beispiel:

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()");

/* erhöht den Wochentag um 1 und wandelt die so entstandene Struktur

in eine Zeit, die dann mit Hilfe von asctime() ausgegeben wird */

 

modf

#include <math.h>

Prototyp:

double modf(double x, double *intpart);

Rückgabewert:

gebrochener Anteil von x

Beschreibung:

spaltet Fließkommazahl x in einen gebrochen-rationalen und einen ganz-rationalen Teil auf, welcher in intpart gespeichert wird.

Beispiel:

gebr = modf(3.432,&ganz);

printf("gebr = %f, ganz = %d\n",gebr,ganz);

/* Ausgabe: gebr = 0.432, ganz = 3 */

 

perror

#include <stdio.h>

Prototyp:

void perror(const char *string);

Rückgabewert:

keiner

Beschreibung:

sendet Fehlermeldung zur Standardfehlerausgabe stderr, zuerst wird string ausgegeben, gefolgt von ": " und anschließend der Systemfehler

Beispiel:

perror(text);

/* erzeugt eine Fehlermeldung der Art:

"text": "Systemfehlermeldung" */

 

pow

#include <math.h>

Prototyp:

double pow(double x,double y);

Rückgabewert:

xy ; bei Unter- oder Überlauf: HUGE__VAL (+/-); bei unzulöässigen Argumenten: 0

Beschreibung:

berechnet xy. Bei Unter-/Überlauf erhält errno den Wert ERANGE. Falls die Argumente nicht im Definitionsbereich liegen, wird eine entsprechende Fehlermeldung auf stderr ausgegeben. errno erhält den Wert EDOM.

Beispiel:

printf("pow(2.0,2.0) = %4.1f\n",pow(2.0,2.0));

/* Ausgabe: pow(2.0,2.0) = 4.0 */

 

printf

#include <stdio.h>

Prototyp:

int printf(const char *formatstring,...,

[arg1,...,argn]);

Rückgabewert:

Anzahl der ausgegebenen Zeichen; im Fehlerfall: EOF

Beschreibung:

gibt formatstring auf stdout aus. Formatelemente werden durch Werte aus der Argumentenliste ersetzt. Ein Formatelement bestimmt die Interpretation des Arguments folgendermaßen:

% [Flags] [Feldbreite] [.Genau] typ

Flags:

'+' - positive Zahlen mit Vorzeichen

' ' - positive Zahlen mit führendem Leerzeichen

'-' - linksbündige Ausgabe

Feldbreite:

Länge des Ausgabefeldes (Ausgabe > Feld : Feld vergrößert)

bei Zahlen werden führende Leerzeichen mit Nullen aufgefüllt

'*' - zusätzliches Argument vom Typ int bestimmt 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

typ

Argument-Typ

Ausgabe

d, i

int

dezimal

unsigned int

dezimal

unsigned int

oktal

unsigned int

hexadezimal (klein)

unsigned int

hexadezimal (groß)

f

float/double

Gleitkommazahl

e, E

float/double

Exponentialform

g, G

float/double

Gleitkomma oder Exponential (kürzere)

char / int

einzelnes Zeichen

String

Ausgabe bis '\0'

int *

speichert im Argument bis dahin ausgegebene Zeichen

Zeiger

im Argument enthaltene Adresse wird in hexadezimaler

Form ausgegeben

%

keiner

'%' wird ausgegeben

bei long-Argumenten muss den Typangaben ein 'l' vorangestellt werden

bei short-Argumenten muss den Typangaben ein 'h' vorangestellt werden

bei long double-Argumenten muss den Typangaben ein 'L' vorangestellt werden

Beispiel:

Die printf-Funktion wird zur Ausgabe bei den meisten Beispielen verwendet.