next up previous contents
Nächste Seite: A. Tips am Rande Aufwärts: 19 Die Standardbibliothek Vorherige Seite: 19.3 Headerdateien und Überblick   Inhalt

Unterabschnitte

19.4 Liste der Funktionen

In diesem Abschnitt werden die Funktionen aus der Standardbibliothek von ANSI-C aufgelistet.

Nach der Angabe der #include -Datei, in der die jeweilige Funktion deklariert ist, und der Deklaration selbst, wird die Funktion vorgestellt. Soweit vorhanden, werden Parameter und Rückgabewert angegeben.

Von Fall zu Fall wird ein kleines Verwendungsbeispiel angegeben.

Die Funktionen sind alphabetisch sortiert.

Alle Funktionen, die in einer tatsächlichen Implementation vorhanden sind, aber hier nicht oder mit einer anderen Funktionsweise genannt sind, sollten so weit als möglich vermieden werden, da der Quelltext dann nicht mehr portierbar ist.

Müssen solche Funktionen unbedingt verwendet werden, sollte man darauf achten, daß sie nur in wenigen, möglichst übersichtlichen Teilen des Programms vorkommen und von der eigentlichen Programmlogik möglichst weit getrennt werden. Das Abtrennen vom eigentlichen Programm und deutliches Kommentieren aller Abweichungen vom ANSI-Standard erleichtert ein späteres Übertragen sowie Einarbeiten fremder Personen enorm. Für spätere Portierungen ist es außerdem sehr hilfreich, wenn bei zusätzlichen Funktionen, die nicht standardisiert sind, als Kommentar die genaue Funktionsweise oder eine entsprechende Literaturangabe im Quelltext erscheint. Sonst kann es passieren, daß die Funktion auf einem anderen System nicht existiert und nachgebildet werden muß, aber niemand mehr so genau weiß, was die Funktion eigentlich macht.


abort() 

#include <stdlib.h>

void abort( void );

bricht das Programm unmittelbar ab.

Funktionen, die mit atexit() eingetragen wurden, werden nicht ausgeführt; offene Dateien werden nicht geschlossen oder ihre Puffer ausgeschrieben; temporäre Dateien (mit tmpfile() geöffnet) werden nicht gelöscht. Das Signal SIGABRT wird mit raise( SIGABRT ) erzeugt und das Programm dann mit dem Rückgabewert 3 abgebrochen.

\bgroup\color{Red}$\rightarrow$\egroupexit(), raise(), assert()


abs() 

#include <stdlib.h>

int abs( int wert );

gibt den Absolutbetrag von wert zurück.

\bgroup\color{Red}$\rightarrow$\egrouplabs(), fabs()


acos() 

#include <math.h>

double acos( double argument );

liefert den ersten Wert des \bgroup\color{Red}$\arccos(\tt argument)$\egroup im Bogenmaß (im Bereich 0.0... \bgroup\color{Red}$\pi$\egroup). argument muß dazu im Bereich -1.0...+1.0 liegen. Ansonsten wird 0.0 zurückgegeben und errno wird auf EDOM gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupcos(), asin(), atan(), atan2()


asctime() 

#include <time.h>

char *asctime( const struct tm *tm_zeiger );

liefert einen Zeiger auf einen String, der die Zeit in *tm_zeiger beschreibt. Beispielsweise liefert das Programm 

#include <time.h>
#include <stddef.h>             /* wegen NULL                 */

main()
{
    time_t      t;

    t = time( NULL );       /* Die Uhrzeit des Rechners lesen */

    /* Die aktuelle Zeit in eine struct tm verwandeln,
     * von da in einen String und ausgeben
     */
    printf( "es ist jetzt %s",
            asctime( localtime( &t ) ) );
    printf( "ok.\n" );
}

die aktuelle Uhrzeit in der Form 

es ist jetzt Mon Mar 11 20:37:20 1991
ok.

Eine für hiesige Gewohnheiten gefälligere Form der Zeitdarstellung wird auf Seite [*] vorgeführt.

Die Positionen der einzelnen Felder in dem 26 Zeichen langen String sind immer gleich und der String ist mit \n und \0 beendet.

Platz für den String braucht nicht bereitgestellt zu werden, sondern ist statisch in der Funktion asctime() vorhanden und wird beim nächsten Aufruf derselben oder ctime() überschrieben.

\bgroup\color{Red}$\rightarrow$\egroupctime(), strftime(), mktime(), time()


asin() 

#include <math.h>

double asin( double argument );

liefert den ersten Wert des \bgroup\color{Red}$\arcsin(\tt argument)$\egroup im Bogenmaß (im Bereich \bgroup\color{Red}$-\pi / 2 \ldots +\pi / 2$\egroup). argument muß dazu im Bereich -1.0...+1.0 liegen. Ansonsten wird 0.0 zurückgegeben und errno wird auf EDOM gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupsin(), acos(), atan(), atan2()


assert() 

#include <assert.h>

void assert( int ausdruck );

ist ein Makro zur Fehlersuche während der Programmentwicklung.

Wenn vor der Praeprozessoranweisung #include <assert.h> die Anweisung 

#define NDEBUG
steht, dann wird assert() vom Praeprozessor aus dem Programm entfernt und bewirkt nichts.

Ansonsten wird vom Praeprozessor ein Stück Quelltext so erzeugt, daß der ausdruck ausgewertet wird und im Falle von 0 bzw. logisch falsch wird eine Meldung in der Form

assertion ausdruck failed: file Dateiname line Zeilennummer

ausgegeben und anschließend das Programm mit abort() abgebrochen.

Siehe auch die Funktion abort().

Ein Beispiel zur Verwendung von assert() ist in Fehlersuche mit Standard-C zu finden.

\bgroup\color{Red}$\rightarrow$\egroupabort(), exit()


atan() 

#include <math.h>

double atan( double argument );

liefert den ersten Wert von \bgroup\color{Red}$\arctan(\tt argument)$\egroup im Bogenmaß (im Bereich \bgroup\color{Red}$-\frac{\pi}{2}\ldots+\frac{\pi}{2}$\egroup).

\bgroup\color{Red}$\rightarrow$\egrouptan(), asin(), acos(), atan2()


atan2() 

#include <math.h>

double atan2( double zaehler, double nenner );

liefert den ersten Wert des \bgroup\color{Red}$\arctan(\frac{\tt zaehler}{\tt nenner})$\egroup im Bogenmaß (im Bereich \bgroup\color{Red}$-\pi$\egroup \bgroup\color{Red}$\ldots$\egroup \bgroup\color{Red}$+\pi$\egroup).

zaehler und nenner dürfen dabei nicht beide den Wert 0.0 haben; in diesem Fall wird errno auf EDOM gesetzt und 0.0 zurückgegeben.

\bgroup\color{Red}$\rightarrow$\egrouptan(), asin(), acos(), atan()


atexit() 

#include <stdlib.h>

