Programmering i ANSI-C/Standardbibliotek

Från Wikibooks
Hoppa till navigering Hoppa till sök
Programmering i ANSI-C

Källkoden|Villkorssatser|Preprocessorn|Kompilatorn|Nyckelord|Standardströmmarna
Filhantering|Felhantering|Programexempel|Standardbibliotek|Tabeller


Standardbibliotek[redigera]

Den här sidan är avsedd att bli en komplett lista på alla i ANSI-C ingående bibliotek med åtminstone dom viktiga funktionerna listade och beskrivna.

Vill man göra det bekvämt för sig så kan man skapa följande lilla huvudfil (*.h) och spara den under lämpligt namn:

/* ANSI.h */

#include <assert.h>
#include <ctype.h>
#include <float.h>
#include <limits.h>
#include <locale.h>
#include <math.h>
#include <setjmp.h>
#include <signal.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

Om filen sedan inkluderas i inledningen av alla ANSI-C program så behöver man inte ange dom bibliotek som skall användas för tillfället utan dom kommer alltid att inkluderas automatiskt. Filen används sedan på följande sätt:

#include "ANSI.h"

int main ( void )
{
    kod
}

Notera att vinkelparenteser "< >" endast används till bibliotek som finns i den mapp som angivits som kompilatorns "include-mapp". Om filen sparats på något annat ställe (till exempel i den aktuella arbetsmappen) så skall dubbla citattecken " " användas i stället och hela sökvägen anges om så krävs för att operativsystemet¹ som brukas av kompilatorn skall hitta rätt fil. (se Preprocessorn -> #include).

¹ Operativsystemet som kompilatorn är skriven för behöver inte vara samma operativsystem som programmet kompileras för, det finns kompilatorer som kan skapa program för flera olika plattformar.

assert.h[redigera]

assert.h innehåller endast ett makro "void assert ( villkor );" som expanderas till ett "if" kommando som, om villkoret inte uppfylls, skriver ut ett standardiserat felmeddelande.

Följande lilla program:

#define TITEL "Test Lib för ANSI-C."
#include <assert.h>

int main ( void )
{
    assert ( 0 == 1 );
    return ( 0 );
}

Ger vid körning följande resultat, (då noll som bekant inte är lika med ett).

Fil:Assert message.jpg

Programmet kommer aldrig att nå till raden där det returnerar utan makrot "assert" anropar en funktion, "abort" som är en genväg ut ur programmet, (används mest vid fel och tester, se "stdlib.h" nedan).

ctype.h[redigera]

ctype.h innehåller funktioner för att testa om tecken är av en viss typ eller inte samt några funktioner för konvertera till andra teckentyper.

Funktioner i ctype.h:

Funktion Beskrivning
int isalnum ( int tecken ); Testar om tecknet tillhör alfabetet eller om det är en siffra.
int isalpha ( int tecken ); Testar om tecknet tillhör alfabetet.
int isascii ( int tecken ); Testar om tecknet är ascii, (0-127).
int iscntrl ( int tecken ); Testar om tecknet är en kontrollkod.
int isdigit ( int tecken ); Testar om tecknet är en siffra.
int isgraph ( int tecken ); Testar om tecknet är en glyf.
int islower ( int tecken ); Testar om tecknet tillhör alfabetet samt att det är gement (liten bokstav).
int isprint ( int tecken ); Testar om tecknet är ett skrivbart tecken.
int ispunkt ( int tecken ); Testar om tecknet är punktueringstecken, punkt, komma och liknande.
int isspace ( int tecken ); Testar om tecknet är ett blanktecken.
int isupper ( int tecken ); Testar om tecknet tillhör alfabetet samt att det är versalt (stor bokstav).
int isxdigit ( int tecken ) Testar om tecknet är en hexadecimal siffra.
int toascii ( int tecken ); Tecknen tvingas till ascii.
int tolower ( int tecken ); Tecknen tvingas till gemener (små bokstäver).
int toupper ( int tecken ); Tecknen tvingas till versaler (stora bokstäver).

Teckentesterna kan användas i olika villkorssatser eller i en switchsats. På sådant sätt kan till exempel en skripttolk enkelt skapas.

Exempel på teckentest:

if ( isalpha ( tecken ) )
    if ( isupper ( tecken ) )
        printf ( "Tecknet är en versal bokstav\n" );
    else
        printf ( "Tecknet är en gemen bokstav\n" );
else
    printf ( "Tecknet är inte en bokstav\n" );

Exemplet visar även att det är möjligt att utelämna klamrarna "{ ... }" i satserna om dom endast innehåller ett ensamt kommando. Här innehåller till exempel den första if-satsen endast ytterligare en if-sats. Den och även else-satserna innehåller sedan endast ett ensamt anrop till funktionen "printf" respektive.

float.h[redigera]

float.h innehåller ett antal predefinierade makron som visar storleken på dom olika flyttalstyperna som kompilatorn använder. Storlekarna på dessa kan variera mellan olika kompilatorer men främst mellan olika plattformar då deras flyttalsprocessorer kan ha olika kapacitet.

Se även: "limits.h" nedan som visar begränsningarna för den aktuella kompilatorns heltalstyper.

Exempel på makron i float.h:

Makro typ Visar
FLT_MAX float Största möjliga belopp i en flyttalsvariabel.
FLT_MIN float Minsta möjliga belopp i en flyttalsvariabel.
DBL_MAX double Största möjliga belopp i en flyttalsvariabel med dubbel precision.
DBL_MIN double Minsta möjliga belopp i en flyttalsvariabel med dubbel precision.
LDBL_MAX long double Största möjliga belopp i en flyttalsvariabel med lång dubbel precision.
LDBL_MIN long double Minsta möjliga belopp i en flyttalsvariabel lång dubbel precision.
FLT_MAX_EXP
FLT_MIN_EXP
FLT_MAX_10_EXP
FLT_MIN_10_EXP
float Anger gränsvärden för exponenter.
DBL_MAX_EXP DBL_MIN_EXP DBL_MAX_10_EXP DBL_MIN_10_EXP double Anger gränsvärden för exponenter.
LDBL_MAX_EXP
LDBL_MIN_EXP
LDBL_MAX_10_EXP
FLT_MIN_10_EXP
LDBL_MIN_10_EXP
long double Anger gränsvärden för exponenter.

Om du vill veta värderna för dessa makron för just den kompilator du använder så är det enklaste sättet att öppna filen "float.h" i en textredigerare och läsa direkt där. Om man vill skriva ett program som fungerar i alla kompilatorer och det är viktigt att veta dessa gränsvärden så kan makrot anvädas i programtexten:

if ( x < sqrt ( DBL_MAX ) )
    x = pow ( x, 2.0 );
else
    printf ( "talet är för stort.\n" );

Om "x" (som är av typen "double") är mindre än roten ur "DBL_MAX", då kommer x att upphöjas till två. Annars visas ett felmedelande. Skulle beräkningen ändå utföras så skulle resultatet inte få plats i variabeln x och ett verkligt fel kommer att inträffa, vilket i värsta fall kan kräva omstart av datorn. Matematikfunktionerna "sqrt" samt "pow" finns definierade i matematikbiblioteket "math.h", (se nedan).

limits.h[redigera]

limits.h innehåller ett antal predefinierade makron som visar storleken på heltalstyperna som den aktuella kompilatorn använder. Storlekarna på dessa kan variera mellan olika kompilatorer men främst mellan olika plattformar då deras processorer kan ha olika ordlängd / bredd på databussen. Äldre 16 bitarskompilatorer använder till exempel ofta en en ordlängd på 16 bitar för typen "int" medan det vanliga idag är 32 bitar, en "short int" är däremot nästan alltid av 16 bitarstyp. Om du vill veta värderna för dessa makron för just den kompilator du använder så är det enklaste sättet att öppna filen "limits.h" i en textredigerare och läsa direkt där.

Se även: "float.h" ovan som visar begränsningarna för den aktuella kompilatorns flyttalstyper.

Makron i limits.h:

Makro typ Visar
CHAR_BIT char Antal bitar i ett tecken (byte), vanligtvis 8.
CHAR_MAX char Största möjliga belopp i ett tecken, oftas 255.
CHAR_MIN char Minsta möjliga belopp i ett tecken, oftas 0.
MB_LEN_MAX Max antal bytes i en multi-char, (UNICODE till exempel).
SCHAR_MAX signed char Största möjliga belopp i ett signerat tecken, oftas 127.
SCHAR_MIN signed char Minsta möjliga belopp i ett signerat tecken, oftas -128.
SHRT_MAX short int Största möjliga belopp i ett signerat kort heltal, oftast 32767.
SHRT_MIN short int Minsta möjliga belopp i ett signerat kort heltal, oftast -32768.
USHRT_MAX unsigned short int Största möjliga belopp i ett osignerat kort heltal, oftast 65535.
INT_MAX int Största möjliga belopp i ett heltal, oftast 32767 men kan även vara 2^31-1.
INT_MIN int Minsta möjliga belopp i ett heltal, oftast -32768 men kan även vara -(2^31).
UINT_MAX unsigned int Största möjliga belopp i ett osignerat heltal, oftast 2^16-1 = 65535 men kan även vara 2^32-1.
LONG_MAX long int Största möjliga belopp i ett långt heltal, oftast 2^31-1.
LONG_MIN long int Minsta möjliga belopp i ett långt heltal, oftast -(2^31).
ULONG_MAX unsigned long int Största möjliga belopp i ett osignerat långt heltal, oftast 2^32-1.
/* Exempel som anger gränsvärden vid inmatning */

long int   heltal;

printf ( "Ange värde (Min:%li, <-> Max:%li); " ,LONG_MIN, LONG_MAX );
scanf ( "%li", &heltal );

Se: "stdio.h" nedan samt standardströmmarna för beskrivning av "printf" samt "scanf".

locale.h[redigera]

locale.h innehåller en funktion, char *setlocale ( int category,const char *locale ); som används för att ändra standarder. Bland annat för vilka tecken som skall tolkas som skrivbara eller inte (svenska åäö till exempel) och liknande, se "ctype.h" ovan. Om komma eller punkt skall användas för flyttal. Format för tid och datum o.s.v. Hur det fungerar beror på den kompilator som används och vilket lands standarder man vill anpassa kategorierna för. Vad heltalet "category" och strängen "locale" skall inehålla beror som nämts på från fall till fall men följande makron skall enligt standarden finnas tillgängliga:

Makron i locale.h:

Makro Kategori
LC_ALL Väljer alla kategorier.
LC_COLLATE Väljer hur textsträngar skall kombineras.
LC_CTYPE Väljer hur olika teckentyper skall tolkas.
LC_MONETARY Väljer hur valuta skall presenteras.
LC_NUMERIC Väljer decimalkomma eller decimalpunkt.
LC_TIME Väljer hur tid och datum skall presenteras.

Makrona innehåller olika bitvärden och kan kombineras med operatorn "|" (OR / ELLER), exempel som definierar de lokala formaten för valuta och tid:

setlocale ( LC_MONETARY | LC_TIME, " datasträng " ); 

LC_ALL sätter alla ingående bitar till 1, vilket betyder att strängen "locale" då skall innehålla data för samtliga kategorier. Strängen "C" skall, om "setlocale" inte anropats i programmet, motsvara systemets standardmiljö.

Se även: Din kompilators dokumentation för en djupare studie i ämnet.

math.h[redigera]

math.h innehåller ett antal matematikfunktioner. Samtliga funktioner ger och tar parametrar av flyttalstypen "double".

Funktioner i math.h:

Funktion Beskrivning
double acos ( double x ); Returnerar arcus cosinus för vinkeln x.
double atan ( double x ); Returnerar arcus tangens för vinkeln x.
double atan2 ( double y, double x ); Returnerar arcus tangens för vinkeln som fås ur divisionen y / x.
double ceil ( double x ); Returnerar x avrundat till närmaste större heltal.
double cos ( double x ); Returnerar cosinus för vinkeln x.
double cosh ( double x ); Returnerar cosinus hyperbolicus för x.
double exp ( double x ); Returnerar talet ex
double fabs ( double x ); Returnerar absolutbeloppet av x, (se "stdlib.h"->"abs" nedan för heltalsversionen av samma funktion).
double floor ( double x ); Returnerar x avrundat till närmaste mindre heltal.
double fmod ( double x, double y ); Returnerar rest vid heltalsdivisionen x / y där y alltid är ett heltal, (modulus).
double frexp ( double x, int *pexp ); Delar ett tal i mantissa och exponent. Returvärdet är mantissan och exponenten returneras i den variabel av typen int som pekaren "*pexp", som skickas med till funktionen, representerar.
double ldexp ( double x, int exp ); Returnerar x · 2exp.
double log ( double x ); Returnerar den naturliga logaritmen av x, (talbasen e).
double log10 ( double x ); Returnerar 10-logaritmen av x, (talbasen 10).
double modf (double x, double *pint ); Delar ett tal i heltalsdel och decimaldel. Returvärdet är decimaldelen och heltalet returneras i den variabel av typen double som pekaren "*pint", som skickas med till funktionen, representerar.
double pow (double x, double y ); Returnerar x upphöjt till y, (x in the power of y, x i kraften av y, y-potensen av x).
double sin (double x ); Returnerar sinus för vinkeln x.
double sinh (double x ); Returnerar sinus hyperbolicus för x
double sqrt (double x ); Returnerar kvadratroten ur x.
double tan (double x ); Returnerar tangens för vinkeln x.
double tanh (double x ); Returnerar tangens hyperbolicus för x

Samtliga trigonometriska funktioner (sin, cos, tan o.s.v.) tar sina argument (vinklar) uttryckt i radianer.

setjmp.h[redigera]

setjmp.h innehåller två funktioner som tillsammans skapar en ickelokal "goto" instruktion.

Funktioner i setjmp.h:

Funktion Beskrivning
void longjmp ( jmp_buf env, int retval ); Utför en icke-lokal goto intsruktion.
int setjmp ( jmp_buf env ); Skapar en virtuell hoppadress (label).

"setjump" markerar platsen i koden man vill återvända till, ungefär som en hoppadress (label) eller ett radnummer. Sedan används "longjump" för att återvända till den senast markerade platsen i koden. På det sättet kan funktioner fås att returnera till valfri plats i andra funktioner.

signal.h[redigera]

signal.h anger två funktioner för att hantera avbrottssignaler. Hur dessa signaler hanteras är starkt knutet till den aktuella hårdvaran och kan alltså därför även variera under ett och samma operativsystem. Det medför att signalhanteringen är den minst portabla delen av ANSI-C.

Funktioner i signal.h:

Funktion Beskrivning
int raise ( int avbrott ); Skickar en signal till omgivningen. Heltalet "avbrott" innehåller signalens ID-nummer.
void ( *signal ( int avbrott, void ( *funktion ) ( int avbrott ) ) ) ( int ); Installerar en funktion för avbrottshantering.

För att installera en signalhanterare skapas först en funktion som hanterar signalavbrottet. Funktionen skall ta en heltalsparameter = "avbrott" som är signalens ID-nummer. Sedan installeras signalhanteraren med funktionen "signal". Då anges signalhanterarens adress med pekaren "*funktion". Funktionen "raise" används för att tvinga fram ett avbrott. Då skickas det valda avbrottets ID-nummer med i heltalsparametern "avbrott".

/* Exempel som installerar en [Ctrl]-[Break] hanterare: /*

#include <signal.h>

/* Först skapas avbrottshanteraren: */
void Ctrl_break_avbrott ( int avbrott )
{
    kod som hanterar avbrottet.
}

/* Sedan installeras funktionen: */
signal ( SIGBREAK, Ctrl_break_avbrott );

I exemplet ovan anges signalens ID-nummer med ett av de predefinierade makron som finns i "signal.h". Dessa makron används för att hantera standardavbrott som till exempel [Ctrl]-[C].

Makron i signal.h:

Makro Avbrott
SIGABRT Abnormal termination, (abnormalt programslut).
SIGFPE Bad floating-point operation, (ogiltig flyttalsoperation).
SIGILL Illegal instruction, (ogiltig instruktion).
SIGINT Ctrl-C interrupt, (Ctrl - C avbrott).
SIGSEGV Invalid access to storage, (Ogiltigt försök till minnesåtkomst).
SIGTERM Request for program termination, (Begäran att avsluta programmet).
SIGUSR1 User-defined signal, (Användardefinierad avbrottsignal 1).
SIGUSR2 User-defined signal, (Användardefinierad avbrottsignal 2).
SIGUSR3 User-defined signal, (Användardefinierad avbrottsignal 3).
SIGBREAK Ctrl-Break interrupt, (Ctrl - Break avbrott).

stdarg.h[redigera]

stdarg.h innehåller tre makron och en datatyp. "stdarg.h" skapar möjligheten att skicka ett variabelt antal parametrar till en funktion.

Makron i stdarg.h:

Makro Funktion
va_start( listpekare, parameter_n ) Sätter pekaren "listpekare" att peka på argumentet efter "parameter_n".
va_arg( listpekare, typ ) Hämtar ett argument av "typ" från listan och sätter pekaren "listpekare" att peka på nästa argument.
va_end( listpekare ) Återställer.

Datatypen som deklareras i "stdarg.h", "va_list" är en pekartyp som används för att hitta listan med dom medskickade parametrarna. Det görs med hjälp av makrona ovan. "va_start" sätter pekaren till att peka på den parameter som ligger näst efter "parameter_n" som är den parameter som är sista deklarerade parameter i parameterlistan för den aktuella funktionen. Sedan hämtas parametrarna en efter en med hjälp av makrot "va_arg". Efter att listan tömts på parametrar så anropas "va_end" för att "städa upp".

/* Exempel: */

#include <stdarg.h>

/* Funktionen deklareras: */
int En_massa_args ( int param_0, int parameter_n, ... )
{
    va_list listpekare;    /* skapa pekarvariabel */

    /* Töm parameterlistan: */
    va_start ( listpekare, parameter_n );
    variabel av någon datatyp = va_arg ( listpekare, datatyp );
    ...
    variabel av någon datatyp = va_arg ( listpekare, datatyp );
    va_end ( listpekare );

    Funktionens övriga programkod.
}

Notera att det variabla antalet parametrar markeras med en ellips (tre punkter, ... ) och att det är viktigt att dom parametrar som deklarerats samt skickas med till funktionen håller reda på antalet argument som skickas med och även deras typer för det kan inte kompilatorn göra.

I dom allra flesta fall kan en funktion med ett variabelt antal patrametrar ersättas med en funktion som tar en pekare till en "struct" eller någon annan typ av datalista.

stddef.h[redigera]

stddef.h innehåller en funktion samt definierar några datatyper.

Funktionen i stddef.h:

Funktion Beskrivning
size_t offsetof ( struct, medlem ); Returnerar index i "struct" för "medlem" i antal objekt av storleken "size_t". (Definieras även i "stdio.h" om det inte redan gorts tidigare.)

Datatyper i stddef.h:

Datatyp Funktion
size_t Anger storleken på ett standardobjekt, vanligtvis av samma storlek som typen unsigned int.
NULL Nollpekare av typen void.
ptrdiff_t Typ för att ange storleken på skillnaden som uppstår när en pekare dras från en annan pekare.

stdio.h[redigera]

stdio.h är det viktigaste och mest omfattande av standardbiblioteken. stdio.h innehåller funktioner, makron, datatyper samt konstanter för att handha programmets kommunikation med omgivningen, så kallad I/O (av engelskans input/output). Denna kommunikation görs med hjälp av dataströmmar (streams). Om ingen specifik ström angetts så brukas standardströmmarna. Hårdvara som kan tilldelas strömmar är till exempel comportar, tangentbord, skärmar, skrivare, plotters samt filer i långtidsminne som disketter eller hårddiskar.

Standardströmmar i stdio.h:

Ström Beskrivning
stdin Ström för inmatning av data, normalt datorns tangentbord.
stdout Ström för utmatning av data, normalt datorns skärm.
stderr Ström för felmeddelanden, normalt som utskrift på skärmen.
stdaux Ström för extern enhet.
stdprn Standardström för printer.

För att använda strömmarna finns ett antal funktioner definierade i biblioteket.

Funktioner i stdio.h:

Funktion Beskrivning
void clearerr ( FILE *ström ); Nollställer strömmens felindikator vilket måste göras om strömmen gett ett felmedelande annars kommer felet att kvarstå. Nollställer även "EOF" indikatorn för strömmen. Funktionen är ekvivalent med "rewind".
int fclose ( FILE *ström ); Stänger en öppen fil. Returvärdet är 0, (noll), om allt gått väl annars returneras värdet "EOF" som felindikator. Se filhanternig för en närmare beskrivning.
int fcloseall ( void ); Stänger alla öppna filer. Returvärdet är ett heltal som anger antalet stängda filer. Om något fel uppstått returneras värdet "EOF" som indikator. Se filhanternig för en närmare beskrivning.
int feof ( FILE *ström ); Filslutsdetektor. Returnerar noll om slutet på filen ännu inte nåtts annars ett värde skilt från noll.
int ferror ( FILE *ström ); Filfelsdetektor. Testar om en fil har läs eller skrivfel, returvärdet är då sklilt från noll, annars inte.
int fflush ( FILE *ström ); Tömmer buffrad fil till "*ström". Har ingen effekt om buffers inte används. Returnerar "EOF" om något fel uppstod, annars noll.
int fgetc ( FILE *ström ); Hämtar nästa tecken från filen. Om slutet på filen nåtts eller om något fel uppstått returneras "EOF" annars tecknet från strömmen.
int fgetpos ( FILE *ström, fpos_t *position ); Samplar aktuell position i filen och sparar värdet i den minescell av typen "fpos_t" som pekaren "*position" anger. Värdet kan sedan användas för att återställa positionen med funktionen "fsetpos", (se nedan).
char *gets ( char *sträng ); Hämtar en sträng från strömmen "stdin" (tangentbordet) och sparar den i minnesblocket som pekaren "*sträng" anger, (som måste vara tillräckligt stort för att rymma hela strängen). Strängen skall avslutas med ett vagnreturstecken (return), det ersätts vid sparningen med ett nolltecken \0 som är det normala sättet att ange radslut i C. Se standardströmmarna för en närmare beskrivning.
FILE *fopen ( const char *filnamn, const char *mod ); Öppnar en fil för läsning eller skrivning. Se filhanternig för en närmare beskrivning.
int fprintf ( FILE *ström, const char *format[, argument, ...] ); Skriver formaterad text till den givna strömmen. Se även: "printf", "sprinf" (nedan).
int fputc ( int tecken, FILE *ström ); Skriver ett tecken till den angivna strömmen. Returnerar "EOF" om ett fel uppstått annars noll.
int fputs( const char *sträng, FILE *ström ); Skriver en sträng till strömmen. "*sträng" är en pekare till texten som skall skrivas. Returnerar "EOF" om ett fel uppstått annars noll.
size_t fread ( void *pekare, size_t storlek, size_t antal, FILE *ström ); Läser från en öppen fil. Se filhanternig för en närmare beskrivning.
FILE *freopen ( const char *filnamn, const char *mod, FILE *ström ); Öppnar en ny fil för den aktuella strömmen. Se filhanternig för en närmare beskrivning.
int fscanf ( FILE *ström, const char *format[, variabelpekare, ...] ); Läser in och formaterar text från en öppen fil. Se även: "scanf", "sscanf" (nedan).
int fseek ( FILE *ström, long index, int varifrån ); Sätter filpekaren "ström" till ny position. "varifrån" (whence) anger utgångsläget. Värden för dessa anges av makrona: SEEK_SET = filens start, SEEK_CUR = nuvarande position, SEEK_END = slutet på filen. "index" anger positionen relativt "varifrån" och kan alltså vara både ett positivt eller ett negativt värde.
int fsetpos ( FILE *ström, const fpos_t *position ); Återställer den tidigare positionen som samplats med funktionen "fgetpos" ovan.
long int ftell ( FILE *ström ); Returnerar nuvarande position i filen "ström" i antal bytes från filens start.
size_t fwrite ( const void *pekare, size_tstorlek, size_t antal, FILE *ström ); Skriver tilll en öppen fil. Se filhanternig för en närmare beskrivning.
int getc ( FILE *ström ); Läser ett tecken från strömmen och sätter strömmens filpekare att peka på nästa objekt. Funktionen returnerar det lästa tecknet om inte ett fel uppstått eller slutet på filen nåtts, då returneras "EOF".
int getchar ( void ); Läser ett tecken från "stdin" (tangentbordet). Funktionen är ekvivalent med "getc ( stdin )", (se ovan). Se standardströmmarna för en närmare beskrivning.
char *gets ( char *sträng ); Läser en sträng från "stdin" och placerar texten i minnesblocket som anges av pekaren "*sträng". Funktionen returnerar "EOF" om ett fel uppstått eller slutet på filen nåtts. Se standardströmmarna för en närmare beskrivning.
void perror ( const char *sträng ); Skriver en sträng till felmeddelandeströmmen "stderr". Se felhantering för en närmare beskrivning.
int printf ( const char *format[, argument, ...] ); Skriver formaterad text till "stdout". Se standardströmmarna för en närmare beskrivning. Se även: "fprintf", "sprintf".
int putc ( int tecken, FILE *ström ); Skriver ett tecken till den angivna strömmen. Se filhanternig för en närmare beskrivning.
int putchar ( int tecken ); Skriver ett tecken till "stdout". Se standardströmmarna för en närmare beskrivning.
int puts ( const char *sträng ); Skriver strängkonstanter till "stdio". Se standardströmmarna för en närmare beskrivning.
int rename ( const char *tidigare, const char *nytt ); Döper om en fil. "*tidigare" är en pekare till en sträng som innehåller sökvägen till filen. "*nytt" är en pekare till det nya filnamnet.
int remove ( const char *filnam ); Raderar en fil från lagringsmediet (normalt hårddisken). "*filnamn" är en pekare till en sträng som innehåller sökvägen för aktuell fil.
void rewind ( FILE *ström ); Se "clearerr" ovan.
int rmtmp ( void ); Stänger och raderar alla filer som skapats med "tmpfile" (se nedan) Arbetsmappen får inte ha ändrats under tiden, då hittar inte programmet filerna. Returvärdet är det antal filer som stängts och raderats.
int scanf ( const char *format[, variabelpekare, ...] ); Läser in och formaterar data från "stdin". Se standardströmmarna för en närmare beskrivning. Se även: "fscanf", "sscanf"
void setbuf ( FILE *ström, char *buffer ); Tilldelar en filbuffer "*buffer" till "*ström". Det skall göras direkt efter det att filen öppnats. Används NULL-pekaren så blir strömmen obuffrad. Storleken på buffern bestäms av makrot "BUFSIZ" (definierad i "stdio.h").
int setvbuf ( FILE *ström, char *buffer, int typ, size_t storlek ); Som "setbuf" ovan med skillnaderna att här kan bufferns "storlek" anges och skall vara större än noll och mindre än makrot "UINT_MAX". Bufferns "typ" anges med något av följande makron: "_IOFBF" helbuffrad, "_IOLBF" linjärt buffrad, "_IONBF" obuffrad fil.
int sprintf ( char *sträng, const char *format[, parametrar, ...] ); Skriver formaterad text till "*sträng" som är en textbuffert. Se även "printf", "fprintf".
int sscanf ( const char *sträng, const char *format[, variabelpekare, ...] ); Hämtar formaterad data i textformat från "*sträng" och typomvandlar dessa till ett binärt format som sedan sparas som variabler i minnet. Se även "scanf", "fscanf".
char *strerror( int felkod ) Returnerar en pekare till en temporär strängbuffert som innehåller ett felmeddelande. Vid anropet anges felkoden som parameter till funktionen. Vid upprepade anrop brukas samma temporära buffert varje gång och den tidigare texten i bufferten kommer då att skrivas över.
char *strncpy ( char *mål , const char *källa , size_t antal ); Kopierar en textsträng, "*källa", till en annan sträng, "*mål". Hur många tecken som skall kopieras anges med parametern "antal". Om "*källa" är längere än "antal" så klipps slutet av och om den är kortare kommer utrymmet fyllas med blanktecken (space). Returvärdet är en kopia av pekaren "*mål".
FILE *tmpfile ( void ); Skapar och öppnar en temporär binärfil för skrivning och sedan även för läsning, (om något skrivits till filen). Returvärdet är den öppnade strömmen. Ändras inte programmets arbetsmapp efter det att filen skapats så raderas den automatiskt vid programslut. Se filhantering för detaljer om filer.
char *tmpnam ( char *sträng ); Skapar ett unikt temporärt filnamn till en temporär fil. Parametern "*sträng" kan vara NULL-pekaren, då returneras en pekare till en temporär strängbuffert som innehåller filnamnet. Annars skall "*sträng" vara en pekare till en buffert. Den globala variabeln "L_tmpnam" anger minsta antalet tecken som bufferten måste innehålla. Hur många olika filnamn som kan skapas anges med makrot "TMP_MAX".
int vfprintf (FILE *ström, const char *format, va_list argumentlista ); Skriver formaterad text till "*ström". Fungerar som "fprintf" med den skillnaden att funktionen tar en pekare till en "argumentlista".
int vprintf ( const char *format, va_list argumentlista ); Skriver formaterad text till "stdout". Fungerar som "printf" med den skillnaden att funktionen tar en pekare till en "argumentlista".
int vsprintf ( char *sträng, const char *format, va_list argumentlista ); Skriver formaterad text till "*sträng". Fungerar som "sprintf" med den skillnaden att funktionen tar en pekare till en "argumentlista".
int ungetc ( int tecken, FILE *ström ); Returnerar ett "tecken" till "*ström" som är öppnad för läsning. Tecknet kan sedan återhämtas från strömmen. Funktionen ändrar inte positionen i strömmen och därför kan endast ett tecken skriva tillbaka. Upprepas skrivningen med flera tecken utan att någon läsning förekommt mellan anropen så skrivs det tidigare tecknet över.

Många av funktionerna ovan använder datatyper som som skapats med nyckelordet typedef för att programmen skall vara flyttbara mellan olika plattformar. Det för att olika datorsystem använder olika metoder för att till exempel hantera filer. Hur dessa typer egentligen ser ut är ointressant för oss, huvudsaken är att funktionerna som använder typerna ger samma resultat oavsett vilken kompilator som används.

Datatyper i stdio.h:

Datatyp Beskrivning
FILE En struct som innehåller dom variabler som krävs för att hantera läsning och skrivning till och från en ström.
fpos_t Anger aktuell position i en ström.
size_t En heltalstyp som används av operatorn sizeof för att ange storlekar på dataobjekt, (se nyckelord). (Definieras även i "stddef.h" om det inte redan gorts tidigare.)

Därtill finns det även ett antal makron i "stdio.h". Dessa makron används bland annat för att ange olika maxvärden och liknande:

Makron i stdio.h:

Makro Beskrivning
BUFSIZ Anger storleken på filbufferten om en ström använder buffrad filhantering. Storleken kan ändras med funktionen "setbuf", (se ovan).
EOF Konstant som motsvarar tecknet som anger filslut, end of file. Brukas som felindikator av många funktioner, (se felhantering).
FOPEN_MAX Anger det maximala antalet filer som den aktuella processen kan hålla öppna samtidigt.
NULL Anger nollpekaren. En nollpekare används som 'dummypekare' eller 'tom adress'. Många funktioner tar pekare till datablock som inte alltid behövs, då anges nollpekaren i stället. Funktionen 'förstår' då att några data inte finns att hämta på adressen.
SEEK_SET Se beskrivningen för funktionen "fseek" ovan.
SEEK_CUR Se beskrivningen för funktionen "fseek" ovan.
SEEK_END Se beskrivningen för funktionen "fseek" ovan.
SYS_OPEN Anger det maximala antalet filer som datorsystemet kan hålla öppna samtidigt.
TMP_MAX Anger det maximala antalet unika filnamn som kan skapas av funktionen "tmpnam", (Se ovan).

stdlib.h[redigera]

Funktioner i stdlib.h:

Funktion Beskrivning
void abort ( void ); Avbryter programmet omedelbart. Används normalt om ett fel uppstått och programmet inte kan fortsätta längre. (Se exempel under felhantering).
int abs ( int heltal ); Returnerar absolutbeloppet av "heltal". Motsvarande funktion för långa heltal är "labs" (nedan) och för flyttal, "fabs", finns i "math.h". (Se ovan).
int atexit ( void ( _USERENTRY * funktion ) ( void ) ); Anger den funktion som skall anropas om "exit" (se nedan) används som programslutsfunktion. Parametern till "atexit" är namnet på den funktion som skall användas. Vid upprepade anrop kan flera funktioner anges, då kommer den sist angivna vara den som utförs först och sedan den näst senaste o.s.v. Max 32 funktioner kan anges.
double atof ( const char *sträng ); Konverterar "*sträng" till ett flyttal. Returparametern är det konverterade talet om det inte är för stort för att rymmas i variabeln, då returneras "HUGE_VAL" som felindikator och den globala variabeln "errno" sätts till "ERANGE".
int atoi ( const char *sträng ); Konverterar "*sträng" till ett heltal. Returparametern är det konverterade talet. Om funktionen inte kan konvertera till strängen till något heltal så returneras noll (0).
long atol ( const char *sträng ); Konverterar "*sträng" till ett långt heltal. Returparametern är det konverterade talet. Om funktionen inte kan konvertera till strängen till något heltal så returneras noll (0).
void *bsearch ( const void *mask, const void *bas, size_t n_element, size_t storlek, int ( _USERENTRY *jämförelse ) ( const void *, const void *)); Söker av ett minnesblock, "*bas", bestående av "n_element" där elementen är "storlek" bytes. Reutnerar adressen till den första förekomsten av innehållet i konstanten som "*mask" pekar på. "*jämförelse" är en adress till en användardefinierad funktion som utför jämförelsen. Den måste definieras så att den tar pekare till dom två element som skall jämföras. Funktionen skall returnera ett tal mindre än 0 om element_1 < element_2, 0 om element_1 == element_2, större än 0 om element_1 > element_2.
void *calloc ( size_t antal, size_t storlek ); Allokerar "antal" objekt av "storlek" bytes minnesceller. Funktionen returnerar en pekare till det begärda minnesblocket om det gått väl annars returneras "NULL". (se även "*malloc" nedan.)
div_t div ( int täljare, int nämnare ); Dividerar två heltal "täljare" / "nämnare" och returnerar både kvot och rest i en för ändamålet avsedd datatyp "div_t", (som är en struct innehållandes två heltal "quot" och "rem", se nedan).
void exit ( int status ); Avslutar programmet. Innan avslut töms alla filbuffertar till dom öppna strömmarna och filerna stängs (om några öppnats). Om några funktioner listats med funktionen "atexit", (se ovan), så anropas även dom. "status" kan vara noll eller makrot "EXIT_SUCCESS" vid normalslut, ett värde skilt från noll eller makrot "EXIT_FAILURE" om man vill markera att ett fel uppstått.
void free ( void *minnesblock ); Återlämnar tidigare allokerat minne till systemet. Parametern "*minnesblock" är den pekare som erhölls när mninnet allokerades med antingen "malloc" (nedan) eller "calloc" (ovan).
char *getenv ( const char *namn ); Söker eller raderar en av systemets miljövariabel. "*namn" är en pekare till en nollterminerad ("\0") sträng. Om variabeln skall raderas så läggse ett likamedtecken till slutet av namnet, ex: "pekare = getenv ( "PATH\0" );" söker strängen och "pekare = getenv ( "PATH=\0" );" raderar strängen. Returparameter är en pekare till den sökta strängen. Om strängen inte hittas returneras "NULL"-pekaren.
char *itoa ( int belopp, char *sträng, int bas ); Skapar en "*sträng" från ett heltal "belopp" i talbasen "bas" som kan vara mellan 2 och 36. Anges basen med ett negativt nummer så sätts den automatiskt till 10. Reurvärdet är = "*sträng".
long int labs ( long int heltal ); Returnerar absolutbeloppet av "heltal". Motsvarande funktion för korta heltal är "abs" (ovan) och för flyttal, "fabs", finns i "math.h". (Se ovan).
void *malloc ( size_t storlek ); Allokerar ett minnesblock om "storlek" bytes. Returvärdet är en pekare till det begärda minnet. Om inte tillräckligt med minne finns tillgängligt returneras "NULL"-pekaren. (Se även "*calloc" ovan)
int mblen ( const char *sträng, size_t antal ); Beräknar längden på ett multi-byte tecken som finns i minnesblocket "*sträng" pekar på. "antal" anger det maximala antalet bytes som skall sökas av. Om längden på strängen inte är noll returneras noll (0) annars -1.
size_t mbstowcs ( wchar_t *variabellista, const char *sträng, size_t antal ); Konverterar "antal" multi-byte tecken i "*sträng" till en indexerad "*variabellista". Returvärdet är antalet konverterade tecken eller -1 om inga tecken kunde hittas.
int mbtowc ( wchar_t *minnesblock, const char *sträng, size_t antal ); Konverterar "antal" multi-byte tecken i "*sträng" till datatypen "wchar_t" och sparar dess i "*minnesblock". Returvärdet är antalet konverterade tecken eller -1 om inga tecken kunde hittas.
void qsort ( void *bas, size_t n_element, size_t storlek, int ( _USERENTRY *jämförelse ) ( const void *, const void *)); Sorterar en lista "*bas" om "n_element" av "strolek" bytaes med 'quick-sort' metoden. Hur den användardefinierade "*jämförelse" funktionen skall definieras beskrivs under "*bsearch" ovan.
int rand ( void ); Slumtalsgenerator. Returnerar ett slumtal i intervallet 0 - "RAND_MAX", som är ett makro, (se nedan).
void *realloc ( void *minnesblock, size_t storlek); Återallokerar ett tidigare allokerat "*minnesblock". Funktionen kan användas om utrymmet behöver minskas eller förstoras till ny "storlek". Se även "*calloc" och "*malloc" ovan.
void srand ( unsigned int frö ); Initierar slumtalsgeneratorn "rand" (ovan). "frö" är det första talet i den nya serien av slumtal.
double strtod ( const char *sträng, char **slutpekare ); Omvandral en "*sträng" till ett flyttal med dubbel precission. Om "**slutpekare" inte är NULL-pekaren så returneras positionen efter det sista tecknet i strängen som kunde omvandlas i den angivna pekaren.
long int strtol( const char *sträng, char **slutpekare, int talbas ); Konverterar ett tal i textformat som lagrats i "*sträng" till ett långt heltal. Om "**slutpekare" inte är NULL-pekaren så returneras positionen efter det sista tecknet i strängen som kunde omvandlas i den angivna pekaren. "talbas" är basen för talsystemt som talet i strängen innehåller och kan vara allt mellan 2 och 36, tecknen som används för att representera talen är 0-9, A-Z.
unsigened long int strtoul( const char *sträng, char **slutpekare, int talbas ); Som ovan "strtol" med skillnaden att här används endast positiva heltal.
time_t time ( time_t *timer ); Returnerar antalet sekunder som passerat sedan den 1 januari år 1970. Om "*timer" inte är NULL-pekaren så sparas värdet även i den angivna variabeln av typen "t_time", (se datatyper i "stdlib.h" nedan)
size_t wcstombs ( char *sträng, const wchar_t *multisträng, size_t antal ); Konverterar en sträng multi-byte tecken "*multisträng" till en "*sträng" 8-bitarstecken. "antal" anger det maximala antalet tecken som skall konverteras. Funktionen returnerar -1 som felkod om ett ogiltigt tecken påträffats annars antalet konverterade tecken.
int wctomb ( char *sträng, wchar_t multitecken ); Konverterar ett multi-byte tecken "multitecken"till en "*sträng" 8-bitarstecken. Om funktionen misslyckas med att hitta något giltigt tecken i "multitecken" returneras -1 som felkod annars antalet 8-bitarstecken som krävdes för att representera tecknet som en "*sträng".

"stdlib.h" innehåller även ett antal datatyper som används för att ange olika objekt som inte passar i någon av standardtyperna. Typerna skapas i huvudfilen med hjälp av nyckelordet typedef.

Datatyper i stdlib.h:

Datatyp Beskrivning
div_t Datatyp som är en struct innehållades två medlemmar, "quot" och "rem" som motsvarar kvot och rest vid division av två heltal. Anväds av funktionen "div", (se ovan).
size_t En heltalstyp som används av operatorn sizeof för att ange storlekar på dataobjekt, (se nyckelord). (Definieras även i "stdio.h" om det inte redan gorts tidigare.)
wchar_t Datatyp för multi-byte tecken. Används av funktionerna "mbstowcs", "wcstombs", "wctomb", (se ovan).

Makron i stdlib.h:

Makro Beskrivning
EXIT_FAILURE Används som parameter till funktionen "exit" och anger då att ett fel uppstått.
EXIT_SUCCESS Används som parameter till funktionen "exit" och anger då normalslut.
RAND_MAX Anger det maximala beloppet som returneras av funktionen "rand".

RAND_MAX kan användas i ett nytt makro för att skapa ett slumptal mellan 0 och 1 på flyttalsformat på samma sätt som till exempel i BASIC. Exempel:

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

#define RND ( ( float ) rand ( ) / RAND_MAX )

int main( void )
{
    float ett_slumptal;      /* skapa flyttalsvariabel */

    ett_slumptal = RND;      /* sätt variabeln till ett värde mellan 0,0 <-> 1,0 */

    printf( "%f", ett_slumptal );
    return 0;
}

string.h[redigera]

time.h[redigera]