math.h
definisce alcune costanti e le seguenti funzioni:
codice:

double acos(double x); 				//arcoseno  0-pi
double asin(double x);          		//arcseno   tra(-pi/2)-pi/2
double atan(double x);				//arctg      tra(-pi/2)-pi/2
double atan2(double y,double x);		//arctg(y/x) -pi e pi
double cabs(struct complex z); //valore assoluto di un numero complesso
double ceil(double x);				//trova l'intero piu'piccolo non < x (arrotonda)
double cos(double x);				//coseno -1 - 1
double cosh(double x);				//coseno iperbolico
double exp(double x);				//e alla x
double fabs(double x);				//valore assoluto di un float
double floor(double x);				//trova l'intero piu'grande non > x(tronca)
double fmod(double x,double y);			//x%y per i float
double frexp(double x,int *exp);		//divide un double in mantissa e esponente
long int labs(long int x);			//valore assoluto di un long
double ldexp(double x,int exp);			//x * 2 alla exp
double log(double x);				//logaritmo in base e
double log10(double x);				//logaritmo in base 10
double modf(double x,double *integer);		//spezza in intero e parte frazionaria
[B]double pow(double x,double y);			[B]//x alla y
double sin(double x);				//seno -1 - 1
double sinh(double x);				//seno iperbolico
double sqrt(double x);				//radice di x
double tan(double x);				//tangente di x sin(x)/cos(x)
double tanh(double x);                          //tangente iperbolica
setjmp.h
dichiara setjmp e longjmp oltre alla struttura jmp_buffer
setjmp setta un salto non locale
longjmp fa il salto non locale
_ESEMPIO_
codice:
#include <stdio.h>
#include <setjmp.h>
#include <stdlib.h>

void sub(jmp_buf);

int main(void)
{

   int value;
   jmp_buf jmp;

   value = setjmp(jmp);
   if (value != 0)
   {
      printf("Longjmp  a==> %d\n", value);
      exit(value);
   }
   printf("chiama la procedura... \n");
   sub(jmp);

   return 0;
}

void sub(jmp_buf jmp)
{
   longjmp(jmp,1);
}
signal.h
dichiara raise e signal oltre ad alcune costanti
void (*signal(int sig, void (*func) (int sig[,int subcode])))(int);
Signal viene innalzato da una eccezione o da raise.


int raise(int sig);
raise manda il segnale sig al programma
se funziona ritorna 0 altrimenti non zero.
se il programma ha installato l'handler del segnale
specificato da sig, l'handler sara' eseguito.
altrimenti si procedera con l'azione tipica

_esempio_
codice:
#include <signal.h>

int main(void)
{
   int a, b;

   a = 10;
   b = 0;
   if (b == 0)
   /* preempt divide by zero error */
      raise(SIGFPE);
   a = a / b;
   return 0;
}
stdarg.h
dichiara alcune macro per sapere quanti parametri sono passati ad una
funzione che accetta un numero variabile di parametri

void va_start(va_list ap, lastfix);
type va_arg(va_list ap, type);
void va_end(va_list ap);

_ESEMPIO_
codice:
void sum(char *msg, ...)
{
   int total = 0;
   va_list ap;
   int arg;
   va_start(ap, msg);
   while ((arg = va_arg(ap,int)) != 0) {
      total += arg;
   }
   printf(msg, total);
   va_end(ap);
}

int main(void) {
   sum("The total of 1+2+3+4 is %d\n", 1,2,3,4,0);
   return 0;
}
stddef.h
dichiara alcune costanti e tipi:
NULL null
ptrdiff_t differenza tra puntatori
size_t tipo per dimensione di oggetti di memoria
wchar_t wide character
stdio.h
oltre alle macro definisce le seguenti funzioni:
void clearerr(FILE *stream);
resetta un errore e l' EOF
codice:
#include <stdio.h>

int main(void)
{
   FILE *fp;
   char ch;

   /* apre un file in lettura */
   fp = fopen("DUMMY.FIL", "w");

   /* si forza un errore tentando di leggere dal file*/
   ch = fgetc(fp);
   printf("%c\n",ch);

   if (ferror(fp))
   {
      /*mostra un errore */
      printf("Error reading from DUMMY.FIL\n");

      /* resetta l'errore e l'EOF  */
      clearerr(fp);
   }

   fclose(fp);
   return 0;
}
int fclose(FILE *stream);
chiude un file torna 0 o EOF per errore.
int feof(FILE *stream);
ritorna non zero se si e' arrivati alla fine del file e 0 altrimenti
int ferror(FILE *stream);
ritorna non zero se si e' verificato un errore
int fflush(FILE *stream);
svuota il buffer nel file torna 0 se successo o EOF
int fgetpos(FILE *stream, fpos_t *pos);
ritorna la posizione nel file
FILE *fopen(const char *filename, const char *mode);
apre il file filename nella modalita' mode(vedi pillola sui file)
size_t fread(void *ptr, size_t size, size_t n, FILE *stream);
legge da un file
_esempio_
codice:
#include <string.h>
#include <stdio.h>