int atexit( void ( *funktion_zeiger )( void );

sorgt dafür, daß bei einem normalen Programmende ( return in main() oder exit()) die Funktion, auf die funktion_zeiger zeigt, aufgerufen wird. *funktion_zeiger erhält keinen Parameter und liefert keinen Rückgabewert. Werden mehrere Funktionen so installiert, dann werden sie bei Programmende entgegen ihrer Installationsreihenfolge ausgeführt. Zu diesem Zeitpunkt existieren keine automatischen Variablen mehr, aber offene Dateien und temporäre Dateien sind noch verwendbar.

Wird das Programm mit abort() beendet, dann werden die mit atexit() installierten Funktionen nicht ausgeführt.

Rückgabewert ist ungleich 0, wenn zuviele Einträge mit atexit() installiert wurden.

Beispielaufruf: 

/* fuassert.c 30. 7.95 kw
 */

#include <stdlib.h>

void erste( void )
{
  printf( "Hallo, hier ist die erste!\n" );
}

void zweite( void )
{
  printf( "Hallo, hier ist die zweite!\n" );
}

int main()
{
  /* die beiden obigen Funktionen installieren,
   * damit sie bei Programmende aufgerufen werden:
    */
  atexit( &erste );
  atexit( &zweite );

  /* Jetzt koennte das Programm irgendetwas tun ...
   */
  printf( "irgendetwas tun ...\n" );

  /* ... und dann beenden.
   * Nach diesem return werden die mit atexit()
   * installierten Funktionen in umgekehrter
   * Reihenfolge ausgefuehrt:
   */
  return 0;
}

Ausgabe davon: 

irgendetwas tun ...
Hallo, hier ist die zweite!
Hallo, hier ist die erste!

\bgroup\color{Red}$\rightarrow$\egroupexit(), abort()


atof() 

#include <stdlib.h>

double atof( const char *string );

verwandelt string soweit möglich in eine double ; dabei wird beim ersten Zeichen in string abgebrochen, das nicht als Bestandteil einer Gleitkommazahl interpretiert werden kann. Kann überhaupt kein Zeichen umgewandelt werden, dann wird 0.0 zurückgegeben.

Die Funktion atof() sollte für Neuentwicklungen nicht mehr verwendet werden. Sie ist nur zur Kompatibilität mit älteren C-Versionen vorhanden und kann durch strtod( string, NULL ) ersetzt werden.

Wenn der Wertebereich von double nicht ausreicht, um das Ergebnis der Umwandlung darzustellen, dann ist der Rückgabewert unbestimmt.

\bgroup\color{Red}$\rightarrow$\egroupstrtod(), atoi(), atol(), sscanf()


atoi() 

#include <stdlib.h>

int atoi( const char *string );

verwandelt string soweit möglich in eine int ; dabei wird beim ersten Zeichen in string abgebrochen, das nicht als Bestandteil einer ganzen Zahl interpretiert werden kann. Kann überhaupt kein Zeichen umgewandelt werden, dann wird 0 zurückgegeben.

Die Funktion atoi() sollte für Neuentwicklungen nicht mehr verwendet werden. Sie ist nur zur Kompatibilität mit älteren C-Versionen vorhanden und kann durch

(int)strtol( string, NULL, 10 )

ersetzt werden.

Wenn der Wertebereich von int nicht ausreicht, um das Ergebnis der Umwandlung darzustellen, dann ist der Rückgabewert unbestimmt.

\bgroup\color{Red}$\rightarrow$\egroupstrtol(), atof(), atol(), sscanf()


atol() 

#include <stdlib.h>

long int atol( const char *string );

verwandelt string soweit möglich in eine long int ; dabei wird beim ersten Zeichen in string abgebrochen, das nicht als Bestandteil einer ganzen Zahl interpretiert werden kann. Kann überhaupt kein Zeichen umgewandelt werden, dann wird 0L zurückgegeben.

Die Funktion atol() sollte für Neuentwicklungen nicht mehr verwendet werden. Sie ist nur zur Kompatibilität mit älteren C-Versionen vorhanden und kann durch strtol( string, NULL, 10 ) ersetzt werden.

Wenn der String eine zu große Zahl für den Wertebereich von long int ergibt, dann ist das Ergebnis nicht definiert und errno wird zu ERANGE gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupatoi(), atof(), sscanf()


bsearch() 

#include <stdlib.h>

void *bsearch( const void *suchschluessel,
               const void *feldanfang,
               size_t     elemente,
               size_t     elementgroesse,
               int ( *vergleichsfunktion )( const void *e1,
                                            const void *e2  )
             );

sucht in einem Feld nach einem Element, das den Wert (*suchschluessel) hat und liefert einen Zeiger auf dieses Element, wenn folgende Bedingungen erfüllt sind:

  • Das Feld beginnt an der Stelle feldanfang im Speicher.
  • Das Feld hat (elemente) Elemente jeweils der Größe (elementgroesse) .
  • vergleichsfunktion zeigt auf eine Funktion, die zwei Zeiger auf je ein Feldelement entgegennimmt und einen negativen int -Wert liefert, wenn der erste Parameter auf ein Element mit kleinerem Suchschlüssel zeigt als der zweite Parameter, 0 liefert, wenn beide Parameter auf Elemente mit gleich großem Suchschlüssel zeigen und sonst einen positiven Wert liefert.
  • Das Feld ist gemäß den Kriterien der vergleichsfunktion aufsteigend sortiert.
Trifft (*suchschluessel) auf keines der Elemente im Feld zu, dann liefert bsearch() den Wert NULL .

Trifft (*suchschluessel) auf mehrere Feldelemente zu, dann wird eines davon geliefert; aber es kann nicht vorhergesagt werden, welches.

Das folgende Beispiel liest einige Vor- und Nachnamen ein und sortiert sie nach den Vornamen. Dann kann der Benutzer einen Vornamen eingeben, zu dem der Nachname gesucht wird: 

/* fubsear.c 30. 7.95 kw
 */

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

#define         NP      5

/* Datentyp, um einen Vor- und einen Nachnamen zu speichern:
 */
typedef struct
{
  char    vorname[30];
  char    nachname[30];
}
person_t;

/* davon ein Feld:
 */
person_t        personfeld[NP];

/* vergleicht fuer qsort() oder bsearch() zwei Feldelemente
 * (nach Vornamen):
 */
int vergl_vn( const void *p1, const void *p2 )
{
  return strcmp( ((person_t *)p1)->vorname,
                 ((person_t *)p2)->vorname
                 );
}

int main()
{
  int         i;
  person_t
    vergleichsperson,
    *gefunden;

  /* Personen einlesen:
   */
  for( i=0; i<NP; i++ )
  {
    printf( "Bitte den Vornamen:  " );
    scanf( "%s", personfeld[i].vorname );
    printf( "Bitte den Nachnamen: " );
    scanf( "%s", personfeld[i].nachname );
  }

  /* Nach Vornamen sortieren:
   */
  qsort( personfeld, NP, sizeof(person_t), vergl_vn );

  /* Nach einem Vornamen fragen und die Person suchen:
   */
  printf( "Bitte einen Vornamen:  " );
  scanf( "%s", vergleichsperson.vorname );
  gefunden = bsearch( &vergleichsperson,
                      personfeld,
                      NP,
                      sizeof(person_t),
                      vergl_vn
                      );
  if( NULL==gefunden )
  {
    puts( "Den kann ich nicht finden!" );
  }
  else
  {
    printf( "%s %s\n",
            gefunden->vorname,
            gefunden->nachname );
  }

  return 0;
}

Bei älteren, nicht ANSI-konformen Compilern kann es sein, daß die Anweisung 

        gefunden = bsearch( &vergleichsperson,
                            personfeld,
                            NP,
                            sizeof(person_t),
                            vergl_vn             );
geändert werden muß zu: 
        gefunden = bsearch( &vergleichsperson,
                            personfeld,
                            NP,
                            sizeof(person_t),
                            &vergl_vn            );
(siehe dazu Zeiger auf Funktionen).

\bgroup\color{Red}$\rightarrow$\egroupqsort()


calloc() 

#include <stdlib.h>

void *calloc( size_t wieviele, size_t wiegross );

versucht, einen Speicherblock mit (wieviele*wiegross) Bytes zu reservieren. Der reservierte Speicher wird in ganzer Länge auf den Wert 0 gesetzt.

Rückgabewert ist ein Zeiger auf den Anfang des reservierten Blocks, wenn alles gut ging, oder der NULL -Zeiger, wenn kein Block ausreichender Größe zu haben ist.

\bgroup\color{Red}$\rightarrow$\egroupfree(), malloc(), realloc()


ceil() 

#include <math.h>

double ceil( double wert );

liefert die nächstgrößere ganze Zahl zu wert als double .

Beispiel: 

#include <math.h>

int main()
{
  double  d;

  for( d=-2.0; d<2.0; d+=0.2 )
    printf( "ceil(%f) = %f\n", d, ceil(d) );
}

Dieses Programm liefert die Ausgabe: 

ceil(-2.000000) = -2.000000
ceil(-1.800000) = -1.000000
ceil(-1.600000) = -1.000000
ceil(-1.400000) = -1.000000
ceil(-1.200000) = -1.000000
ceil(-1.000000) = -1.000000
ceil(-0.800000) = -0.000000
ceil(-0.600000) = -0.000000
ceil(-0.400000) = -0.000000
ceil(-0.200000) = -0.000000
ceil(0.000000) = 1.000000
ceil(0.200000) = 1.000000
ceil(0.400000) = 1.000000
ceil(0.600000) = 1.000000
ceil(0.800000) = 1.000000
ceil(1.000000) = 2.000000
ceil(1.200000) = 2.000000
ceil(1.400000) = 2.000000
ceil(1.600000) = 2.000000
ceil(1.800000) = 2.000000

\bgroup\color{Red}$\rightarrow$\egroupfloor()


clearerr() 

#include <stdio.h>

void clearerr( FILE *datei );

löscht gegebenenfalls die Indikatoren für Dateifehler und Dateiende für die übergebene Datei.

clearerr() kann auch als Makro definiert sein.

\bgroup\color{Red}$\rightarrow$\egroupfeof(), ferror(), fopen(), freopen(), fclose(), rewind()


clock() 

#include <time.h>

clock_t clock( void );

liefert die Anzahl der ,,Schläge`` der internen Rechneruhr seit Programmbeginn.

Dies ist ein Maß für die Zeit, die das Programm bereits im Rechner läuft.

Die Anzahl der Uhrschläge pro Sekunde ist mit dem Makro CLOCKS_PER_SEC definiert. Zur Umrechnung des Funktionsergebnisses von clock() in Sekunden kann man das Funktionsergebnis deshalb durch CLOCKS_PER_SEC teilen37.

Je nach Rechnersystem kann man nicht sicher sein, daß diese Funktion funktioniert, da die Zeitinformation nicht immer zur Verfügung steht. Dann liefert clock() immer den Wert -1.

Beispiel: 

/* fuclock.c 30. 7.95 kw
 */

#include <time.h>
#include <stdio.h>

int main()
{
  clock_t
    start,
    ende;
  long int  i;
  char      name[30];

  start = clock();

  if( -1==start )
  {
    puts( "Ich kann die Zeit nicht messen!" );
  }
  else
  {
    printf( "Bitte Ihren Namen eingeben: " );
    scanf( "%s", name );
    ende = clock();
    printf( "Sie brauchten %f sec fuer "
            "Ihren Namen, Sie %s!\n",
            (double)(ende-start)/CLOCKS_PER_SEC,
            name
            );
  }

  return 0;
}

\bgroup\color{Red}$\rightarrow$\egrouptime(), difftime()


cos() 

#include <math.h>

double cos( double phi );

liefert den \bgroup\color{Red}$\cos(\tt phi )$\egroup ( phi ist im Bogenmaß anzugeben).

Ist phi betragsmäßig zu groß, dann kann das Ergebnis ungenau sein, ohne daß errno gesetzt wird.

\bgroup\color{Red}$\rightarrow$\egroupacos(), sin(), tan(), cosh()


cosh() 

#include <math.h>

double cosh( double phi );

liefert den \bgroup\color{Red}$\cosh(\tt phi )$\egroup.

Ist phi betragsmäßig zu groß, dann wird der Wert HUGE_VAL zurückgegeben und errno auf ERANGE gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupcos(), sinh(), tanh()


ctime() 

#include <time.h>

char *ctime( const time_t *zeit );

liefert einen Zeiger auf einen 26 Byte langen String (inkl. '\0' ), in dem die Kalenderzeit *zeit als Text beschrieben ist. Der String wird beim nächsten Aufruf von ctime() oder asctime() überschrieben.

ctime( zeit ) ist identisch mit asctime( localtime( zeit ) ) ; siehe dort.

\bgroup\color{Red}$\rightarrow$\egroupasctime(), localtime(), time()


difftime() 

#include <time.h>

double difftime( time_t zeit1, time_t zeit2 );

liefert die Differenz zwischen zwei Kalenderzeiten als double in der Einheit Sekunden. Wenn zeit2 vor zeit1 liegt, dann ist das Ergebnis negativ.

\bgroup\color{Red}$\rightarrow$\egroupclock(), time()


div() 

#include <stdlib.h>

div_t div( int dividend, int divisor );

führt die Division dividend/divisor aus und liefert eine Struktur mit zwei int -Elementen quot und rem . Das Element quot enthält das Ergebnis der ganzzahligen Division; rem enthält den Divisionsrest.

divisor darf nicht 0 sein.

\bgroup\color{Red}$\rightarrow$\egroupldiv(), fmod()


exit() 

#include <stdlib.h>

void exit( int rueckgabe );

beendet das Programm, nachdem alle mit atexit() angemeldeten Funktionen ausgeführt wurden, alle offenen Dateien ordnungsgemäß geschlossen und alle temporären Dateien (siehe tmpfile()) gelöscht wurden.

An die Programmumgebung wird dann der Wert rueckgabe gemeldet. Ein Rückgabewert von 0 signalisiert allgemein, daß das Programm erfolgreich lief; andere Werte zeigen Fehler an. Dafür können auch die Werte EXIT_SUCCESS und EXIT_FAILURE aus stdlib.h verwendet werden.

\bgroup\color{Red}$\rightarrow$\egroupabort(), atexit()


exp() 

#include <math.h>

double exp( double wert );

liefert den Wert der Exponentialfunktion \bgroup\color{Red}$({e}^\tt wert)$\egroup. Wenn wert zu groß ist, dann wird HUGE_VAL geliefert und errno auf ERANGE gesetzt.

\bgroup\color{Red}$\rightarrow$\egrouplog()


fabs() 

#include <math.h>

double fabs( double wert );

liefert den Absolutbetrag von wert zurück.

\bgroup\color{Red}$\rightarrow$\egroupabs(), labs()


fclose() 

#include <stdio.h>

int fclose( FILE *datei );

schließt die übergebene Datei, nachdem die Puffer freigegeben wurden. Wurde die Datei mit tmpfile() erzeugt, dann wird sie gelöscht.

Wenn alles klappt, gibt die Funktion 0 zurück; ansonsten liefert sie EOF und setzt errno , um den Fehler näher zu beschreiben.

Beispiele stehen ab der Seite [*] und auf der Seite [*].

\bgroup\color{Red}$\rightarrow$\egroupfopen(), freopen(), tmpfile(), fflush()


feof() 

#include <stdio.h>

int feof( FILE *datei );

testet den Indikator für das Dateiende der übergebenen Datei. Dieser Indikator kann mit rewind(), fsetpos(), fseek() oder clearerr() zurückgesetzt werden.

feof() liefert 0, wenn der Indikator für das Dateiende nicht gesetzt ist.

feof() kann als Makro definiert sein.

\bgroup\color{Red}$\rightarrow$\egroupclearerr(), rewind(), fseek(), fsetpos()


ferror() 

#include <stdio.h>

int ferror( FILE *datei );

Testet den Fehlerindikator der übergebenen Datei und liefert wahr, wenn selbiger gesetzt ist.

Der Indikator kann mit rewind() oder clearerr() gelöscht werden.

\bgroup\color{Red}$\rightarrow$\egroupclearerr(), feof(), rewind()


fflush() 

#include <stdio.h>

int fflush( FILE *datei );

schreibt eventuell noch im Speicher schwebende Puffer der übergebenen Datei aus. Dies wird bei normalem Programmende ( return in main() oder exit()) oder beim Schließen der Datei oder beim Aufruf von rewind(), fseek() und fsetpos() automatisch ausgeführt.

Rückgabewert ist 0, wenn alles klappt. Ansonsten wird EOF zurückgegeben und errno entsprechend gesetzt.

\bgroup\color{Red}$\rightarrow$\egrouprewind(), fseek(), fsetpos(), fclose(), exit()


fgetc() 

#include <stdio.h>

int fgetc( FILE *datei );

liest das nächste Zeichen aus datei und liefert es zurück, wenn kein Fehler und kein Dateiende auftraten. Ansonsten wird EOF geliefert und errno sowie der entsprechende Indikator der Datei für Fehler oder Dateiende gesetzt.

Dieses Beispiel kopiert den Inhalt der Datei ein.dat zeichenweise in die Datei aus.dat: 

/* fufgetc.c 30. 7.95 kw
 */

#include <stdio.h>

int main()
{
  int     zeichen;
  FILE
    *ein,
    *aus;

  /* Dateien oeffnen
   */
  ein = fopen( "ein.dat", "rb" );
  aus = fopen( "aus.dat", "wb" );

  /* bis Dateiende lesen und ...
   */
  while( (zeichen=fgetc( ein ))!=EOF )
  {
    /* ... schreiben
     */
    fputc( zeichen, aus );
  }

  /* Dateien wieder schliessen
   */
  fclose( ein );
  fclose( aus );
}

\bgroup\color{Red}$\rightarrow$\egroupfeof(), ferror(), clearerr(), fputc(), getc(), getchar()


fgetpos() 

#include <stdio.h>

int fgetpos( FILE *datei, fpos_t *position_zeiger );

speichert die aktuelle Position von datei an der Speicherstelle *position_zeiger . Dieser Wert kann zu einem späteren Zeitpunkt an fsetpos() übergeben werden, um die Datei wieder an dieselbe Stelle zu positionieren.

Zurückgegeben wird 0, wenn alles gut ging. Ansonsten wird ein Wert ungleich 0 geliefert und errno wird gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupfsetpos(), ftell(), fseek()


fgets() 

#include <stdio.h>

char *fgets( char *charfeld, int anzahl, FILE *datei );

versucht, aus datei einen String zu lesen.

Wenn das Dateiende gesetzt ist, bevor das erste Zeichen gelesen werden konnte, wird NULL geliefert und charfeld ist unverändert.

Wenn ein Lesefehler auftritt, wird ebenfalls NULL geliefert, aber charfeld kann verändert worden sein.

Ansonsten liefert fgets() einen Zeiger auf charfeld[0] , also den Wert von charfeld . Die Funktion hat dann Zeichen gelesen, bis entweder ein Zeichen mit dem Wert '\n' (Zeilenvorschubzeichen) oder (anzahl-1) Zeichen eingelesen wurden, oder bis das Dateiende erreicht ist. Die eingelesenen Zeichen werden mit einer '\0' beendet.

charfeld muß auf einen Speicherbereich zeigen, der für (anzahl) Zeichen Platz bietet.

\bgroup\color{Red}$\rightarrow$\egroupfgetc(), fputs(), gets()


floor() 

#include <math.h>

double floor( double wert );

liefert die nächstkleinere oder gleiche ganze Zahl zu wert als double .

Beispiel: 

/* fufloor.c 30. 7.95 kw
 */

#include <math.h>

int main()
{
  double  d;

  for( d=-2.0; d<2.0; d+=0.2 )
    printf( "floor(%f) = %f\n", d, floor(d) );
}

Dieses Programm liefert die Ausgabe: 

floor(-2.000000) = -2.000000
floor(-1.800000) = -2.000000
floor(-1.600000) = -2.000000
floor(-1.400000) = -2.000000
floor(-1.200000) = -2.000000
floor(-1.000000) = -1.000000
floor(-0.800000) = -1.000000
floor(-0.600000) = -1.000000
floor(-0.400000) = -1.000000
floor(-0.200000) = -1.000000
floor(0.000000) = 0.000000
floor(0.200000) = 0.000000
floor(0.400000) = 0.000000
floor(0.600000) = 0.000000
floor(0.800000) = 0.000000
floor(1.000000) = 1.000000
floor(1.200000) = 1.000000
floor(1.400000) = 1.000000
floor(1.600000) = 1.000000
floor(1.800000) = 1.000000

Hier treten beim Hochzählen von d Rundungsfehler auf; dadurch wird beispielsweise der Wert -1.0 nicht genau getroffen, sondern leicht unterschritten.

\bgroup\color{Red}$\rightarrow$\egroupceil()


fmod() 

#include <math.h>

double fmod( double zaehler, double nenner );

liefert den Rest der Gleitkommadivision zaehler / nenner so, daß zaehler gleich dem Wert fmod( zaehler, nenner ) + i*nenner für irgendein i ist. Ist die Division nicht möglich (etwa weil nenner den Wert 0.0 hat), dann ist das Ergebnis undefiniert.

\bgroup\color{Red}$\rightarrow$\egroupceil(), floor(), modf()


fopen() 

#include <stdio.h>

FILE *fopen( const char *dateiname, const char *modus );

öffnet eine Datei (sequentieller oder direkter Zugriff; Textdatei oder Binärdatei, Lesen oder Schreiben oder beides).

modus ist dabei einer der folgenden Strings:

"r"
"rb"
"r+"
"r+b"
"rb+"
"w"
"wb"
"w+"
"w+b"
"wb+"
"a"
"ab"
"a+"
"a+b"
"ab+"

Mit dem Zeichen 'r' in modus öffnet man eine Datei zum Lesen. Mit 'w' analog zum Schreiben; 'a' zum Schreiben ab dem bisherigen Dateiende.

"r+" , "w+" und "a+" öffnen die Datei zum Ändern (Lesen und Schreiben), wobei "a+" die Datei so öffnet, daß sie anfangs auf dem bisherigen Dateiende positioniert ist. Bei "r+" (mit oder ohne b ) muß die Datei bereits existieren, bei "w+" wird sie gegebenenfalls neu angelegt.

Ist in modus kein b enthalten, dann wird eine Textdatei erzeugt. Ist dagegen ein b enthalten, dann wird eine Binärdatei geöffnet.

Mit Textdateien sind dabei Dateien gemeint, die eine Zeilenstruktur aufweisen. In C werden die Zeilen solcher Dateien mit einem line feed-Zeichen, also einem Zeilenvorschub, abgeschlossen.

Text- und Binärdateien unterscheiden sich auf manchen Rechnern darin, daß Binärdateien tatsächlich nur die Zeichen enthalten, die hineingeschrieben wurden und man beim Lesen nur die Zeichen erhält, die wirklich in der Datei stehen. Textdateien enthalten dagegen als Zeilentrenner auf manchen Rechnersystemen die Zeichenfolge '\r' , '\n' ; also Return und Linefeed. Auf anderen Rechnern (insbesondere Unix) ist als Zeilentrenner nur '\n' (Linefeed) üblich. Um jetzt diese Rechnerabhängigkeit vom C-Quelltext fernhalten zu können, öffnet man Textdateien ohne ein b in modus . Als Zeilentrenner (z.B. in fprintf(...)) verwendet man auf jedem System innerhalb des Quelltextes nur das Zeichen '\n' . Dann wird --je nach Rechner-- in den verwendeten Bibliotheksfunktionen jedes geschriebene Zeichen gegebenfalls daraufhin untersucht, ob es ein '\n' ist. Wenn auf dem Rechner nur '\n' als Zeilentrenner üblich ist, dann werden alle Zeichen unverändert weitergegeben und geschrieben. Im anderen Fall werden alle '\n' in die Zeichenfolge '\r' , '\n' verwandelt. Umgekehrt werden beim Lesen aus Textdateien eventuell alle '\r' , '\n' in das eine Zeichen '\n' verwandelt, so daß das eigentliche Programm die Zeichenfolge Return, Linefeed gar nicht sieht.

Binärdateien dagegen sind von dieser Unterscheidung ausgenommen, hier wird unverändert übertragen.

Wird eine Datei nur zum Lesen geöffnet, dann muß sie bereits existieren.

Wird die Datei zum Schreiben oder Ändern geöffnet und existiert noch nicht, dann wird sie (leer) erzeugt.

Wird die Datei zum Schreiben geöffnet und existiert schon, dann wird der alte Inhalt gelöscht.

Im Änderungsmodus geöffnete Dateien dürfen wechselweise beschrieben und gelesen werden. Der Wechsel zwischen Lesen und Schreiben (oder umgekehrt) muß aber unbedingt von einem Aufruf der Funktionen rewind(), fseek(), fsetpos() oder fflush() für die betreffende Datei begleitet sein, da sonst die Pufferung der Datei schief geht.

Wenn die Datei wie gewünscht geöffnet werden konnte, dann gibt fopen() einen Zeiger auf die Dateibeschreibung zurück. Dieser Zeiger darf nicht verändert werden und wird für alle nachfolgenden Operationen mit dieser Datei bis zum fclose() oder dem Programmende benötigt.

Kann die Datei nicht geöffnet werden, dann gibt fopen() den Wert NULL zurück und setzt errno .

Beispiele stehen unter anderem auf der Seite [*] und auf der Seite [*].

\bgroup\color{Red}$\rightarrow$\egroupfclose(), freopen(), fread(),
\bgroup\color{Red}$\rightarrow$\egroupfwrite(), fprintf(), fscanf(),
\bgroup\color{Red}$\rightarrow$\egroupfputc(), fputs(), fgetc(),
\bgroup\color{Red}$\rightarrow$\egroupfgets(), fgetpos(), fsetpos(),
\bgroup\color{Red}$\rightarrow$\egroupftell(), fseek()


fprintf() 

#include <stdio.h>

int fprintf( FILE *datei, const char *format, ... );

schreibt formatierte Ausgabe in die Datei datei .

Abgesehen von dem zusätzlichen Parameter datei , der die zu beschreibende Datei angibt, ist fprintf() identisch mit printf(), siehe also dort.

Zurückgegeben wird die Anzahl der geschriebenen Bytes (nicht eingerechnet sind in diese Anzahl die zusätzlichen Zeichen, die durch eine eventuelle Umwandlung für Textdateien auftreten; siehe dazu die Beschreibung in fopen()).

\bgroup\color{Red}$\rightarrow$\egroupfopen(), printf(), sprintf(),
\bgroup\color{Red}$\rightarrow$\egroupvfprintf()


fputc() 

#include <stdio.h>

int fputc( int zeichen, FILE *datei );

verwandelt zeichen in den Typ char und schreibt das Ergebnis nach datei .

Zurückgegeben wird das geschriebene Zeichen oder EOF , wenn das Schreiben nicht möglich war. Dann werden errno und der Fehlerindikator in der Struktur *datei gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupfopen(), putc(), putchar(),
\bgroup\color{Red}$\rightarrow$\egroupfputs(), fgetc(), getc()


fputs() 

#include <stdio.h>

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

versucht, den String, der ab *string im Speicher steht, nach datei zu schreiben bis die abschließende Null erreicht ist. Diese wird nicht übertragen.

Wenn das Schreiben gelingt, dann wird der Wert 0 zurückgegeben. Beim Auftreten eines Fehlers wird ein Wert ungleich 0 geliefert und der Fehlerindikator in *datei und errno werden gesetzt.

Im Gegensatz zu puts() wird an den auszugebenden String nicht automatisch ein Zeilenvorschub angehängt; dies könnte mit
fprintf( datei, "%s\n", string )
anstatt
fputs( string, datei )
erreicht werden.

\bgroup\color{Red}$\rightarrow$\egroupputs(), fgets(), fputs(),
\bgroup\color{Red}$\rightarrow$\egroupfprintf()


fread() 

#include <stdio.h>

size_t fread( void *wohin,
              size_t elementgroesse,
              size_t elemente,
              FILE *datei            );

versucht aus der Datei datei in den Speicher ab wohin zu lesen, bis entweder maximal (elementgroesse * elemente) Zeichen in den Speicher übertragen wurden oder das Dateiende erreicht ist oder ein Fehler auftritt. Eine eventuelle Anpassung der Daten für Textdateien (siehe fopen()) wird dabei durchgeführt.

Zurückgegeben wird die Anzahl der eingelesenen Elemente. Das ist maximal der Wert von elemente , wenn alles gut ging, sonst weniger. Dann wird der Indikator für Dateiende von datei oder der Fehlerindikator gesetzt; in letzterem Fall auch errno .

\bgroup\color{Red}$\rightarrow$\egroupfopen(), fwrite(), feof(),
\bgroup\color{Red}$\rightarrow$\egroupferror()


free() 

#include <stdlib.h>

void free( void *p )

gibt den Speicher ab p frei, der zuvor mit malloc() oder calloc() allokiert worden sein muß.

Ein Beispiel steht auf Seite [*].

\bgroup\color{Red}$\rightarrow$\egroupmalloc(), calloc(), realloc()


freopen() 

#include <stdio.h>

FILE *freopen( const char *dateiname,
               const char *modus,
               FILE *datei            );

verknüpft eine Datei dateiname mit einer schon offenen Datei oder einem Gerät datei .

datei wird dazu eventuell geschlossen und als dateiname neu geöffnet.

Zu modus siehe fopen().

Diese Funktion wird manchmal dazu verwendet, einen der vordefinierten Gerätekanäle stdin , stdout , stderr auf eine Datei umzubiegen.

Rückgabe ist der übergebene Zeiger datei , wenn die Umlenkung klappte, oder sonst der Wert NULL .

Zum Beispiel kann man mit
freopen( dateiname, "w", stdout )
alle nachfolgenden Ausgaben des Programms, die über stdout gehen, in eine Datei umbiegen: 

/* fufreopn.c 30. 7.95 kw
 */

#include <stdio.h>

main()
{
  freopen( "test.dat", "w", stdout );
  printf( "dieser Text landet in der Datei test.dat!\n" );
}
Je nach Rechnersystem kann man diese Verknüpfung wieder aufheben, wenn man die Standardausgabe unter ihrem Gerätenamen wieder öffnet. Die folgende Sequenz leitet unter DOS die Ausgabe in eine Datei um und dann wieder zurück auf den Bildschirm: 

         freopen( "test.dat", "w", stdout );
         printf( "dieser Text landet in der Datei test.dat!\n" );
         freopen( "CON", "w", stdout );
         printf( "und das wieder auf dem Bildschirm!\n" );

\bgroup\color{Red}$\rightarrow$\egroupfopen(), fclose()


frexp() 

#include <math.h>

double frexp( double wert, int *exp_zeiger );

zerlegt den Parameter wert in eine normalisierte Mantisse im Bereich 0.5...1.0 und einen Binärexponenten. Die Mantisse wird zurückgegeben. Der Exponent wird an die Stelle im Speicher geschrieben, auf die exp_zeiger zeigt.

Die Zerlegung geschieht so, daß die Mantisse multipliziert mit \bgroup\color{Red}${2}^\tt *exp\_zeiger $\egroup den übergebenen Parameter wert ergibt.

Wenn wert gleich 0.0 ist, dann sind beide Teile der Zerlegung 0.

Beispiel: 

/* fufrexp.c 30. 7.95 kw
 */

#include <math.h>

main()
{
  int    expo;
  double frac;

  frac = frexp( 12.3456, &expo );
  printf( "frac = %20.10f; expo = %d\n", frac, expo );
  printf( "frac*(2^expo) = %20.10f\n", frac*pow(2.0,expo) );
}

erzeugt die Ausgabe 

frac =         0.7716000000; expo = 4
frac*(2^expo) =        12.3456000000

\bgroup\color{Red}$\rightarrow$\egroupldexp(), modf()


fscanf() 

#include <stdio.h>

int fscanf( FILE *datei, const char *format, ... );

liest aus einer Datei formatierte Eingabe und wandelt sie nach den Anweisungen in format um.

Die weiteren Parameter richten sich nach den Direktiven in format und sind Zeiger auf Speicherplätze, an welche die umgewandelten Werte geschrieben werden können.

Bis auf den zusätzlichen Parameter datei , der angibt, aus welcher Datei gelesen werden soll, ist fscanf() identisch mit scanf(), siehe also dort.

Zurückgegeben wird die Anzahl der gelesenen und umgewandelten Werte oder EOF , wenn das Dateiende vor der ersten Übertragung erreicht wurde.

\bgroup\color{Red}$\rightarrow$\egroupscanf(), sscanf(), fprintf()


fseek() 

#include <stdio.h>

int fseek( FILE *datei, long int wieweit, int abwo );

positioniert die Datei datei an eine neue Position.

Je nach dem Wert von abwo zählt die Positionsangabe wieweit

  • ab dem Dateianfang, wenn abwo gleich SEEK_SET ist,
  • ab der aktuellen Position, wenn abwo gleich SEEK_CUR ist, oder
  • ab dem Dateiende, wenn abwo gleich SEEK_END ist.

SEEK_SET , SEEK_CUR und SEEK_END sind in stdio.h definiert.

Bei der Positionierung wird der Indikator für Dateiende gelöscht und die Wirkung eines eventuellen vorherigen Aufrufs der Funktion ungetc() wird aufgehoben. Durch den Aufruf von fseek() darf bei Dateien im Änderungsmodus zwischen Lese- und Schreibzugriff gewechselt werden oder umgekehrt.

Achtung! Bei Dateien im Textmodus ist fseek() nur sinnvoll, wenn entweder

  • wieweit von einem vorherigen Aufruf von ftell() stammt und abwo den Wert SEEK_SET hat, oder
  • wieweit den Wert 0 hat.

Bei allen anderen Kombinationen können in Textmodus Fehler auftreten, weil die Positionen, die das Programm sieht, nicht identisch mit physikalischen Positionen in der Datei sein müssen (siehe fopen()).

Im erfolgreichen Fall gibt fseek() den Wert 0 zurück. Ansonsten wird ein Wert ungleich 0 geliefert und errno gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupftell(), fopen(), fgetpos(),
\bgroup\color{Red}$\rightarrow$\egroupfsetpos()


fsetpos() 

#include <stdio.h>

int fsetpos( FILE *datei, fpos_t *position );

setzt die Datei datei auf die Position *position , die von einem vorherigen Aufruf von fgetpos() stammen muß.

Der Dateiende-Indikator der Datei wird gelöscht; ein eventueller vorheriger Aufruf der Funktion ungetc() wird unwirksam. Weiterhin erlaubt fsetpos() bei Dateien im Änderungsmodus den Wechsel zwischen Ein- und Ausgabe.

Geht alles gut, dann liefert fsetpos() den Wert 0; Ansonsten einen anderen Wert, weil die Position ungültig war. Dann wird errno auf den Wert EINVAL gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupfgetpos(), fseek(), ftell()


ftell() 

#include <stdio.h>

long int ftell( FILE *datei );

liefert die momentane Position der Datei datei zurück.

Dieser Wert kann für spätere Aufrufe von fseek( datei, ..., SEEK_SET ) verwendet werden (sowohl für Text- als auch Binärdateien).

Für Binärdateien ist der Rückgabewert die Dateiposition.

Im Fehlerfall wird -1L zurückgegeben und errno wird gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupfseek(), fopen(), fgetpos(),
\bgroup\color{Red}$\rightarrow$\egroupfsetpos()


fwrite() 

#include <stdio.h>

size_t fwrite( const void *woher,
               size_t elementgroesse,
               size_t elemente,
               FILE *datei            );

schreibt ab der Speicherstelle woher maximal ( elementgroesse * elemente) Bytes in die Datei datei .

Bei Dateien im Textmodus wird die übliche Konvertierung (siehe fopen()) durchgeführt.

Zurückgegeben wird die Anzahl der tatsächlich geschriebenen Elemente. Im Fehlerfall ist dies weniger als der Wert von elemente ; dann werden der Fehlerindikator der Datei und errno gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupfopen(), fread(), fprintf(),
\bgroup\color{Red}$\rightarrow$\egroupfputs()


getc() 

#include <stdio.h>

int getc( FILE *datei );

liest aus datei das nächste Zeichen.

Geliefert wird das gelesene Zeichen oder EOF , wenn das Dateiende erreicht wurde, oder wenn ein Fehler auftrat. In diesen beiden Fällen wird der Indikator für Dateifehler bzw. für Dateiende in datei gesetzt.

Achtung! Je nach System kann getc() als Makro definiert sein. Sicherer ist die Verwendung der gleichwertigen Funktion fgetc().

\bgroup\color{Red}$\rightarrow$\egroupfgetc(), fopen(), getchar(),
\bgroup\color{Red}$\rightarrow$\egroupungetc()


getchar() 

#include <stdio.h>

int getchar( void );

liest ein Zeichen von der Standardeingabe stdin und ist identisch mit getc( stdin ) . Siehe dort.

\bgroup\color{Red}$\rightarrow$\egroupfgetc(), getc(), ungetc()


getenv() 

#include <stdlib.h>

char *getenv( const char *name );

sucht im sogenannten environment (siehe auch Environmentvariablen) des Programms nach einer Variable mit der Bezeichnung *name . Wird eine solche gefunden, dann liefert getenv() einen Zeiger auf ihren Wert; ansonsten NULL .

Der Variablenname ab ( *name ) sollte in Großbuchstaben angegeben werden.

\bgroup\color{Red}$\rightarrow$\egroupsystem()


gets() 

#include <stdio.h>

char *gets( char *s );

liest einen String von der Standardeingabe in den Speicher ab der Stelle, auf die s zeigt, bis das Dateiende von stdin auftritt, oder ein Fehler, oder ein Zeilenvorschub gelesen wird. Der Zeilenvorschub wird nicht mitgespeichert. Anschließend wird ein Zeichen mit dem Wert \0 angehängt.

Zurückgegeben wird der Zeiger s , wenn das Lesen klappte.

Ist das Dateiende schon vor dem Lesen erreicht oder tritt ein Dateifehler auf, dann wird Null zurückgegeben und bei einem Fehler errno gesetzt.

Achtung! Im Gegensatz zu fgets() wird keine Feldüberschreitung geprüft!

\bgroup\color{Red}$\rightarrow$\egroupputs(), fgets(), getchar(),
\bgroup\color{Red}$\rightarrow$\egroupfgetc()


gmtime() 

#include <time.h>

struct tm *gmtime( const time_t *zeit_zeiger );

verwandelt die Kalenderzeit in *zeit_zeiger in eine Struktur als Greenwich mean time (GMT). Die gegebene Zeit sollte als Ortszeit vorliegen (etwa aus time()). Dazu wird die Zeitdifferenz zwischen GMT und der Ortszeit aus der environment-Variablen TZ bestimmt. Dieser String sollte aus drei Buchstaben bestehen, welche die Standardzeitzone beschreiben, weiterhin aus einer vorzeichenbehafteten ganzen Zahl, die den Abstand angibt, um den die Ortszeit der GMT vorausgeht. Falls Sommerzeit ist, sollten anschließend drei Buchstaben folgen, die den Namen der Sommerzeitzone angeben.

Zurückgegeben wird ein Zeiger auf eine statische Struktur, in der die errechnete Zeit abgelegt wird. Diese Struktur wird bei jedem Aufruf von
gmtime(), asctime(), ctime() und localtime()
überschrieben.

Wenn die environment-Variable TZ nicht existiert, dann wird NULL zurückgegeben.

\bgroup\color{Red}$\rightarrow$\egroupasctime(), ctime(), localtime(),
\bgroup\color{Red}$\rightarrow$\egrouptime(), mktime()


isalnum() 

#include <ctype.h>

int isalnum( int c );

liefert ungleich 0, wenn c ein alphanumerisches Zeichen ist ( 0 - 9 , a - z , A - Z ).

Deutsche Umlaute werden nicht als Buchstaben behandelt, sondern als Sonderzeichen.

\bgroup\color{Red}$\rightarrow$\egroupisalpha(), iscntrl(), isdigit(),
\bgroup\color{Red}$\rightarrow$\egroupisgraph(), islower(), isprint(),
\bgroup\color{Red}$\rightarrow$\egroupispunct(), isspace(), isupper(),
\bgroup\color{Red}$\rightarrow$\egroupisxdigit()


isalpha() 

#include <ctype.h>

int isalpha( int c );

liefert ungleich 0, wenn c ein Buchstabe ist ( a - z , A - Z ).

Deutsche Umlaute werden nicht als Buchstaben behandelt, sondern als Sonderzeichen.

\bgroup\color{Red}$\rightarrow$\egroupisalnum(), iscntrl(), isdigit(),
\bgroup\color{Red}$\rightarrow$\egroupisgraph(), islower(), isprint(),
\bgroup\color{Red}$\rightarrow$\egroupispunct(), isspace(), isupper(),
\bgroup\color{Red}$\rightarrow$\egroupisxdigit()


iscntrl() 

#include <ctype.h>

int iscntrl( int c );

liefert ungleich 0, wenn c ein Steuerzeichen ist (Im ASCII-Zeichensatz sind das die Zeichen 0 bis 31 dezimal).

\bgroup\color{Red}$\rightarrow$\egroupisalnum, isalpha, isdigit,
\bgroup\color{Red}$\rightarrow$\egroupisgraph, islower, isprint, ispunct,
\bgroup\color{Red}$\rightarrow$\egroupisspace, isupper, isxdigit


isdigit() 

#include <ctype.h>

int isdigit( int c );

liefert ungleich 0, wenn c eine dezimale Ziffer ist ( 0 - 9 ).

\bgroup\color{Red}$\rightarrow$\egroupisalnum(), isalpha(), iscntrl(),
\bgroup\color{Red}$\rightarrow$\egroupisgraph(), islower(), isprint(),
\bgroup\color{Red}$\rightarrow$\egroupispunct(), isspace(), isupper(),
\bgroup\color{Red}$\rightarrow$\egroupisxdigit()


isgraph() 

#include <ctype.h>

int isgraph( int c );

liefert ungleich 0, wenn c ein graphisches (nicht druckbares) Zeichen ist.

\bgroup\color{Red}$\rightarrow$\egroupisalnum(), isalpha(), iscntrl(),
\bgroup\color{Red}$\rightarrow$\egroupisdigit(), islower(), isprint(),
\bgroup\color{Red}$\rightarrow$\egroupispunct(), isspace(), isupper(),
\bgroup\color{Red}$\rightarrow$\egroupisxdigit()


islower() 

#include <ctype.h>

int islower( int c );

liefert ungleich 0, wenn c ein Kleinbuchstabe ist ( a - z ).

Deutsche Umlaute werden nicht als Buchstaben behandelt, sondern als Sonderzeichen.

\bgroup\color{Red}$\rightarrow$\egroupisalnum(), isalpha(), iscntrl(),
\bgroup\color{Red}$\rightarrow$\egroupisdigit(), isgraph(), isprint(),
\bgroup\color{Red}$\rightarrow$\egroupispunct(), isspace(), isupper(),
\bgroup\color{Red}$\rightarrow$\egroupisxdigit()


isprint() 

#include <ctype.h>

int isprint( int c );

liefert ungleich 0, wenn c ein druckbares Zeichen oder ein Leerzeichen ist.

\bgroup\color{Red}$\rightarrow$\egroupisalnum(), isalpha(), iscntrl(),
\bgroup\color{Red}$\rightarrow$\egroupisdigit(), isgraph(), islower(),
\bgroup\color{Red}$\rightarrow$\egroupispunct(), isspace(), isupper(),
\bgroup\color{Red}$\rightarrow$\egroupisxdigit()


ispunct() 

#include <ctype.h>

int ispunct( int c );

liefert ungleich 0, wenn c ein Interpunktionszeichen ist; dazu zählen alle druckbaren Zeichen (außer dem Leerzeichen), die nicht alphanumerisch sind (also auch deutsche Umlaute).

\bgroup\color{Red}$\rightarrow$\egroupisalnum(), isalpha(), iscntrl(),
\bgroup\color{Red}$\rightarrow$\egroupisdigit(), isgraph(), islower(),
\bgroup\color{Red}$\rightarrow$\egroupisprint(), isspace(), isupper(),
\bgroup\color{Red}$\rightarrow$\egroupisxdigit()


isspace() 

#include <ctype.h>

int isspace( int c );

liefert ungleich 0, wenn c ein sogenanntes white-space-Zeichen ist (also \t , (Leerzeichen), \f , \n , \r , \v );

\bgroup\color{Red}$\rightarrow$\egroupisalnum(), isalpha(), iscntrl(),
\bgroup\color{Red}$\rightarrow$\egroupisdigit(), isgraph(), islower(),
\bgroup\color{Red}$\rightarrow$\egroupisprint(), ispunct(), isupper(),
\bgroup\color{Red}$\rightarrow$\egroupisxdigit()


isupper() 

#include <ctype.h>

int isupper( int c );

liefert ungleich 0, wenn c ein Großbuchstabe ist ( A - Z ).

Deutsche Umlaute werden nicht als Buchstaben behandelt, sondern als Sonderzeichen.

\bgroup\color{Red}$\rightarrow$\egroupisalnum(), isalpha(), iscntrl(),
\bgroup\color{Red}$\rightarrow$\egroupisdigit(), isgraph(), islower(),
\bgroup\color{Red}$\rightarrow$\egroupisprint(), ispunct(), isspace(),
\bgroup\color{Red}$\rightarrow$\egroupisxdigit()


isxdigit() 

#include <ctype.h>

int isxdigit( int c );

liefert ungleich 0, wenn c eine hexadezimale Ziffer ist (also 0 - 9 , a - f , A - F ).

\bgroup\color{Red}$\rightarrow$\egroupisalnum(), isalpha(), iscntrl(),
\bgroup\color{Red}$\rightarrow$\egroupisdigit(), isgraph(), islower(),
\bgroup\color{Red}$\rightarrow$\egroupisprint(), ispunct(), isspace(),
\bgroup\color{Red}$\rightarrow$\egroupisupper()


labs() 

#include <stdlib.h>

long int labs( long int wert );

gibt den Absolutbetrag von wert zurück.

\bgroup\color{Red}$\rightarrow$\egroupabs(), fabs()


ldexp() 

#include <math.h>

double ldexp( double wert, int expo );

multipliziert wert mit der Zweierpotenz \bgroup\color{Red}${2}^{\tt expo}$\egroup. Das Ergebnis wird zurückgegeben.

Wenn das Ergebnis so groß ist, daß es nicht als double dargestellt werden kann, dann wird HUGE_VAL geliefert und errno auf den Wert ERANGE gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupfrexp()


ldiv() 

#include <stdlib.h>

ldiv_t ldiv( long int dividend, long int divisor );

führt die Division dividend / divisor aus und liefert eine Struktur mit den zwei long int -Elementen quot und rem . Das Element quot enthält das Ergebnis der ganzzahligen Division; rem enthält den Divisionsrest.

divisor darf nicht 0 sein.

\bgroup\color{Red}$\rightarrow$\egroupdiv(), fmod()


localtime() 

#include <time.h>

struct tm *localtime( const time_t *zeit_zeiger );

verwandelt die gepackte (lokale) Kalenderzeit *zeit_zeiger in die aufgebrochene Form struct tm und liefert einen Zeiger auf diese statische Struktur. Diese Struktur wird bei jedem Aufruf von
gmtime(), asctime(), ctime() und localtime()
überschrieben.

Die Kalenderzeit kann man mit time() erhalten.

Ein Beispiel dazu steht auf der Seite [*].

\bgroup\color{Red}$\rightarrow$\egroupgmtime(), ctime(), asctime(), \bgroup\color{Red}$\rightarrow$\egroupmktime(), time()


log() 

#include <math.h>

double log( double argument );

berechnet den natürlichen Logarithmus \bgroup\color{Red}$\ln(\tt argument)$\egroup (also zur Basis \bgroup\color{Red}$e$\egroup).

Wenn argument==0.0 ist, dann tritt ein Resultatfehler auf, das heißt errno wird zu ERANGE gesetzt und - HUGE_VAL wird zurückgegeben.

Wenn argument kleiner als 0.0 ist, dann wird ein Argumentfehler auftreten und errno den Wert EDOM erhalten. Der Funktionswert ist dann 0.0.

\bgroup\color{Red}$\rightarrow$\egrouplog10()


log10() 

#include <math.h>

double log10( double argument );

berechnet den dekadischen Logarithmus \bgroup\color{Red}$\log(\tt argument)$\egroup (also zur Basis 10).

Wenn argument==0.0 ist, dann tritt ein Resultatfehler auf, das heißt errno wird zu ERANGE gesetzt und - HUGE_VAL wird zurückgegeben.

Wenn argument kleiner als 0.0 ist, dann wird ein Argumentfehler auftreten und errno den Wert EDOM erhalten. Der Funktionswert ist dann 0.0.

\bgroup\color{Red}$\rightarrow$\egrouplog()


longjmp() 

#include <setjmp.h>

void longjmp( jmp_buf umgebung, int return_wert );

springt zu dem Funktionsaufruf zurück, der in der Struktur umgebung von einem vorhergehenden Aufruf von setjmp() gespeichert ist.

Die Programmausführung wird nicht mit der Anweisung nach longjmp() weitergesetzt, sondern mit der Anweisung nach dem zu umgebung gehörenden setjmp()-Aufruf!

Aus dem genannten setjmp()-Aufruf heraus wird das Programm mit dem Rückgabewert return_wert fortgesetzt. Deshalb sollte return_wert nicht den Wert 0 haben, da sonst der Aufrufer nicht den Rücksprung von longjmp() erkennen kann. Wenn return_wert trotzdem auf 0 gesetzt ist, wird automatisch mit 1 aus dem setjmp()-Aufruf zurückgesprungen.

Achtung! Der zu einem Aufruf von longjmp() gehörige setjmp()-Aufruf muß:

1)
zeitlich (bezüglich des Programmlaufs) vor longjmp() erfolgen, und
2)
eine der beiden folgenden Bedingungen erfüllen:
a)
in derselben Funktion stehen wie longjmp() (dann wäre ein goto aber zweckmäßiger), oder
b)
in der Aufrufhierarchie in direkter Linie oberhalb von longjmp() stehen.
Es ist also nicht möglich, in einer Funktion setjmp() aufzurufen, die Funktion zu verlassen und dann mit longjmp() wieder dorthin zurückzukehren! Dies liegt daran, daß mit dem Rücksprung aus der Funktion auch der sogenannte Stack ungültig wird, auf dem alle Funktionsparameter und lokalen Variablen abgelegt werden (vergleiche Speichermodell eines Prozesses). Wird eine Funktion verlassen und kehrt man danach mit longjmp() wieder dorthin zurück, dann hat die Funktionen einerseits ihre (automatischen) Variablen und Parameter verloren, und hat andererseits keine berechtigte Chance, zu ihrem Aufrufer zurückkehren zu können.

