stdlib.h
dichiara alcune costanti(tra cui RAND_MAX e EXIT_SUCCESS) e tipi e
le seguenti funzioni:
void abort(void);
abort scrive nel stderr "Abnormal program termination" quindi chiama exit(3)
int abs(int x);
ritorna il valore assoluto di x
int atexit(atexit_t func);
registra fino a 32 funzioni da eseguire prima di uscire dal programma
le funzioni vengono eseguite dall'ultima inserita alla prima
ritorna 0 in caso di successo o non zero.
_ESEMPIO_
codice:
#include <stdio.h>
#include <stdlib.h>

void f1(void)
{
   printf("funzione 1\n");
}

void f2(void)
{
   printf("funzione 2\n");
}

int main(void)
{
   /* registro la prima funzione */
   atexit(f1);
   /* registro anche la seconda che verra' eseguita prima */
   atexit(f2);
   return 0;
}
double atof(const char *s);
converte una stringa in un double
finche' non incontra un carattere non aspettato se fallisce torna 0
la stringa deve essere in questo formato[spazi] [segno] [decimale] [.] [decimale] [e|E[segno]decimale]
per i perliani dovrebbe essere una cosa tipo:
\s[\+|\-]?[0-9]*\.?([0-9]*)?([e|E][+|-]?[0-9]*)?
int atoi(const char *s);
converte una stringa in un integer
finche' non incontra un carattere non aspettato se fallisce torna 0
la stringa dovrebbe essere in questo formato [spazi] [segno] [decimale]
regex: \s?[\+|\-]?[0-9]*
long atol(const char *s);
converte una stringa in long
finche' non incontra un carattere non aspettato se fallisce torna 0
accetta le stringhe di atoi
void *bsearch(const void *key, const void *base, size_t nelem,size_t width, int (*fcmp)(const void*, const void*));
esegue una ricerca binaria
_esempio_
codice:
 #include <stdlib.h>
 #include <stdio.h>

 typedef int (*fptr)(const void*, const void*);

 #define NELEMS(arr) (sizeof(arr) / sizeof(arr[0]))

 int numarray[] = {123, 145, 512, 627, 800, 933};

 int numeric (const int *p1, const int *p2)
 {
    return(*p1 - *p2);
 }

 #pragma argsused
 int lookup(int key)
 {
    int  *itemptr;

    /* il cast (int(*)(const void *,const void*))
       e' neccessario */
    itemptr = (int *) bsearch (&key, numarray, NELEMS(numarray),
	      sizeof(int), (fptr)numeric);
    return (itemptr != NULL);
 }

 int main(void)
 {
    if (lookup(512))
       printf("512 esiste.\n");
    else
       printf("512 non esiste.\n");

    return 0;
 }
double cabs(struct complex z);
macro che calcola il valore assoluto di un numero complesso
void *calloc(size_t nitems, size_t size);
calloc alloca (nitems * size) bytes settandoli a 0 fino a 64K
div_t div(int numer, int denom);
divide numer per denom e ritorna il quoziente e il resto nella struttura div_t
void exit(int status);
termina un programma con il status assegnato.
double fabs(double x);
calcola il valore assoluto di un double
void free(void *block);
libera la memoria non piu' usata (in c non esiste un garbage collector)
char *getenv(const char *name);
getenv torna il valore di una variabile d' ambiente
char *getenv(const char *name);
torna il valore assoluto di un long
ldiv_t ldiv(long int numer, long int denom);
uguale a div tranne che lavora con i long
void *malloc(size_t size);
malloc alloca size bytes dinamicamente tornando un puntatore all' area
allocata
int mblen(const char *s, size_t n);
determina la lunghezza di un carattere multibyte
int mbtowc(wchar_t *pwc, const char *s, size_t n);
mbtowc converte un multibyte character in wchar_t
size_t mbstowcs(wchar_t *pwcs, const char *s, size_t n);
mbstowcs converte una stringa multibyte in un array di wchar_t
void qsort(void *base, size_t nelem,size_t width, int (*fcmp)(const void *, const void *));
usa l'algoritmo di quick sort
_ESEMPIO_
codice:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int sort_function( const void *a, const void *b);

char list[5][4] = { "cat", "car", "cab", "cap", "can" };

int main(void)
{
   int  x;

   qsort((void *)list, 5, sizeof(list[0]), sort_function);
   for (x = 0; x < 5; x++)
      printf("%s\n", list[x]);
   return 0;
}

int sort_function( const void *a, const void *b)
{
   return( strcmp((char *)a,(char *)b) );
}
int rand(void);
ritorna un numero pseudocasuale compreso tra 0 e RAND_MAX
void *realloc(void *block, size_t size);
rialloca memoria gia' allocata ritornando l'indirizzo della
nuova memoria allocata
void srand(unsigned seed);
inizializza un seme di random
_ESEMPIO_
codice:
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

