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
VVoVe: 