Nochmal Achtung! Automatische Variablen (also lokale Variablen, die nicht als static vereinbart sind) werden bei einem longjmp()-Sprung nicht unbedingt restauriert (je nach System)! Will man solche Variablen restauriert haben, muß man sie als volatile (siehe Seite [*]) deklarieren.

Beispiel: 

/* fulongjm.c 30. 7.95 kw
 */

#include <setjmp.h>
#include <ctype.h>
#include <stdio.h>

jmp_buf umgebung;

void f( void )
{
  puts( "Hier ist f()." );
  puts( "Wollen Sie f() mit longjmp() verlassen?" );
  if( toupper(getchar())=='J' )
  {
    longjmp( umgebung, 1 );
  }

  puts( "Na gut, dann nicht!" );
  return;
}

int main()
{
  int     wert;

  wert = setjmp( umgebung );

  /* Nach dem Aufruf von setjmp() hat wert den Inhalt 0.
   * Nach dem Ruecksprung durch longjmp() ist wert
   * dagegen ungleich 0.
   */
  if( wert==0 )
  {
    puts( "hier ist main(), gleich kommt f()!" );
    f();
    puts( "hier ist main(); "
          "f() wurde mit return verlassen!" );
  }
  else
  {
    puts( "hier ist main() nach longjmp()!" );
  }
  return 0;
}