int main(void)
{
   int i;
   time_t t;

   srand((unsigned) time(&t));
   printf("genera 10 numeri da 1 a 100\n");
   for(i=0; i<10; i++)
       printf("%d\n", rand() % 100 +1);
   return 0;
}
double strtod(const char *s, char **endptr);
converte una stringa in double. accetta le stringhe di atof
long strtol(const char *s, char **endptr, int radix);
converte una stringa in long. accetta le stringhe di atol
unsigned long strtoul(const char *s, char **endptr, int radix);
converte una stringa in unsigned long accetta le stringhe di strol
int system(const char *command);
esegue un comando del sistema operativo -1 se si verifica un errore
size_t wcstombs(char *s, const wchar_t *pwcs, size_t n);
converte la stringa di wchar_t pwcs in una stringa multibyte s
int wctomb(char *s, wchar_t wc);
converte s in un carattere multibyte
string.h
dichiara alcune funzioni per lavorare con le stringhe
per evitare il buffer overflow usare le funzioni strn* anziche str*
void *memchr (const void *s, int c, size_t n);
cerca per n byte il carattere c se lo trova ritorna il puntatore
al carattere altrimenti null
int memcmp (const void *s1, const void *s2, size_t n);
compara i primi n byte di s1 e s2 ritornando
<0 se s1<s2
=0 se s1=s2
>0 se s1>s2
void *memcpy (void *dest, const void *src, size_t n);
copia un blocco di n byte da src a dest se strabocca non si sa cosa succede
void *memmove(void *dest, const void *src, size_t n);
copia un blocco di n byte da src a dest copia correttamente anche se strabocca
void *memset (void *s, int c, size_t n);
setta i primi n byte di s nel carattere c
[b]char *strcat(char *dest, const char *src);[B]
appende una copia di src alla fine di dest e ritorna un puntatore alla
nuova stringa
char *strncat(char *dest, const char *src, size_t maxlen);
appende al massimo maxlen caratteri di src alla fine di dest
char *strchr(const char *s, int c);
cerca un carattere c nella stringa s e torna il puntatore a quel
carattere o null
int strcmp(const char *s1, const char*s2);
compara la stringa s1 a s2 e ritorna come memcmp
int strncmp (const char *s1, const char *s2, size_t maxlen);
compara s1 a s2 ma non piu' di maxlen
int strcoll(char *s1, char *s2);
compara 2 stringhe in base al LOCALE settato
char *strcpy(char *dest, const char *src);
copia src in dest
char *strncpy(char *dest, const char *src, size_t maxlen);
copia al massimo maxlen caratteri di src in dest
size_t strcspn(const char *s1, const char *s2);
trova il primo carattere di s1 che appartiene a s2
char *strerror(int errnum);
restituisce la stringa d' errore che corrisponde al numero
size_t strlen(const char *s);
restituisce la lunghezza di una stringa terminante per \0
char *strpbrk(const char *s1, const char *s2);
cerca una sottostringa di s1 contenente qualsiasi carattere di s2
char *strrchr(const char *s, int c);
come strchr ma fa la scansione a partire dalla fine della stringa
size_t strspn(const char *s1, const char *s2);
trova il primo carattere di s1 che non appartiene a s2
char *strstr(const char *s1, const char *s2);
trova la prima sottostringa s2 in s1
char *strtok(char *s1, const char *s2);
trova il la stringa s1 delimitata dal token,
passando successivamente null al posto di s1 si parsa
tutta la stringa finche' non rimangono piu' token
size_t strxfrm(char *s1, char *s2, size_t n);
trasforma la stringa s1 in s2 per non piu' di n caratteri
time.h
dichiara alcune costanti e le seguenti funzioni:
char *asctime(const struct tm *tblock);
converte la data dalla struttura tm ad ascii
_ESEMPIO_
codice:
#include <stdio.h>
#include <string.h>
#include <time.h>

int main(void)
{
   struct tm t;


   /* carico la struttura tm  */

   t.tm_sec    = 1;  /* Secondi */
   t.tm_min    = 30; /* Minuti */
   t.tm_hour   = 9;  /* Ore */
   t.tm_mday   = 22; /* Giorno  */
   t.tm_mon    = 11; /* Mese */
   t.tm_year   = 56; /* Anno */
   t.tm_wday   = 4;  /* giorno della settimana  */


   printf("%s\n", asctime(&t));

   return 0;
}
clock_t clock(void);
ritorna il numero di cicli del processore da quando il programma e' partito
char *ctime(const time_t *time);
converte il tempo in una stringa
_esempio_
codice:
#include <stdio.h>
#include <time.h>

int main(void)
{
   time_t t;

   time(&t);
   printf("data e ora di oggi: %s\n", ctime(&t));
   return 0;
}
double difftime(time_t time2, time_t time1);
ritorna i secondi trascorsi
struct tm *gmtime(const time_t *timer);
converte la data in GMT
struct tm *localtime(const time_t *timer);
converte la data in una struttura
time_t mktime(struct tm *t);
funzione inversa:da una struttura ad un tempo
size_t _cdecl strftime(char *s, size_t maxsize, const char *fmt,const struct tm *t);
formatta l' output rispetto alla stringa fmt rispettando la tabella
codice:
Spec|Range |Substitution          !Spec|Range |Substitution
----\------/---------------------------\------/--------------------------
 %% |      |Character %           ! %p |      |AM or PM
 %a |      |Abbrev. weekday name  ! %S |00--59|2-digit second (00--59)
 %A |      |Full weekday name     ! %U |00--52|2-digit week number:
 %b |      |Abbrev. month name    !    |      | Sunday = 1st day of week
 %B |      |Full month name       ! %w | 0--6 |Weekday: 0 = Sunday
 %c |      |Date and time         ! %W |00--52|2-digit week number:
 %d |01--31|2-digit day of month  !    |      | Monday = 1st day of week
 %H |00--23|2-digit hour          ! %x |      |Date
 %I |01--12|2-digit hour          ! %X |      |Time
 %j |001-- |3-digit day of year   ! %y |00--99|2-digit year, no century
    |   366|                      ! %Y |      |Year with century
 %m |01--12|2-digit month, decimal! %Z |      |Time zone name, or no
 %M |00-59 |2-digit minute        !    |      | chars if no time zone
time_t time(time_t *timer);
restituisce i secondi passati dal 1o Gennaio 1970