int main(void)
{
   FILE *stream;
   char msg[] = "questo e un test";
   char buf[20];

   if ((stream = fopen("DUMMY.FIL", "w+"))
       == NULL)
   {
      fprintf(stderr, "file non aperto.\n");
      return 1;
   }

   /*scrive nel file*/
   fwrite(msg, strlen(msg)+1, 1, stream);

   /*si sposta all'inizio del file*/
   fseek(stream, SEEK_SET, 0);

   /*legge il dato e lo butta in output */
   fread(buf, strlen(msg)+1, 1, stream);
   printf("%s\n", buf);

   fclose(stream);
   return 0;
}
FILE *freopen(const char *filename, const char *mode, FILE *stream);
chiude il file stream,e riapre cambiandolo con filename nella modalita' mode
int fseek(FILE *stream, long offset, int whence);
sposta il puntatore di lettura/scrittura nel file(vedi pillola file)
int fsetpos(FILE *stream, const fpos_t *pos);
setta la posizione nel file dopo aver resettato l'EOF
long ftell(FILE *stream);
ritorna la posizione del puntatore nel file o -1L
size_t fwrite(const void *ptr, size_t size, size_t n, FILE*stream);
scrive nel file(pillola)
int fgetc(FILE *stream);
ritorna un carattere dal file
int fputc(int c, FILE *stream);
accoda un carattere nel file
int getc(FILE *stream);
legge un carattere da un file (macro)
int getchar(void);
macro che equivale a getc(stdin)
char *gets(char *s);
legge una riga (terminante con \n)da stdin
int putc(int c, FILE *stream);
accoda un carattere a un file(macro)
int putchar(int c);
macro che equivale a putch(c,stdout)
int puts(const char *s);
puts stampa una stringa sullo stdout
int remove(const char *filename);
cancella il file filename
_ESEMPIO_
codice:
#include <stdio.h>

int main(void)
{
   char file[80];

   /* prompt for file name to delete */
   printf("File to delete: ");
   gets(file);

   /* delete the file */
   if (remove(file) == 0)
      printf("Removed %s.\n",file);
   else
      perror("remove");

   return 0;
}
int rename(const char *oldname, const char *newname);
rinomina un file da oldname a newname
void rewind(FILE *stream);
equivale a fseek(*stream,0L,SEEK_SET) solo che cancella anche gli eventuali
errori verificatisi prima
void setbuf(FILE *stream, char *buf);
int setvbuf(FILE *stream, char *buf, int type, size_t size);
setbuf e setvbuf usano un buffer(*buf) per l' I/O ,
anziche' usare lo standard
FILE *tmpfile(void);
crea un file temporaneo.
_esempio_
codice:
#include <stdio.h>
int main(void)
{
   FILE *tempfp;

   tempfp = tmpfile();
   if (tempfp)
      printf("creato file temporaneo\n");
   else
   {
      printf("file temporaneo non creato\n");
      exit(1);
   }

   return 0;
}
char *tmpnam(char *sptr);
crea un nome di file temporaneo
_ESEMPIO_
codice:
int main(void)
{
   char name[13];

   tmpnam(name);
   printf("nome temporaneo ->> %s\n", name);
   return 0;
}
int fprintf (FILE *stream, const char *format [, argument, ...]);
come la printf ma su un file
int fscanf (FILE *stream, const char *format [, address, ...]);
come la scanf ma prende i dati da un file
int printf (const char *format [, argument, ...]);
stampa una stringa formattandola - vedi pillola
int scanf (const char *format [, address, ...]);
legge da un file.
int sprintf (char *buffer, const char *format [, argument, ...]);
come printf ma su una stringa
int sscanf (const char *buffer, const char *format [, address, ...]);
come scanf ma prende da una stringa
int vfprintf(FILE *stream, const char *format, va_list arglist);
come fprintf ma usando una lista di argomenti
_ESEMPIO_
codice:
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

FILE *fp;

int vfpf(char *fmt, ...)
{
   va_list argptr;
   int cnt;

   va_start(argptr, fmt);
   cnt = vfprintf(fp, fmt, argptr);
   va_end(argptr);

   return(cnt);
}

int main(void)
{
   int inumber = 30;
   float fnumber = 90.0;
   char string[4] = "abc";

   fp = tmpfile();
   if (fp == NULL)
   {
      perror("tmpfile() call");
      exit(1);
   }

   vfpf("%d %f %s", inumber, fnumber, string);
   rewind(fp);
   fscanf(fp,"%d %f %s", &inumber, &fnumber, string);
   printf("%d %f %s\n", inumber, fnumber, string);
   fclose(fp);

   return 0;
}
int vprintf (const char *format, va_list arglist);
come printf ma usando una lista di argomenti
_ESEMPIO_
codice:
#include <stdio.h>
#include <stdarg.h>

int vpf(char *fmt, ...)
{
   va_list argptr;
   int cnt;

   va_start(argptr, fmt);
   cnt = vprintf(fmt, argptr);
   va_end(argptr);

   return(cnt);
}

int main(void)
{
   int inumber = 30;
   float fnumber = 90.0;
   char *string = "abc";

   vpf("%d %f %s\n",inumber,fnumber,string);

   return 0;
}
int vsprintf(char *buffer, const char *format, va_list arglist);
come vprintf ma su una stringa
int ungetc(int c, FILE *stream);
fa tornare un carattere nello stream
void perror(const char *s);
stampa l'ultimo errore prodotto in stderr