\bgroup\color{Red}$\rightarrow$\egroupsetjmp()


malloc() 

#include <stdlib.h>

void *malloc( size_t wieviel );

versucht, einen Speicherblock mit wieviel Bytes zu reservieren.

Rückgabewert ist ein Zeiger auf den Anfang des reservierten Blocks, wenn alles gut ging, oder der NULL -Zeiger, wenn kein Block ausreichender Größe zu haben ist.

Der zugewiesene Speicher wird nicht gelöscht, sondern hat einen zufälligen Inhalt38.

Ein Beispiel steht auf Seite [*].

\bgroup\color{Red}$\rightarrow$\egroupfree(), calloc(), realloc()


memchr() 

#include <string.h>

void *memchr( const void *abwo, int zeichen, size_t wieviel );

durchsucht ab der Speicherstelle abwo maximal wieviel Zeichen nach zeichen und liefert einen Zeiger auf das erste Vorkommen oder NULL , wenn zeichen in dem Bereich nicht gefunden wird.

\bgroup\color{Red}$\rightarrow$\egroupstrchr()


memcmp() 

#include <string.h>

int memcmp( const void *zeiger1, const void *zeiger2, size_t wieviele );

vergleicht den Speicher ab der Speicherstelle zeiger1 mit dem Speicher ab zeiger2 .

Nach maximal wieviele Bytes wird der Vergleich abgebrochen. Wenn bis dahin kein Unterschied festgestellt wurde, wird der Wert 0 zurückgegeben. Ansonsten liefert der Aufruf von memcmp() einen Wert größer, gleich oder kleiner als 0, je nachdem ob das erste unterschiedliche Zeichen im Bereich ab zeiger1 größer, gleich oder kleiner als das entsprechende Zeichen im Bereich ab zeiger2 ist.

\bgroup\color{Red}$\rightarrow$\egroupstrcmp(), strncmp()


memcpy() 

#include <string.h>

void *memcpy( void *wohin, void *woher, size_t wieviele );

kopiert wieviele Bytes ab der Speicherstelle woher in den Bereich ab wohin . Die Bereiche sollten sich nicht überschneiden (für diesen Fall gibt es memmove()).

memcpy() liefert den Zeiger wohin zurück.

\bgroup\color{Red}$\rightarrow$\egroupmemmove(), strcpy(), strncpy()


memmove() 

#include <string.h>

void *memmove( void *wohin, void *woher, size_t wieviele );

kopiert einen Speicherbereich an eine andere Stelle im Speicher.

Dabei darf sich der Zielbereich ( wohin bis (wohin + wieviele) ) mit dem Quellbereich ( woher bis (woher + wieviele) ) überlappen.

Ist sichergestellt, daß sich die Bereiche nicht überlappen, dann ist die Funktion memcpy() gleichwertig, aber schneller.

Zurückgegeben wird ein Zeiger auf den Zielbereich, also wohin .

\bgroup\color{Red}$\rightarrow$\egroupmemcpy(), strcpy(), strncpy()


memset() 

#include <string.h>

void *memset( void *abwo, int womit, size_t wieviele );

füllt ab der Stelle abwo im Arbeitsspeicher wieviele aufeinanderfolgende Bytes mit dem Zeichen (unsigned char)womit.

Zurückgegeben wird ein Zeiger auf das gefüllte Objekt, also abwo .

\bgroup\color{Red}$\rightarrow$\egroupcalloc()


