Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 14
  1. #1

    [Pillola][C] i 15 header standard ANSI

    L'altro giorno navigando su goooooogle mi sono
    accorto che spesso e volentieri mi serviva cercare una funzione simile a quella
    che uso io perche' essa non e' standard..
    cosi' ho deciso di creare una pillola REFERENCE per coloro
    che cercano una determinata funzione.
    per far cio' elenco ,con breve descrizione e ,a volte
    qualche esempio, tutte le funzioni standard.
    Per creare questa pillola ho utilizzato 2 pc un 486 con
    turboc e un p133 con gcc per testare l'effettiva usabilita' dei codici.
    inoltre ho preso spunto un po' da:
    codice:
    referenze:
    imparare il c - una guida per linux di Marco Latini e Paolo Lulli
    Gapil - Guida alla programmazione in Linux di Simone Piccardi
    help di turbo pascal( soprattutto per gli esempi )
    manpages

  2. #2

    i 15 header standard definiti dall' ansi:

    codice:
    1)	assert.h
    2)	ctype.h
    3)	errno.h
    4)	float.h
    5)	limits.h
    6)	locale.h
    7)	math.h
    8)	setjmp.h
    9)	signal.h
    10)	stdarg.h
    11)	stddef.h
    12)	stdio.h
    13)	stdlib.h
    14)	string.h
    15)	time.h

  3. #3

    assert.h
    contiene la macro assert
    codice:
    void assert(int espressione)
    
    assert e' una macro che fa' questa cosa:
    
    assert(test)
    if (test==0){
    	fprintf(stderr,"assertion failed: test,file:nomefile, line:linea");
    	abort();
    }
    se l'espressione e' falsa stampa in stderr un errore e interrompe il programma

    type.h
    definisce alcune macro che tornano 0 se falso o non-zero se vero

    • int isalnum(int c);
    • int islower(int c);
    • int isalpha(int c);
    • int isprint(int c);
    • int ispunct(int c);
    • int iscntrl(int c);
    • int isspace(int c);
    • int isdigit(int c);
    • int isupper(int c);
    • int isgraph(int c);
    • int isxdigit(int c);


    is..(int c) controlla:
    • isalpha: c e' una lettera ('A'-'Z' o 'a'-'z')
    • iscntrl: c e' un carattere di controllo o di cancellazione(0x7F o 0x00-0x1F)
    • isdigit: c e' un cifra ('0'-'9')
    • isgraph: c e' un carattere stampabile, come isprint ma escludendo lo spazio (' ')
    • islower: c e' in minuscolo ('a'-'z')
    • isprint: c e' un carattere stampabile (0x20-0x7E)
    • ispunct: c e' un carattere punctuation(iscntrl o isspace)
    • isspace: c e' spazio, tab, carriage return, invio, vertical tab, o formfeed (0x09-0x0D, 0x20)
    • isupper: c e' maiuscolo ('A'-'Z')
    • isxdigit: c e' una cifra esadecimale ('0'-'9','A'-'F','a'-'f')

    errno.h
    contiene la definizione di alcune costanti e della variabile
    errno che all inizio del programma e 0 e cambia se si verifica
    un errore durante il programma.
    float.h
    definisce valori estremi dei float
    limits.h
    contiene e definisce le caratteristiche (massimi e minimi dei tipi di dato)
    tra cui:
    codice:
    CHAR_BIT    CHAR_MAX    CHAR_MIN    INT_MAX     INT_MIN     LONG_MAX
    LONG_MIN    SCHAR_MAX   SCHAR_MIN   SHRT_MAX    SHRT_MIN    UCHAR_MAX
    UINT_MAX    ULONG_MAX   USHRT_MAX
    locale.h
    contiene le funzioni localeconv che ritorna un puntatore alla struttura
    locale corrente o null se fallisce e setlocale che permette di selezionare
    un locale che permettono di selezionare i formati numerici nazionali
    diversi(monete,data..)
    • struct lconv *localeconv(void);
    • char *setlocale(int category, char *locale);

    setlocale torna una stringa con il locale precedente.

    codice:
    argomenti possibili per *locale:
      *) LC_ALL        *) LC_COLLATE
      *) LC_CTYPE      *) LC_MONETARY
      *) LC_NUMERIC    *) LC_TIME

  4. #4

    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

  5. #5
    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

  6. #6
    finito.
    spero di non aver sparato troppe cavolate..
    dimenticato cose importanti,eccetera..
    se notate qualchecosa che non va,
    oltre al mio italiano,
    segnalatelo, come segnalate aggiunte ,modifiche da fare,
    cose da aggiungere.
    un ultima nota va ai frammenti di codice tratti per lo piu' dall' help di turboc ..
    non credo ci siano problemi di copyright
    ma in caso sono pronto a sostituire tutto il codice

  7. #7
    Complimenti x l'impegno ! VVoVe:

    Adesso la leggo...
    Vinum dolce gloriosum
    pingue facit et carnosum
    Vinum forte,vinum purum
    reddit hominem securum

  8. #8
    io ho il K&R(la bibbia che chi programma in C dovrebbe avere) e tutto ciò li è scritto
    La stupidità umana e l'universo sono infinite.
    Della seconda non sono certo(Einstein)

    Gnu/Linux User

  9. #9
    Originariamente inviato da Luc@s
    io ho il K&R(la bibbia che chi programma in C dovrebbe avere) e tutto ciò li è scritto
    si ma dalla seconda versione però

  10. #10
    Utente di HTML.it L'avatar di brapao
    Registrato dal
    Jun 2002
    Messaggi
    35
    ... esiste una libreria che gestisce il mouse ??? ... e i colori dello schermo ??? me ne bastano 256 ... grazie

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2019 vBulletin Solutions, Inc. All rights reserved.