mktime() 

#include <time.h>

time_t mktime( struct tm *zeitzeiger );

konvertiert die Ortszeit aus der Struktur *zeitzeiger in das komprimierte Format der Funktion time().

Dies ist die Umkehrung von localtime().

\bgroup\color{Red}$\rightarrow$\egrouplocaltime(), time(), gmtime()


modf() 

#include <math.h>

double modf( double wert, double *ganzzahliger_teil );

zerlegt wert in einen ganzzahligen Anteil und einen gebrochenen Teil, der zurückgegeben wird. Der ganzzahlige Teil wird bei ganzzahliger_teil hinterlegt. Beide Teile haben das gleiche Vorzeichen wie wert .

\bgroup\color{Red}$\rightarrow$\egroupfloor(), ceil(), fmod(), frexp()


perror() 

#include <stdio.h>

void perror( const char *text );

Wenn text ungleich NULL ist, dann wird der String ab text nach stderr geschrieben.

Anschließend wird eine Fehlermeldung ausgegeben, die dem aktuellen Wert von errno entspricht. Anschließend wird ein Zeilenvorschub ausgegeben.

\bgroup\color{Red}$\rightarrow$\egroupstrerror()


pow() 

#include <math.h>

double pow( double basis, double exponent );

gibt die Potenz \bgroup\color{Red}$(\tt basis)^\tt exponent$\egroup zurück, wenn möglich.

Ist das Ergebnis zu groß, um als double dargestellt zu werden, dann wird +HUGE_VAL oder -HUGE_VAL geliefert und errno auf ERANGE gesetzt.

Wenn:

  • basis negativ ist und exponent nicht ganzzahlig oder
  • basis ist 0.0 und exponent ist kleiner oder gleich 0.0,
(Argumentfehler), dann wird 0.0 zurückgegeben und errno auf EDOM gesetzt.

Wenn man nicht unbedingt gebrochene Exponenten braucht, dann kann man Potenzen eventuell schneller berechnen. Siehe dazu Abschnitt Potenzen mit ganzzahligen Exponenten.

\bgroup\color{Red}$\rightarrow$\egrouplog(), log10(), frexp()


printf() 

#include <stdio.h>

int printf( char *format, ... )

gibt den String format aus. Sind darin Prozentzeichenfolgen %d , %f , %s , und so weiter enthalten, dann werden an deren Stelle weitere Werte ausgegeben, die in der gleichen Reihenfolge hinter dem Parameter format folgen müssen, wie die zugehörigen Prozentzeichenfolgen in format .

Der String, auf den der Parameter format zeigt, wird auf die Standardausgabe stdout ausgegeben. Dabei dürfen die üblichen Steuerzeichen wie \t als Tabulator, \n als Zeilenvorschub und \a als Piepston eingestreut sein.

Ein Prozentzeichen % im Formatstring leitet eine Veränderung der Ausgabe ein.

Nach dem Prozentzeichen folgt eine der Direktiven % , d , i , o , u , x , X , e , E , f , g , G , c , s , p , n .

Die meisten der Prozentzeichenfolgen (außer %% ) ,,verbrauchen`` jeweils ein weiteres Argument aus der Argumentliste hinter dem Parameter format . Wenn für die Feldbreite und/oder die Genauigkeit (siehe unten) nur ein * angegeben ist, dann wird dafür jeweils ein weiteres Argument vom Typ signed int verbraucht. Dieses zusätzliche Argument muß man noch vor dem auszugebenden Wert in die Parameterliste schreiben.

Achtung! Die Direktiven im Formatstring und die restlichen Argumente der Funktion müssen in Typ und Reihenfolge sauber zusammenpassen, sonst produziert die Funktion nur Unsinn!

Erläuterung der Direktiven:

%%
Mit Hilfe der Formatangabe %% wird ein Prozentzeichen ausgegeben. Es wird kein Argument verbraucht.

%d , %i
geben aus der Argumentliste hinter format eine Zahl vom Typ int dezimal aus.

Wenn eine Genauigkeit angegeben wird, bedeutet diese die mindestens auszugebende Anzahl von Zeichen. Notfalls werden führende Nullen mit ausgegeben. Reicht die Genauigkeit nicht aus, dann werden mehr Zeichen ausgegeben.

Ist keine Genauigkeit angegeben, dann wird der Wert 1 dafür eingesetzt.

%u
ist wie %d , aber die auszugebende Zahl wird als unsigned int behandelt.

%o
gibt ebenfalls eine unsigned int aus, aber in oktaler Schreibweise. Mit dem Steuerzeichen # wird immer eine führende Null ausgegeben.

%x , %X
geben eine unsigned int als sedezimale Zahl (also zur Basis 16) aus. Bei %x werden als Ziffern 0 - 9 und a - f verwendet; bei %X stattdessen 0 - 9 und A - F . Mit dem Steuerzeichen # wird vor die Ausgabe der Text 0x bzw. 0X gestellt.

%e , %E
geben eine doppelt genaue gebrochene Zahl ( double ) aus, wie etwa 1.234567e-12 oder -1.234567e+20 . Bei %E wird das Zeichen E für den Zehnerexponenten ausgegeben. Die Genauigkeit gibt die Anzahl der gewünschten Nachkommastellen an.

Wenn keine Genauigkeit angegeben ist, wird 6 angenommen. Ist die Genauigkeit 0 , dann wird der Dezimalpunkt nur ausgegeben, wenn als Steuerzeichen # angegeben wurde.

Es wird immer eine Ziffer vor dem Dezimalpunkt ausgegeben. Diese ist nur dann 0 , wenn die auszugebende Zahl den Wert 0.0 hat.

%f
gibt ebenfalls eine Gleitkommazahl aus ( double ), aber ohne Exponentialdarstellung. Fehlt die Genauigkeitsangabe, dann wird 6 angenommen.

%g , %G
geben eine Gleitkommazahl ( double ) aus, und zwar in der Form von %f , wenn die Zahl in der aktuellen Feldbreite und Genauigkeit ausgegeben werden kann; ansonsten in der Form von %e (wenn %g angegeben) bzw. %E (wenn %G angegeben). Eine Genauigkeit von 0 wird wie 1 behandelt. Nachkommastellen werden von rechts her entfernt, soweit sie 0 sind. Dies kann mit dem Steuerzeichen # verhindert werden; damit werden auch abschließende Nullen geschrieben.

%c
gibt ein Argument vom Typ int als Zeichen aus.

%s
verbraucht ein Argument vom Typ char * , also ein Zeiger auf char . Ab der Stelle, auf die das verbrauchte Argument zeigt, werden Zeichen ausgegeben, bis ein Zeichen den Wert 0 hat, oder die eventuell angegebene Genauigkeit erreicht ist. Die abschließende 0 des Strings wird nicht mit ausgegeben.

%p
verbraucht einen Zeiger ( void * ) und gibt seinen Wert hexadezimal aus. Wenn das Steuerzeichen # angegeben ist, dann wird vor die Ausgabe der Text 0x gestellt.

%n
verbraucht einen Zeiger auf eine ganze Zahl ( int * ) und erzeugt keine Ausgabe. Vielmehr wird die Anzahl der bisher ausgegebenen Zeichen ermittelt und dahin geschrieben, wo der verbrauchte Zeiger hinzeigt. Normalerweise wird an diese Stelle eine int geschrieben; mit der Längenangabe h oder l kann man das Schreiben von short int oder long int erzwingen.

Zwischen dem einleitenden Prozentzeichen und der Direktive darf eine Auswahl der Steuerzeichen + , (ein Leerzeichen), 0 , - , # , Feldbreite , .Genauigkeit , sowie als Hinweis auf die Objektgröße der Buchstabe h oder l oder L stehen.

Gegebenenfalls mehrere dieser Steuerzeichen können in folgender Reihenfolge angegeben werden:

+
bewirkt, daß bei der Ausgabe von Zahlen ein positives Vorzeichen ausgegeben wird. Standardmäßig würde nur ein negatives Vorzeichen ausgegeben werden.

(Leerz.)
bewirkt, daß positive Zahlen statt mit einem Vorzeichen mit einem Leerzeichen beginnen. Wenn + und angegeben werden, dann gewinnt das + .

0
bewirkt, daß die Ausgabe nicht mit Leerzeichen, sondern mit Nullen auf die angegebene Feldbreite aufgefüllt wird.

-
bewirkt eine linksbündige Ausgabe innerhalb der Feldbreite. Standard ist rechtsbündig.

#
bewirkt eine alternative Form der Ausgabe; die Wirkung ist abhängig von der Direktive.

Feldbreite
gibt als Dezimalzahl die Anzahl der mindestens auszugebenden Zeichen an. Wird statt einer Zahl ein * angegeben, dann wird noch vor dem auszugebenden Argument ein Wert vom Typ signed int verbraucht, der für die Feldbreite verwendet wird.

. Genauigkeit
kann ebenfalls durch einen * mit einem Argument aus der Parameterliste ersetzt werden. Für auszugebende Zeichenketten (Format %s) kann man hiermit die maximale Anzahl der zu schreibenden Zeichen an.

Objektgröße
gibt die (Speicher-) Größe des auszugebenden Objekts an, und zwar entweder
h
bewirkt, daß statt einer int eine short int verbraucht wird; oder

l
statt einer int eine long int oder
L
statt einer double eine long double .

Leider gibt es keine Direktive, um einen Wert vom Typ size_t auszugeben. Dazu muß man mit einem cast den auszugebenden Wert in den Typ unsigned long verwandeln und dann mit der Direktive %lu ausgeben.

Die Funktion printf() gibt die Anzahl der ausgegebenen Zeichen zurück. Tritt ein Fehler auf, dann wird eine negative Zahl zurückgegeben und errno gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupfprintf(), sprintf(), vprintf(),
\bgroup\color{Red}$\rightarrow$\egroupvfprintf(), vsprintf(), scanf(),
\bgroup\color{Red}$\rightarrow$\egroupputs(), putchar()


putc() 

#include <stdio.h>

int putc( int zeichen, FILE *datei );

gibt das Zeichen zeichen auf datei aus.

Eigentlich gleichbedeutend mit fputc(). Aber bei manchen Systemen als Makro definiert und deshalb unsicher.

Rückgabewert ist das ausgegebene Zeichen, oder EOF , wenn ein Fehler auftritt. Dann werden auch errno und der Fehlerindikator in datei gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupfputc(), putchar(),
\bgroup\color{Red}$\rightarrow$\egroupputs()


putchar() 

#include <stdio.h>

int putchar( int zeichen );

gibt das Zeichen zeichen auf der Standardausgabe aus.

Gleichbedeutend mit putc( c, stdout ) .

Rückgabewert ist das ausgegebene Zeichen, oder EOF , wenn ein Fehler auftritt. Dann wird auch errno gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupfputc(), putc(), puts()


puts() 

#include <stdio.h>

int puts( char *s );

gibt den String, der an der Stelle s beginnt, und einen Zeilenvorschub auf die Standardausgabe aus.

Rückgabewert ist 0, wenn alles klar ging. Im Fehlerfall wird ein Wert ungleich 0 zurückgegeben und errno sowie der Fehlerindikator der Standardausgabe werden gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupprintf(), gets(), fputs(), putchar()


qsort() 

#include <stdlib.h>

void qsort( void *feldanfang
            size_t elemente,
            size_t elementgroesse,
            int (*vergleichsfunktion)( const void *zeiger1,
                                       const void *zeiger2 )
          );

sortiert ein beliebiges Feld im Speicher, wenn folgende Bedingungen erfüllt sind:

  • Das Feld beginnt an der Stelle feldanfang im Speicher.
  • Das Feld hat elemente Elemente jeweils der Größe elementgroesse .
  • vergleichsfunktion zeigt auf eine Funktion, die zwei Zeiger auf je ein Feldelement entgegennimmt und einen negativen int -Wert liefert, wenn der erste Parameter auf ein Element mit kleinerem Suchschlüssel zeigt als der zweite Parameter, 0 liefert, wenn beide Parameter auf Elemente mit gleich großem Suchschlüssel zeigen und sonst einen positiven Wert liefert.
Gemäß den Vergleichskriterien der Funktion (*vergleichsfunktion)() ist das Feld nach dem Aufruf von qsort() sortiert.

Liefern mehrere Elemente keinen Unterschied beim Vergleich, dann ist ihre Reihenfolge untereinander unbestimmt und nicht unbedingt ihre ursprüngliche.

Wenn die einzelnen Feldelemente groß sind, kann man meist Rechenzeit sparen, indem man ein Feld mit Zeigern auf die einzelnen Feldelemente anlegt und dieses Zeigerfeld sortieren läßt. Die Vergleichsfunktion muß natürlich eine Dereferenzierung mehr besitzen für jeden der Parameter.

Beispielaufruf: 

/* fuqsort.c 30. 7.95 kw
 *
 * Vergleichsfunktion fuer zwei int-Werte.
 * Liefert einen Wert gleich 0, wenn die Elemente *p1 und *p2
 * gleich sind, kleiner als 0, wenn *p1 kleiner als *p2, sonst
 * groesser 0.
 */
int verg( const void *p1, const void *p2 )
{   return *(int *)p1 - *(int *)p2;
}

/* Testprogramm fuer qsort().
 */
int main()
{
  int   feld[10] = { 45, 89, 12, 36, 78, 1, 2, 41, 74, 85 };
  int   i;

  /* unsortiert ausgeben:
   */
  for( i = 0; i<10; i++ )
    printf( "%d ", feld[i] );
  printf( "\n" );

  /* sortieren lassen:
   */
  qsort( feld, 10, sizeof(int), verg );

  /* sortiert ausgeben:
   */
  for( i = 0; i<10; i++ )
    printf( "%d ", feld[i] );
  printf( "\n" );

  return;
}

Ausgabe davon: 

45 89 12 36 78 1 2 41 74 85 
1 2 12 36 41 45 74 78 85 89

Zum Parameter verg beim Aufruf von qsort() siehe auch die Bemerkung (bezüglich Adresse von Funktionen) auf Seite [*].

Ein weiteres Beispiel findet man auf Seite [*].

\bgroup\color{Red}$\rightarrow$\egroupbsearch()


raise() 

#include <signal.h>

int raise( int welches_signal );

erzeugt eine Ausnahmebehandlung, in der an das laufende Programm ein Signal mit dem Wert welches_signal gesandt wird.

welches_signal sollte einer der in signal.h definierten Werte sein, etwa SIGFPE (siehe Seite [*]).

Mit der Funktion signal() kann vorher festgelegt werden, wie auf bestimmte Signale zu reagieren ist.

\bgroup\color{Red}$\rightarrow$\egroupsignal()


rand() 

#include <stdlib.h>

int rand( void );

erzeugt eine ,,Zufallszahl`` im Bereich von 0 bis RAND_MAX .

Dies ist bei jedem Aufruf eine weitere Zahl aus einer Zahlenfolge, deren Startwert mit srand() gesetzt werden kann. Sonst wird dieser Startwert bei jedem Programmstart auf 0 gesetzt.

Ein Programm erhält dadurch bei jedem Lauf die gleiche Folge von ,,Zufallszahlen``: 

/* furand1.c 30. 7.95 kw
 */

#include <stdlib.h>

int main()
{
  int     i;

  for( i=0; i<10; i++ )
    printf( "%d\n", rand() );
}

Die Ausgabe des obigen Programms ist bei jedem Programmstart gleich.

Die immer wieder gleiche Folge von Zufallszahlen ist zur Fehlersuche manchmal ganz nützlich, da dadurch die Daten immer gleich sind. In vielen praktischen Fällen ist das aber nicht erwünscht; dann muß man den Startwert bewußt bei jedem Programmstart auf einen anderen Wert setzen. Dazu bieten sich Datum und Uhrzeit an: 

/* furand2.c 30. 7.95 kw
 */

#include <stdlib.h>
#include <time.h>

int main()
{
  int         i;
  time_t      t;
  struct tm  *tp;


  /* Datum und Uhrzeit holen:
   */
  t  = time( NULL );
  tp = localtime( &t );

  /* den Startwert fuer die Zufallszahlen
   * in Abhaengigkeit von der Zeit setzen:
   */
  srand(   tp->tm_sec
           + tp->tm_min
           + tp->tm_hour
           + tp->tm_yday
           );


  for( i=0; i<10; i++ )
    printf( "%d\n", rand() );
}

\bgroup\color{Red}$\rightarrow$\egroupsrand()


realloc() 

#include <stdlib.h>

void *realloc( void *alterblock, size_t wieviel )

dient dazu, einen Speicherblock zu allokieren (wie malloc()), oder einen bereits allokierten Speicherblock freizugeben (wie free()), oder einen allokierten Speicherblock in der Größe zu verändern.

In Abhängigkeit seiner Parameter verhält sich die Funktion realloc() folgendermaßen:

Wenn alterblock == NULL ,

dann:
realloc() reagiert genau wie malloc( wieviel ) , versucht also, einen Speicherblock der Größe wieviel zu allokieren.
ansonsten:
alterblock muß auf einen bereits früher mit malloc() oder calloc() reservierten Speicherblock zeigen. realloc() versucht dann, den Speicherblock auf die neue Größe wieviel zu ändern. Ist wieviel==0 , dann wird der früher allokierte Block freigegeben (wie bei free( alterblock ) ). Nach der Größenänderung kann der Block an einer anderen Stelle im Speicher liegen. Dann wird der alte Blockinhalt automatisch an die neue Stelle kopiert (maximal jedoch wieviel Bytes).

Rückgabewert ist ein Zeiger auf den Anfang des reservierten Blocks, wenn alles gut ging, oder der NULL -Zeiger, wenn kein Block ausreichender Größe zu haben ist. Ist wieviel==0 , dann wird der Block freigegeben und der Rückgabewert ist NULL .

\bgroup\color{Red}$\rightarrow$\egroupfree(), malloc(), calloc()


remove() 

#include <stdio.h>

int remove( const char *dateiname );

entfernt (löscht) eine Datei von einem Massenspeicher.

Rückgabe ist im Erfolgsfall der Wert 0. Ansonsten wird ein Wert ungleich 0 geliefert und errno gesetzt.

\bgroup\color{Red}$\rightarrow$\egrouprename(), tmpfile(), tmpnam()


rename() 

#include <stdio.h>

int rename( const char *altername, const char *neuername );

benennt eine Datei um. Dies ist auch möglich, wenn die Datei gerade geöffnet ist.

Eine Datei mit dem Namen neuername darf vorher nicht existieren.

Rückgabe ist im Erfolgsfall der Wert 0. Ansonsten wird ein Wert ungleich 0 geliefert und errno gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupremove()


rewind() 

#include <stdio.h>

void rewind( FILE *datei );

spult eine Datei an den Anfang zurück und löscht gegebenenfalls den Fehler- und den Dateiendeindikator der Datei. Nach rewind() darf bei Dateien im Änderungsmodus zwischen Lese- und Schreibzugriff gewechselt werden.

\bgroup\color{Red}$\rightarrow$\egroupfopen(), fseek(), ftell(), fsetpos(), fgetpos()


scanf() 

#include <stdio.h>

int scanf( const char *format, ... );

liest von der Standardeingabe Zeichen und führt gemäß den Direktiven in dem String ab *format Datenumwandlungen aus. Dabei werden von den Direktiven eventuell weitere Parameter verbraucht, deren Typ und Reihenfolge von den Direktiven in format abhängen. Da diese zusätzlichen Parameter angeben, wo die Ergebnisse der Umwandlungen im Speicher abzulegen sind, sind alle diese zusätzlichen Parameter von einem Zeigertyp.

Die Folge aus Eingabe und Umwandlungen wird solange fortgesetzt, bis das Ende von format erreicht ist, oder bis die eingelesenen Zeichen nicht zu den Direktiven passen. In diesem Fall wird die Abarbeitung vorzeitig abgebrochen.

Zurückgegeben wird die Anzahl der tatsächlich umgewandelten und zugewiesenen Werte oder EOF , wenn ein Dateifehler auftritt.

Der Formatstring besteht aus einer Folge von Direktiven. Jedes Zeichen außer dem Prozentzeichen % bewirkt, daß ein Zeichen von der Eingabe gelesen wird und mit dem Zeichen aus dem Formatstring verglichen wird. Wenn das gelesene Zeichen nicht identisch mit mit dem in format , dann wird scanf() abgebrochen.

Alle anderen Direktiven beginnen mit einem Prozentzeichen. Danach können in dieser Reihenfolge folgen (müssen aber nicht!):

*
Dies bedeutet, daß das Ergebnis der Umwandlung aus dieser Direktive keinem Wert zugewiesen werden soll und dadurch auch kein Argument verbraucht wird.

Weiterhin beeinflußt die Anzahl der so verarbeiteten Eingaben nicht den Rückgabewert der Funktion.

Die Eingabe wird also einfach überlesen.

Feldbreite
gibt (dezimal) an, wieviele Zeichen für die Umwandlung maximal gelesen werden sollen.

Objektgröße
ist ein Zeichen, welches die Größe des umgewandelten Ergebnisses im Speicher angibt und damit den Typ des zugeordneten Zeigers in der Parameterliste beschreibt:
h
gibt an, daß eine ganzzahlige Umwandlung den Typ short int haben soll.
l
analog long int ; bei Gleitkommakonversion bedeutet l eine Umwandlung nach double statt nach float.
L
bedeutet long double .
Wenn dieses Zeichen fehlt, dann wird für ganzzahlige Umwandlung der Datentyp int ( signed oder unsigned ) angenommen und für Gleitkommazahlen der Typ float .

Die Direktive endet mit einem Zeichen, das die Art der Umwandlung angibt:

%d
führt eine Umwandlung der gelesenen Zeichen von dezimaler Schreibweise nach int durch.
%i
wandelt eine Zeichenfolge mit einer vorzeichenbehafteten ganzen Zahl um, wie sie auch von strtol() mit der Basis 0 durchgeführt wird. Die Zahlenbasis der Umwandlung wird dabei von den ersten Zeichen festgelegt. Siehe strtol().
%o
wandelt eine vorzeichenlose oktale Zeichenfolge (Basis 8) um. Siehe strtoul() mit Basis 8.
%u
wandelt eine vorzeichenlose Ziffernfolge (dezimal, also Basis 10) um wie strtoul() mit Basis 10.
%x , %X
verwandeln eine sedezimale Ziffernfolge wie strtoul() mit Basis 16.
%e , %E
,
%f , %F
,
%g , %G
wandeln die Zeichenfolge einer Gleitkommazahl wie strtod().
%c
wandelt eine Zeichenfolge mit der Länge der Feldbreite, wenn angegeben; sonst ein Zeichen. Hier werden ausnahmsweise führende white-space-Zeichen nicht übersprungen. Das zugehörige Argument muß ein Zeiger auf einen Speicherbereich sein, der groß genug ist für alle gelesenen Zeichen. Es wird keine abschließende Null angehängt.
%s
liest eine Folge von Zeichen, die nicht Zwischenraumzeichen sind. Der zugehörige Parameter muß auf einen Speicherbereich zeigen, der groß genug ist für die gelesenen Zeichen und die abschließende \0 , die automatisch angehängt wird.

Wenn eine Feldbreite angegeben ist, dann werden maximal soviele Zeichen eingelesen und in den Speicherbereich kopiert; wie sonst auch wird dann eine abschließende Null angehängt. Deshalb sollte der Speicherbereich ein Byte größer sein als die Feldbreite!

%[
beginnt in format eine Zeichenfolge, die von ] beendet wird. Im eingelesenen Strom von Zeichen werden alle Zeichen in den Speicher übertragen ab der Stelle, auf die der zugehörige Parameter aus der Parameterliste zeigt. Dieser Speicherbereich muß Platz bieten für alle eingelesenen Zeichen (maximal die Feldbreite) plus 1 für die abschließende \0 , die automatisch angefügt wird. Es wird übertragen, solange alle gelesenen Zeichen in dem Klammerpaar [ ... ] enthalten sind; das erste andere Zeichen wird nicht übertragen.

Ist das erste Zeichen nach dem [ ein ^ , dann wird die Wirkung umgedreht: alle eingelesenen Zeichen, die nicht in format zwischen [^ und ] vorkommen, werden übertragen.

Um das Zeichen ] selbst in die Zeichenfolge aufzunehmen, muß es direkt nach dem Zeichen [ auftreten bzw. nach der Folge [^ . Nur dann beendet dieses ] nicht die Direktive in format , sondern erst das nächste auftretende ] .

%p
wandelt eine hexadezimale Zeichenfolge 0x... um in einen Zeiger. Das zugehörige Argument muß also vom Typ Zeiger auf Zeiger auf irgendwas ( void ** ) sein.

%n
liest keine Eingabezeichen; aber die Anzahl der bisher eingelesenen Zeichen wird als unsigned int dahin geschrieben, wo der zugehörige Zeiger aus der Parameterliste hinzeigt. Dieser Vorgang erhöht nicht den Rückgabewert von scanf().

%%
paßt zu einem % aus der Eingabe. Wie sonst auch jede Direktive, die nicht mit % beginnt, wird kein Parameter verbraucht. Diese Direktive sollte nur aus den beiden Zeichen %% bestehen; die sonst wahlweise möglichen Zeichen dazwischen dürfen nicht genutzt werden.

Die Umwandlung geschieht in folgender Weise:

Alle Zwischenraumzeichen (white space, siehe isspace()) werden übersprungen.

Von der Eingabe werden Zeichen gelesen, bis die Feldbreite erreicht ist, oder keine Eingabezeichen mehr verfügbar sind, oder bis ein Zeichen nicht zur aktuellen Umwandlung paßt. In letzterem Fall wird das gelesene Zeichen nicht verbraucht und steht für die nächste Umwandlung zur Verfügung.

Je nach dem letzten Buchstaben der Direktive (siehe oben) wird die Folge der Eingabezeichen in den entsprechenden Datentyp umgewandelt. Dabei kann ein Überlauf auftreten, der das Ergebnis verfälscht und nicht weiter berücksichtigt wird.

Wenn das Zeichen * nicht zu Beginn der Direktive stand, dann wird aus der Parameterliste ein Zeiger verbraucht und das Ergebnis an der betreffenden Stelle im Speicher abgelegt. Jede solche Zuweisung erhöht den späteren Rückgabewert um eins.

Achtung! Die Direktiven im Formatstring und die restlichen Argumente der Funktion müssen in Typ und Reihenfolge sauber zusammenpassen, sonst produziert die Funktion nur Unsinn!

Ebenso wie bei printf() gibt es für den Datentyp size_t keine direkt passende Direktive. Dazu muß man den Umweg über eine Variable vom Typ unsigned long nehmen.

\bgroup\color{Red}$\rightarrow$\egroupstrtol(), printf(), sscanf(),
\bgroup\color{Red}$\rightarrow$\egroupfscanf()


setbuf() 

#include <stdio.h>

void setbuf( FILE *datei, char *puffer );

setzt den Puffer für die angegebene Datei an die Stelle puffer .

Der Speicherbereich ab diesem Zeigerwert muß mindestens BUFSIZ Bytes groß sein und muß existieren, solange die Datei geöffnet bleibt.

Wenn puffer den Wert NULL hat, dann wird die Ein- und Ausgabe für diese Datei nicht gepuffert.

Diese Funktion muß zwischen dem Öffnen der Datei und dem ersten Zugriff aufgerufen werden oder gar nicht.

setbuf( datei, puffer ) ist identisch mit
setvbuf( datei, puffer, _IOFBF, BUFSIZ ) oder (wenn puffer NULL ist) mit
setvbuf( datei, puffer, _IONBF, 0 ) .

\bgroup\color{Red}$\rightarrow$\egroupfopen(), setvbuf()


setjmp() 

#include <setjmp.h>

int setjmp( jmp_env umgebung );

speichert die aktuelle Situation des Prozessors (program counter, stack pointer, alle wichtigen Register etc.) in umgebung und gibt den Wert 0 zurück.

Bei einem späteren Aufruf von longjmp( umgebung, wert ) wird ebenfalls die Programmausführung da fortgesetzt, wo sie auch nach dem Aufruf von setjmp() fortgeführt wird. Nur wird nach der Ausführung von longjmp() nicht 0 geliefert, sondern der zweite Parameter von longjmp().

Deshalb sollte dieser nie 0 sein; sonst kann der Aufrufer von setjmp() nicht entscheiden, ob der Rücksprung aus setjmp() tatsächlich von setjmp() kommt oder von einem späteren Aufruf von longjmp().

Ein Beispiel steht auf Seite [*]. Die dort stehende Warnung bitte beherzigen!

\bgroup\color{Red}$\rightarrow$\egrouplongjmp()


setvbuf() 

#include <stdio.h>

int setvbuf( FILE *datei,
             char *puffer,
             int wie_denn_nun,
             size_t wieviel    );

gibt die gewünschte Pufferung für eine Datei an.

setvbuf() muß zwischen dem Öffnen der Datei und dem ersten Zugriff ausgeführt werden oder gar nicht.

wie_denn_nun muß einer der Werte: _IOFBF , _IOLBF , _IONBF sein. Dementsprechend wird die Datei voll (blockweise), zeilenweise oder gar nicht gepuffert.

Außer bei _IONBF muß puffer auf einen Speicherbereich zeigen, der wieviel Byte lang ist und solange erhalten bleibt, wie die Datei geöffnet ist.

Ist puffer gleich NULL , dann wird von setvbuf() selbständig ein ausreichender Puffer beschafft (mit malloc()), der beim Schließen der Datei auch wieder freigeben wird.

Zurückgegben wird 0, wenn alles gut ging; ansonsten ein Wert ungleich 0. Dann wird errno entsprechend gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupsetbuf()


signal() 

#include <signal.h>

void (*signal( int welches_signal,
               void (*neue_funktion)( int )
             )
     )( int );

gibt an, wie in Zukunft auf Signale mit dem Wert welches_signal reagiert werden soll.

signal() hat zwei Parameter:

  • eine int , die angibt, um welches der in Zukunft möglicherweise auftretenden Signale es geht.
  • einen Zeiger auf eine Funktion, die wiederum einen int -Parameter erhält und nichts void zurückliefert.

welches_signal sollte einer der folgenden Werte sein:

  • SIGABRT Programmabbruch, z.B. wegen Aufruf von abort().
  • SIGFPE Fehler bei Gleitkommarechnung.
  • SIGILL unzulässiger Funktionsaufruf.
  • SIGINT Eintreffen eines interaktiven Signals.
  • SIGSEGV Unzulässiger Speicherzugriff.
  • SIGTERM Programmende gefordert.

neue_funktion muß entweder auf eine Funktion zeigen, die in Zukunft auf das entsprechende Signal reagieren soll (der Signaltyp, also welches_signal , wird ihr dann als Parameter übergeben), oder neue_funktion muß einen der Werte SIG_IGN bzw. SIG_DFL haben. Dann wird beim Auftreten eines solchen Signals selbiges ignoriert bzw. die Standardreaktion findet statt, die auch bei Programmstart voreingestellt ist.

Zurückgegeben wird ein Zeiger auf den bisherigen Empfänger eines solchen Signals.

Wirkliches Weitergeben von Signalen geschieht eigentlich nur auf Systemen mit Multitasking, also nicht auf kleinen Rechnern mit MSDOS oder ähnlichen Betriebssystemen.

Ein Signal kann jedoch auch mit raise() vom Programm selbst erzeugt und an sich selbst geschickt werden.

\bgroup\color{Red}$\rightarrow$\egroupraise()


sin() 

#include <math.h>

double sin( double phi );

liefert den \bgroup\color{Red}$\sin(\tt phi)$\egroup ( phi ist im Bogenmaß anzugeben).

Ist phi betragsmäßig zu groß, dann kann das Ergebnis ungenau sein, ohne daß errno gesetzt wird.

\bgroup\color{Red}$\rightarrow$\egroupasin(), cos(), tan(), sinh()


sinh() 

#include <math.h>

double sinh( double phi );

liefert den \bgroup\color{Red}$\sinh(\tt phi)$\egroup.

Ist phi betragsmäßig zu groß, dann wird der Wert HUGE_VAL zurückgegeben und errno auf ERANGE gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupsin(), cosh(), tanh()


sprintf() 

#include <stdio.h>

int sprintf( char *string, const char *format, ... );

ist identisch mit printf(), mit dem Unterschied, daß die Ausgabe nicht nach stdout geschrieben wird, sondern stattdessen in den Speicher ab der Stelle string . Dieser Parameter muß also auf einen ausreichend großen Speicherbereich zeigen. Der geschriebene String wird automatisch mit \0 abgeschlossen.

Zur Beschreibung der weiteren Parameter: siehe printf().

\bgroup\color{Red}$\rightarrow$\egroupprintf(), sscanf()


sqrt() 

#include <math.h>

double sqrt( double wert );

berechnet \bgroup\color{Red}$\sqrt\tt wert$\egroup und gibt diese Zahl zurück.

Wenn wert negativ ist, dann wird 0.0 zurückgegeben und errno auf EDOM gesetzt.

\bgroup\color{Red}$\rightarrow$\egrouppow()


srand() 

#include <stdlib.h>

void srand( int startwert );

setzt den Startwert des Zufallszahlengenerators für zukünftige Aufrufe von rand().

Dieser Startwert wird bei jedem Programmstart auf 0 gesetzt. Mit srand( 0 ) und einer Folge von rand()-Aufrufen kann man also jeweils wieder die gleiche Zahlenfolge wie bei Programmstart erhalten.

\bgroup\color{Red}$\rightarrow$\egrouprand()


sscanf() 

#include <stdio.h>

int sscanf( const char *string, const char *format, ... );

ist identisch mit scanf(), außer dem zusätzlichen ersten Parameter. sscanf() liest nicht von stdin , sondern aus dem Speicherbereich, der bei string beginnt.

Zur Beschreibung der weiteren Parameter: siehe scanf().

\bgroup\color{Red}$\rightarrow$\egroupscanf(), sprintf()


strcat() 

#include <string.h>

char *strcat( char *woran, char *woher );

kopiert an das Ende des Strings woran alle Zeichen ab *woher , wobei die abschließende \0 des Strings woran vom ersten Zeichen aus woher überschrieben wird. Das Resultat ist ein String, der ab woran steht und hinter den bisherigen Zeichen von woran die Zeichen ab woher enthält. Dahinter folgt eine abschließende Null \0 .

Achtung! Der Zeiger woran muß auf einen Speicherbereich zeigen, der genügend Platz für alle Zeichen aus woran plus alle Zeichen aus woher plus 1 (für die Null) enthält.

Zurückgegeben wird ein Zeiger mit dem Wert woran .

\bgroup\color{Red}$\rightarrow$\egroupstrncat(), memcpy(), strcpy()


strchr() 

#include <string.h>

char *strchr( const char *wo, int was );

sucht in dem String ab *wo nach dem Zeichen (char)was und liefert einen Zeiger auf das erste Vorkommen, bzw. NULL , wenn nicht gefunden. Die abschließende \0 wird in die Suche noch mit eingeschlossen, das heißt man kann mit strchr( string, 0 ) nach dem Stringende suchen.

\bgroup\color{Red}$\rightarrow$\egroupstrlen(), memchr(), strstr(), strrchr()


strcmp() 

#include <string.h>

int strcmp( const char *str1, const char *str2 );

vergleicht zwei Strings str1 und str2 und liefert einen Wert größer als 0, wenn in der ersten Position, an der sich die beiden Strings unterscheiden, in str1 ein (alphabetisch) größeres Zeichen steht als in str2 , und liefert einen Wert kleiner als 0 bei umgekehrten Verhältnissen. Sind die beiden Strings gleichlang und bis zur abschließenden \0 identisch, dann wird 0 zurückgegeben.

Die Zeichen in den Strings werden dabei immer als unsigned char betrachtet.

\bgroup\color{Red}$\rightarrow$\egroupstrncmp(), memcmp()


strcpy() 

#include <string.h>

char *strcpy( char *wohin, char *woher );

kopiert alle Zeichen ab *woher bis zur ersten auftretenden \0 (einschließlich) in den Speicher ab der Stelle wohin .

Achtung! Der Zeiger wohin muß auf einen Speicherbereich zeigen, der genügend Platz für alle Zeichen aus woher plus 1 (für die Null) enthält.

\bgroup\color{Red}$\rightarrow$\egroupstrncpy(), memcpy(), strcat()


strcspn() 

#include <string.h>

size_t strcspn( const char *worin, const char *welchezeichennicht );

bestimmt die Länge des Anfangsstücks des Strings worin , das nur aus Zeichen besteht, die nicht auch in welchezeichennicht vorkommen.

Wenn welchezeichennicht leer ist oder keine Zeichen enthält, die auch in worin vorkommen, dann liefert strcspn() die Länge von worin .

\bgroup\color{Red}$\rightarrow$\egroupstrspn()


strerror() 

#include <string.h>

char *strerror( int fehlernummer );

liefert einen Zeiger auf einen String, der eine Beschreibung des Fehlers mit der Nummer fehlernummer enthält.

fehlernummer muß dazu einer der Werte sein, die in errno.h für die Variable errno definiert sind. Ansonsten kann es sein, daß strerror() einen Zeiger auf einen leeren String liefert.

Die Fehlerbeschreibung darf nicht modifiziert werden.

Achtung! Bei einigen Unix-Versionen gibt es eine Funktion mit dem gleichen Namen, aber einer anderen Funktionsweise!

\bgroup\color{Red}$\rightarrow$\egroupperror()


strftime() 

#include <time.h>

size_t strftime( char *wohin,
                 size_t wieviele_maximal,
                 const char *format,
                 const struct tm *ortszeit    );

erzeugt einen String ab der Stelle wohin mit maximal wieviele_maximal Zeichen (einschließlich der abschließenden \0 ), der aus format gebildet wird. Alle Zeichen aus format werden nach wohin kopiert, mit Ausnahme von bestimmten Direktiven, die in den erzeugten String wohin Werte aus *ortszeit einsetzen.

An Direktiven stehen zur Verfügung:

%a
abgekürzter Name des Wochentags
%A
Name des Wochentags
%b
abgekürzter Monatsname
%B
Monatsname
%c
Datum und Uhrzeit
%d
Tag des Monats (01-31)
%H
Stunde (00-23)
%I
Stunde (00-12)
%j
Tag im Jahr (001-366)
%m
Monat im Jahr (01-12)
%M
Minute (00-59)
%p
AM oder PM
%S
Sekunde (00-59)
%U
Wochennummer mit Sonntag als erstem Tag der Woche (00-53)
%w
Wochentag mit 0 als Sonntag (0-6)
%W
Wochennummer mit Montag als erstem Tag der Woche (00-53)
%x
Datum
%X
Uhrzeit
%y
Jahr ohne Jahrhundert (00-99)
%Y
Jahr mit Jahrhundert
%Z
Name der Zeitzone, oder nichts, falls die Zeitzone nicht feststellbar ist. Dieser Wert wird aus der Environmentvariablen TZ bestimmt.
%%
Ein Prozentzeichen wird ausgegeben.

Zurückgegeben wird 0, wenn der String nicht innerhalb der angegebenen Zeichenzahl gebildet werden kann; ansonsten die Anzahl der erzeugten Zeichen (ohne die \0 ).

Das folgende Beispiel gibt das aktuelle Datum aus: 

/* fustrft.c 30. 7.95 kw
 */

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

#define LAENGE  25

int main( int argc, char **argv )
{
  char                string[LAENGE];
  struct tm   ortszeit;
  time_t              zeitgepackt;

  /* Holen des gepackten Zeitformats:
   */
  zeitgepackt = time( NULL );
  /* Entpacken in eine struct tm:
   */
  ortszeit = *localtime( &zeitgepackt );
  /* Tag, Monat und Jahr in einen String
   * schreiben:
   */
  strftime( string,
            LAENGE,
            "Heute ist der %d.%m.%Y\n",
            &ortszeit
            );
  /* Ausgabe des Strings:
   */
  puts( string );

  return EXIT_SUCCESS;
}

\bgroup\color{Red}$\rightarrow$\egrouptime(), asctime(), localtime()


strlen() 

#include <string.h>

size_t strlen( const char *string );

bestimmt die Länge des Strings string bis auf die abschließende \0 .

\bgroup\color{Red}$\rightarrow$\egroupstrchr()


strncat() 

#include <string.h>

char *strncat( char *woran, char *woher, size_t wieviele_maximal );

kopiert an das Ende des Strings woran alle Zeichen ab *woher , wobei die abschließende \0 des Strings woran vom ersten Zeichen aus woher überschrieben wird. Das Resultat ist ein String, der ab *woran steht und hinter den bisherigen Zeichen von woran die Zeichen ab *woher enthält. Dahinter folgt eine abschließende Null \0 .

Die Anzahl der kopierten Zeichen ist maximal wieviele_maximal Zeichen ohne die abschließende \0 . Darüber hinaus gehende Zeichen werden nicht kopiert.

Achtung! Der Zeiger woran muß auf einen Speicherbereich zeigen, der für (die alte Länge von woran + wieviele_max + 1) Zeichen Platz bietet.

Die Strings woher und wohin dürfen sich nicht überschneiden.

Zurückgegeben wird ein Zeiger mit dem Wert woran .

\bgroup\color{Red}$\rightarrow$\egroupstrcat(), memcpy(), strncpy()


strncmp() 

#include <string.h>

int strncmp( const char *str1, const char *str2, size_t wieviele_maximal );

vergleicht zwei Strings str1 und str2 und liefert einen Wert größer als 0, wenn in der ersten Position, an der sich die beiden Strings unterscheiden, in str1 ein (alphabetisch) größeres Zeichen steht als in str2 , und liefert einen Wert kleiner als 0 bei umgekehrten Verhältnissen. Sind die beiden Strings gleichlang und bis zur abschließenden \0 identisch, dann wird 0 zurückgegeben.

Es werden höchstens wieviele_maximal Zeichen verglichen. Sind beide Strings länger und in den ersten wieviele_maximal Zeichen gleich, dann wird ebenfalls 0 zurückgegeben.

Die Zeichen in den Strings werden dabei immer als unsigned char betrachtet.

\bgroup\color{Red}$\rightarrow$\egroupstrcmp(), memcmp()


strncpy() 

#include <string.h>

char *strncpy( char *wohin, char *woher, size_t wieviele );

kopiert alle Zeichen ab woher bis zur ersten auftretenden \0 (einschließlich) in den Speicher ab der Stelle wohin und füllt bis zur Länge wieviele mit Nullen auf, wenn woher kürzer ist als wieviele Zeichen. Ansonsten werden wieviele Zeichen kopiert und keine Null angehängt.

Achtung! Der Zeiger wohin muß auf einen Speicherbereich zeigen, der genügend Platz für wieviele Zeichen enthält.

\bgroup\color{Red}$\rightarrow$\egroupstrcpy(), memcpy(), strcat()


strpbrk() 

#include <string.h>

char *strpbrk( const char *worin, const char *welche );

liefert einen Zeiger auf das erste Zeichen in dem String worin , das auch in dem String welche vorkommt. Die abschließenden Nullen werden nicht in die Suche mit einbezogen. Wird kein solches Zeichen gefunden, dann liefert die Funktion NULL zurück.

\bgroup\color{Red}$\rightarrow$\egroupstrstr(), strspn(), strchr(),
\bgroup\color{Red}$\rightarrow$\egroupstrtok()


strrchr() 

#include <string.h>

char *strrchr( const char *wo, int was );

sucht in dem String ab wo nach dem Zeichen (char)was und liefert einen Zeiger auf das letzte Vorkommen, bzw. NULL , wenn nicht gefunden. Die abschließende \0 wird in die Suche mit eingeschlossen, das heißt man kann mit strrchr( string, 0 ) nach dem Stringende suchen.

\bgroup\color{Red}$\rightarrow$\egroupstrlen(), memchr(), strstr(),
\bgroup\color{Red}$\rightarrow$\egroupstrchr()


strspn() 

#include <string.h>

size_t strspn( const char *worin, const char *welchezeichen );

bestimmt die Länge des Anfangsstücks des Strings worin , das nur aus Zeichen besteht, die auch in welchezeichen vorkommen.

Die abschließenden Nullen werden nicht mit durchsucht.

\bgroup\color{Red}$\rightarrow$\egroupstrcspn()


strstr() 

#include <string.h>

char *strstr( const char *worin, const char *welcher );

sucht in dem String worin nach der Zeichenfolge welcher und liefert einen Zeiger auf den Anfang in worin bzw. NULL , wenn welcher nicht in worin enthalten ist. Die abschließende Null von welcher wird nicht mit einbezogen.

\bgroup\color{Red}$\rightarrow$\egroupstrchr(), strpbrk(), strspn(),
\bgroup\color{Red}$\rightarrow$\egroupstrcspn()


strtod() 

#include <stdlib.h>

double strtod( const char *string, char **endezeiger );

verwandelt den String ab string in eine Gleitkommazahl, die zurückgegeben wird. Dabei werden aus string solange Zeichen gelesen, bis das Ende von string erreicht ist oder ein ungültiges Zeichen gelesen wird. Der dabei errechnete Zahlenwert wird zurückgegeben. Wenn endezeiger ungleich NULL ist, dann wird an der Stelle *endezeiger im Speicher ein Zeiger auf das erste Zeichen hinterlegt, das nicht mehr mit umgewandelt werden konnte. War bereits das erste Zeichen ungültig, dann ist der hinterlegte Zeiger der Wert von string .

Kann kein Zeichen umgewandelt werden, dann wird 0.0 zurückgegeben. Ist der umzuwandelnde Wert zu groß, dann wird +HUGE_VAL oder -HUGE_VAL zurückgegeben und errno auf ERANGE gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupatof(), sscanf(), strtol(),
\bgroup\color{Red}$\rightarrow$\egroupstrtoul()


strtok() 

#include <string.h>

char *strtok( char *string, const char *trennzeichen );

teilt einen String string in einzelne Bruchstücke (token) gemäß der Trennzeichen im String trennzeichen .

Für jedes Bruchstück erfolgt ein Aufruf von strtok(), wobei jeweils ein Zeiger auf den Anfang des Tokens geliefert wird oder NULL , wenn der String keine weiteren Token liefert.

Beim ersten Aufruf übergibt man den zu zerlegenden String als ersten Parameter. Die Menge der Trennzeichen übergibt man in einem String als zweiten Parameter. Die Funktion übergeht alle führenden Zeichen in string , bis eines gefunden wird, das nicht in trennzeichen enthalten ist. Dies ist der Anfang des ersten Teilstrings, der zurückgegeben wird.

Für weitere Aufrufe zum gleichen string übergibt man als ersten Parameter den Wert NULL . Der String mit Trennzeichen darf von Aufruf zu Aufruf wechseln. Die Suche wird jeweils hinter dem zuletzt gefundenen Trennzeichen fortgesetzt. Das jeweils gefundene Trennzeichen wird in string durch \0 ersetzt und ein Zeiger auf den nächsten Teilstring geliefert, bis das Ende von string erreicht ist. Dann wird NULL zurückgegeben.

Achtung! Der ursprüngliche Inhalt von string wird durch das Überschreiben der Trennzeichen mit Nullen verändert! Deshalb darf man als ersten Parameter keine Stringkonstante übergeben.

\bgroup\color{Red}$\rightarrow$\egroupstrcspn(), strspn()


strtol() 

#include <stdlib.h>

long int strtol( const char *string,
                 char **endezeiger,
                 int basis           );

verwandelt den String ab string in eine ganze Zahl, die zurückgegeben wird. Dabei werden aus string solange Zeichen gelesen, bis das Ende von string erreicht ist oder ein ungültiges Zeichen gelesen wird. Der dabei errechnete Zahlenwert wird zurückgegeben. Wenn endezeiger ungleich NULL ist, dann wird an der Stelle *endezeiger im Speicher ein Zeiger auf das erste Zeichen hinterlegt, das nicht mehr mit umgewandelt werden konnte. War bereits das erste Zeichen ungültig, dann ist der hinterlegte Zeiger der Wert von string .

Der String wird dabei als Zahl zur Basis basis betrachtet. Ist basis 0, dann darf die Ziffernfolge in string die Form einer C-Konstanten haben und die Basis wird aus den ersten Zeichen bestimmt ( 0x oder 0X für Basis 16, 0 für Basis 8 etc.). Ansonsten darf basis Werte von 2 bis 36 annehmen, wobei die Buchstaben a - z bzw. A - Z für die Ziffern mit den Werten 10-35 stehen.

Kann kein Zeichen umgewandelt werden, dann wird 0 zurückgegeben. Ist der umzuwandelnde Wert betragsmäßig zu groß, dann wird LONG_MIN oder LONG_MAX zurückgegeben und errno auf ERANGE gesetzt.

\bgroup\color{Red}$\rightarrow$\egroupatoi(), sscanf(), strtod(),
\bgroup\color{Red}$\rightarrow$\egroupstrtoul()


strtoul() 

#include <stdlib.h>

unsigned long int strtoul( const char *string,
                           char **endezeiger,
                           int basis           );

verwandelt den String ab string in eine ganze Zahl, die zurückgegeben wird. Dabei werden aus string solange Zeichen gelesen, bis das Ende von string erreicht ist oder ein ungültiges Zeichen gelesen wird. Der dabei errechnete Zahlenwert wird zurückgegeben. Wenn endezeiger ungleich NULL ist, dann wird an der Stelle *endezeiger im Speicher ein Zeiger auf das erste Zeichen hinterlegt, das nicht mehr mit umgewandelt werden konnte. War bereits das erste Zeichen ungültig, dann ist der hinterlegte Zeiger der Wert von string .

Der String wird dabei als Zahl zur Basis basis betrachtet. Ist basis 0, dann darf die Ziffernfolge in string die Form einer C-Konstanten haben und die Basis wird aus den ersten Zeichen bestimmt ( 0x oder 0X für Basis 16, 0 für Basis 8 etc.). Ansonsten darf basis Werte von 2 bis 36 annehmen, wobei die Buchstaben a - z bzw. A - Z für die Ziffern mit den Werten 10-35 stehen.

Kann kein Zeichen umgewandelt werden, dann wird 0 zurückgegeben. Ist der umzuwandelnde Wert zu groß, dann wird LONG_MAX zurückgegeben und errno auf ERANGE gesetzt.

Außer der Behandlung des Ergebnisses als unsigned ist strtoul() identisch mit
strtol().

\bgroup\color{Red}$\rightarrow$\egroupatoi(), sscanf(), strtod(),
\bgroup\color{Red}$\rightarrow$\egroupstrtol()


system() 

#include <stdlib.h>

int system( const char *kommando );

versucht den Kommandointerpreter der aufrufenden Programmumgebung zu rufen und das Kommando in kommando ausführen zu lassen.

Mit einem NULL -Zeiger als kommando kann man testen, ob ein Kommandoprozessor erreichbar ist. Dann wird nämlich ein von Null unterschiedlicher Wert zurückgegeben.

Der Inhalt des Strings kommando ist systemabhängig.

\bgroup\color{Red}$\rightarrow$\egroupgetenv()


tan() 

#include <math.h>

double tan( double wert );

liefert den \bgroup\color{Red}$\tan(\tt wert)$\egroup ( wert ist im Bogenmaß anzugeben).

Ist wert zu groß, kann ein sehr ungenaues Ergebnis geliefert werden, ohne daß eine Fehlermeldung auftritt.

\bgroup\color{Red}$\rightarrow$\egroupatan(), atan2(), tanh(),
\bgroup\color{Red}$\rightarrow$\egroupsin(), cos()


tanh() 

#include <math.h>

double tanh( double wert );
liefert den \bgroup\color{Red}$\tanh( \tt wert )$\egroup.

\bgroup\color{Red}$\rightarrow$\egroupexp(), sinh(), cosh()


time() 

#include <time.h>

time_t time( time_t *zeit_zeiger );

liefert die aktuelle Systemzeit. Wenn zeit_zeiger ungleich NULL ist, dann wird die Zeit ebenfalls an dieser Stelle im Speicher hinterlegt.

Das folgende Beispiel gibt Datum und Uhrzeit in ,,üblicher`` Form aus:

/* futime.c 30. 7.95 kw
 */

#include <stdio.h>
#include <stddef.h>
#include <time.h>

void main()
{
  time_t      zeit;
  struct tm   z;
  char       *tag[] =
  {
    "Sonntag",
    "Montag",
    "Dienstag",
    "Mittwoch",
    "Donnerstag",
    "Freitag",
    "Samstag",
  };
  char       *mon[] =
  {
    "Januar",
    "Februar",
    "Maerz",
    "April",
    "Mai",
    "Juni",
    "Juli",
    "August",
    "September",
    "Oktober",
    "November",
    "Dezember",
  };

  /* Holen der komprimierten Uhrzeit in die Variable zeit:
   */
  zeit = time( NULL );

  /* Entpacken der Variablen zeit in die Struktur z:
   */
  z = *localtime( &zeit );

  /* Ausgabe von einigen Elementen der Struktur:                  */
  printf( "Heute ist %s, %d. %s %d  %02d:%02d h\n",
          tag[z.tm_wday],
          (int)z.tm_mday,
          mon[z.tm_mon],
          (int)z.tm_year+1900,
          (int)z.tm_hour,
          (int)z.tm_min
          );
}

\bgroup\color{Red}$\rightarrow$\egroupctime(), asctime(), gmtime(),
\bgroup\color{Red}$\rightarrow$\egrouplocaltime(), mktime()


tmpfile() 

#include <stdio.h>

FILE *tmpfile( void );

öffnet eine temporäre Binärdatei, die nach dem Schließen automatisch entfernt wird (außer bei Programmabbruch durch abort()), im Modus wb+ mit einem automatisch erzeugten Dateinamen. Geliefert wird der zugehörige Dateizeiger oder NULL , wenn keine Datei geöffnet werden kann.

\bgroup\color{Red}$\rightarrow$\egroupfopen(), tmpnam(), exit(), abort()


tmpnam() 

#include <stdio.h>

char *tmpnam( char *wohin );

erzeugt einen gültigen Dateinamen, der noch an keine Datei vergeben ist. Bei jedem Aufruf wird ein anderer Name erzeugt.

Wenn wohin den Wert NULL hat, dann wird der Name in einem statischen Speicherbereich erzeugt, der beim nächsten Aufruf überschrieben werden kann. Ansonsten wird der Name da erzeugt, worauf wohin weist. Dann sollte ab wohin Platz für mindestens L_tmpnam Zeichen sein.

Zurückgegeben wird ein Zeiger auf den erzeugten Namen, oder NULL , wenn ein Fehler auftrat.

\bgroup\color{Red}$\rightarrow$\egrouptmpfile(), fopen(), remove()


tolower() 

#include <ctype.h>

int tolower( int zeichen );

liefert zu einem Großbuchstaben ( A - Z ) den entsprechenden Kleinbuchstaben. Andere Zeichen werden nicht verwandelt.

Deutsche Umlaute werden nicht als Buchstaben behandelt, sondern als Sonderzeichen.

Achtung! Auf älteren Systemen (bei einigen Unixversionen) verwandelt tolower() alle Buchstaben; dann darf man die Funktion nur mit Großbuchstaben aufrufen.

\bgroup\color{Red}$\rightarrow$\egrouptoupper()


toupper() 

#include <ctype.h>

int toupper( int zeichen );

liefert zu einem Kleinbuchstaben ( a - z ) den entsprechenden Großbuchstaben. Andere Zeichen werden nicht verwandelt.

Deutsche Umlaute werden nicht als Buchstaben behandelt, sondern als Sonderzeichen.

Achtung! Auf älteren Systemen (bei einigen Unixversionen) verwandelt toupper() alle Buchstaben; dann darf man die Funktion nur mit Kleinbuchstaben aufrufen.

\bgroup\color{Red}$\rightarrow$\egrouptolower()


ungetc() 

#include <stdio.h>

int ungetc( int zeichen, FILE *datei );

stellt das schon gelesen Zeichen zeichen wieder zurück in den Dateipuffer, so daß der nächste Leseaufruf wieder dieses Zeichen liefert (sofern zwischendurch keine Dateipositionierung erfolgt).

Man darf sich nur darauf verlassen, daß ein Zeichen zurückgestellt werden kann.

Zurückgegeben wird das Zeichen oder EOF , wenn mehrere Zeichen zurückgestellt werden sollen oder wenn zeichen den Wert EOF hat.

\bgroup\color{Red}$\rightarrow$\egroupgetc(), fgetc()


va_start(), va_arg(), va_end() 

#include <stdarg.h>

void    va_start( va_list arglist, argument );
type??? va_arg  ( va_list arglist, type??? );
void    va_end  ( va_list arglist );

Mit diesen Makros kann man variable Parameterlisten (wie beispielsweise die Parameterliste für printf()) auswerten.

Eine Funktion, die mit einer variablen Parameterliste aufgerufen werden soll, vereinbart vom Typ va_list eine Variable. Hier soll sie arglist heißen, aber der Name ist natürlich frei wählbar.

Die Funktion braucht mindestens einen bekannten Parameter.

Der letzte bekannte Parameter (in der Deklaration vor der Zeichenfolge ... ) wird benutzt, um die Variable zu initialisieren: 

va_start( arglist, letzter_bekannter_Parameter );

Dann kann man die variablen Parameter nacheinander mit je einem Aufruf von va_arg() holen, wobei der jeweilige Typ des zu holenden Parameters anzugeben ist. Soll beispielsweise eine double aus der Parameterliste in eine Variable d gelesen werden, dann ist 

d = va_arg( arglist, double );

zu schreiben.

va_arg() hat keinen festgelegten Ergebnistyp; es liefert ein Objekt von dem Typ, den man als zweiten Parameter angibt.

Der zweite Parameter an va_arg() ist also kein Objekt (wie Konstante oder Variable), sondern eine Typenangabe!

So können alle Parameter geholt werden.

Vor Beendigung der Funktion muß unbedingt 

va_end( arglist );

aufgerufen werden.

Beispiel: 

/* fuvaarg.c 30. 7.95 kw
 */

#include <stdarg.h>
#include <stdlib.h>

/* maxabs() erhaelt einen Formatstring, der aus einer Folge
 * von Direktiven besteht. Jede Direktive beschreibt den Typ
 * eines weiteren Parameters aus der Parameterliste.
 * Die Direktiven sind im einzelnen:
 *    %d    (signed int)
 *    %u    (unsigned int)
 *    %ld   (signed long)
 *    %lu   (unsigned long)
 *    %f    (double)
 *    %s    (char *s, wobei s auf einen String zeigt, der
 *           wiederum eine Zahl enthaelt)
 * Zurueckgegeben wird der groesste Betrag aller Argumente.
 */

double maxabs( const char *s, ... )
{
  double      maximalwert = 0.0,
    wert;
  va_list     argp;
  char       *s2;

  if( s )
  {
    va_start( argp, s );    /* argp am letzten bekann-
                             * ten Argument ausrichten.
                             */
    /* Schleife ueber Direktiven    */
    while( *s )
    {
      if( '%'==*s++ )     /* kommt hier '%'?       */
      {
        switch( *s++ )  /* Welche Direktive? */
        {
          /* Je nach dem Inhalt der
           * Direktive wird
           * ein Argument mit
           * dem jeweiligen Wert
           * aus der Parameterliste
           * geholt:
           */

          case 'd':
            wert = va_arg( argp, int );
            break;

          case 'u':
            wert = va_arg( argp, unsigned );
            break;

          case 'l':
            if( 'd'==*s )
              wert = va_arg( argp, long );
            else if( 'u'==*s )
              wert = va_arg( argp,
                             unsigned long
                             );
            s++;
            break;

          case 'f':
            wert = va_arg( argp, double );
            break;

          case 's':
            wert = strtod( va_arg( argp,
                                   char * ),
                           NULL
                           );
            break;

          default:
            /* Ungueltige Direktiven uebergehen.
             */
            break;
        }

        /* Gegebenenfalls den bisherigen Maximal-
         * wert korrigieren:
         */
        if( wert>maximalwert )
          maximalwert = wert;
        else if( -wert>maximalwert )
          maximalwert = -wert;
      }
    }

    va_end( argp );         /* Auswertung beenden       */
  }  return maximalwert;
}

/* Das Hauptprogramm ruft maxabs() mit verschiedenen Parameter-
 * listen (hinsichtlich Anzahl und Datentypen) auf.
 */
int main()
{
  double w;

  w = maxabs( "%d%d", 123, 25 );
  printf( "w ist %f\n", w );

  w = maxabs( "%lu%s%d", 123ul, "25", -300 );
  printf( "w ist %f\n", w );

  w = maxabs( "%ld%s%d%f", 123ul, "250", -30, 3.141592E3 );
  printf( "w ist %f\n", w );

  return 0;
}

Die Ausgabe dieses Beispiels lautet: 

w ist 123.000000
w ist 300.000000
w ist 3141.592000

\bgroup\color{Red}$\rightarrow$\egroupvprintf(), vsprintf(), vfprintf()


vfprintf() 

#include <stdio.h>

int vfprintf( FILE *datei, const char *format, va_list arglist );

ist identisch mit fprintf(), außer daß die variable Argumentliste nach format ersetzt wird durch einen Parameter vom Typ va_list .

\bgroup\color{Red}$\rightarrow$\egroupva_start/va_arg/va_end(), fprintf()


vsprintf() 

#include <stdio.h>

int vsprintf( char *s, const char *format, va_list arglist );

ist identisch mit sprintf(), außer daß die variable Argumentliste nach format ersetzt wird durch einen Parameter vom Typ va_list .

\bgroup\color{Red}$\rightarrow$\egroupva_start/va_arg/va_end(), sprintf()


vprintf() 

#include <stdio.h>

int vprintf( const char *format, va_list arglist );

ist identisch mit printf(), außer daß die variable Argumentliste nach format ersetzt wird durch einen Parameter vom Typ va_list .

\bgroup\color{Red}$\rightarrow$\egroupva_start/va_arg/va_end(), printf()

next up previous contents
Nächste Seite: A. Tips am Rande Aufwärts: 19 Die Standardbibliothek Vorherige Seite: 19.3 Headerdateien und Überblick   Inhalt
AnyWare@Wachtler.de