Newsgroup: it.comp.lang.c++
Titolo: tempo tra 2 istanti

ciao...come mi è stato suggerito ho trovato che la funzione
gettimeofday permette di misurare l'intervallo tra due istanti con una
precisione migliore del secondo.
timeval ha la seguente struttura:
 struct timeval
{      long tv_sec;            /* seconds */
     long tv_usec;           /* microseconds */
 };
e quindi per misurare con la precisione del microsecondo ho fatto
così....
#include <sys/time.h>
#include <time.h>
...
...
long elapsedtime;
struct timeval tvstart, tvend;
gettimeofday(&tvstart, NULL);
...
...
...
gettimeofday(&tvend, NULL);
elapsedtime = (tvend.tv_sec - tvstart.tv_sec) * 1000000 +
                  tvend.tv_usec - tvstart.tv_usec;
solo che mi da i seguenti errori:
 C:\Documents and Settings\peppe\Desktop\provaaa­aaaaaaaa\client.cpp
[Warning] In function:
113 C:\Documents and
Settings\peppe\Desktop\provaaa­aaaaaaaa\client.cpp
`
113 C:\Documents and
Settings\peppe\Desktop\provaaa­aaaaaaaa\client.cpp
(Each
vedendo altrove il seguente prototipo:
int gettimeofday(struct timeval *tv, struct timezone *tz)
ho provato ad utilizzare i puntatori ma cmq non funziona.....
forse è perchè uso windows??? 
ma non so come fare!!!!

 
dovrai accontentarti di minore precisione utilizzando funzioni tipo 
time() e clock(), oppure quella specifica di Windows.
-- 
MSN: sirpsycho_78 -at- hotmail dot com

non esistono direttive per rendere il codice portabile???
a me basterebbe anche la precisione dei decimi o centesimi meglio
ancora.....
xò non posso seguire il consiglio di scaricare qualche programmino
xkè deve funzionare anche su altri dove non posso scaricare nulla
:)...
clock() e time() se non sbaglio hanno solo la precisione del
secondo.....

a proposito mi hanno consigliato difftime() solo che anche così riesco
ad ottenere solo la precione del secondo...     :-(

 
no, clock() in realtà dovrebbe essere un po' più preciso, la macro 
CLOCKS_PER_SEC ti restituisce il numero di tick del contatore per 
secondo. CLOCKS_PER_SEC/1000. invece ti restituisce quelli per 
millisecondo. Se non vado errato però, non c'è altro di portabile.


 secondo.....
http://groups.google.com/group/it.comp.lang.c++/tree/browse_frm/thread/08e6ac7bf31c276f/cd686b9696356a30?rnum=1&_done=%2Fgroup%2Fit.comp.lang.c%2B%2B%2Fbrowse_frm%2Fthread%2F08e6ac7bf31c276f%2Ffdb626f73ec30308%3F#doc_f9385dc15af4cd3d
-- 
Gerolamo 

 tipo time() e clock(), oppure quella specifica di Windows.
Per una precisione di seconde, time(). Se no, bisogna cercare
una funzione Windows.
--
James Kanze                                           GABI Software
Conseils en informatique orientée objet/
                   Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, 
+33 (0)1 30 23 00 34

 secondo.....
clock() ne hà più; quanto dipende dell'implementazione. Invece,
non mesura il tempo passato, ma il tempo utilisato dal
programma.


 millisecondo.
Su molti sistemi, CLOCKS_PER_SEC/1000 dà 0. (Non dimenticare che
a un tipo integrale.)


 così riesco ad ottenere solo la precione del secondo... :-(
Essiste perche time_t non misura obligatoriamente secondi. Può
essere un double, può essere un int a 64 bits che misura
milliseconde, può avere un format: 6 bits per i secondi, 6 per i
minui, 5 per l'ora, etc. (Infatti, sul vecchio DOS, un tale
format a servito, con 5 bit per i secondi/2, dal modo che l'ora
passa in 16 bit, et la data in 16.)
Oggi, su Windows e Unix, non c'è probleme: time_t dà i secondi
da una data e un'ora fisse.


 a un tipo integrale.)
infatti ho scritto CLOCKS_PER_SEC/1000. - guarda bene ;-)


 da una data e un'ora fisse.
Non sono sicuro.  Secondo ISO/IEC 9899:1999 7.23.1.3, time_t e' un
"arithmetic type capable of representing times"; quindi credo che
bytefields come dicevi prima, o anche struct composte da piu' di un
int/long siano ammesse dallo Standard.  Per questo bisognerebbe
*sempre* usare difftime e *mai* sottrarre direttamente.
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Dept. of Physics, Univ. of Padova, Italy              ROT13: 
ybe...@cq.vasa.vg

con clock() sono riuscito ad ottenere la precione del microsecondo...
grazie tante...

 grazie tante...
occhio che, come puoi vedere se leggi tutto il thread che ti ho segnalato,
un conto è la precisione e un altro è l'unità di misura.
Comunque quello è circa il meglio che puoi fare col C++ standard.
ciao
-- 
Gerolamo 

 infatti ho scritto CLOCKS_PER_SEC/1000. - guarda bene ;-)
Dovè la differenze? Mi son già serviti di sistemi dove
CLOCKS_PER_SEC valeva 50. L'espressione 50/1000 vale 0 in C++,
perche 50 e 1000 sono tutti due int.


 sottrarre direttamente.
È probabilemente megliore. Mà esiste tanta codice che non lo fà.
Anch'io dimentico spesso farlo. (Bisogna dire che ho imparato
time() sotto Unix, prima che sià una norma C. I vecchi
abitudini, anche i cativi, non si perdono.)


 
50/1000. in C++ restituisce 0.05, non 0.
#include <iostream>
int
main()
{
	std::cout << "50/1000 = " << 50/1000 << std::endl;
	std::cout << "50/1000. = " << 50/1000. << std::endl;


 50/1000. in C++ restituisce 0.05, non 0.
quindi le costanti literal (ossia inline, non dichiarate const) 
vengono memorizzate come double di defautl ?
E in caso contrario, si effettuano tre cast (due con promozione 
a double e uno con ritorno al tipo del dato di rango più alto 
della espressione, o della destinazione in caso di assegnazione) 
? Se ciò fosse vero, come fare a forzare l'esecuzione della 
divisione intera ? Servirebbe un cast statico a tipi integrali 
su entrambi i termini della divisione, tipo :
(int)(50) / (int)(1000)  ?
ciao
CCCP++Mario


 (int)(50) / (int)(1000)  ?
Non esattamente. Fred sfrutta il fatto che 1000. (nota il punto)
equivale a 1000.0 e sono entrambe costanti double. 1000 e' di tipo int.
Questo thread mi pare un buon esempio del perche' e' meglio sempre
scrivere lo zero dopo la virgola se si vuole ottenere una costante
double con valore intero.
Ciao,
Nicola

 double con valore intero.
quoto :-)


 1000000.
Non necessariamente, o meglio, in teoria si. È scritto nello standard
SUSv2. 
Tuttavia leggo che FreeBSD non rispetta questa convenzione. Su MacOS X
(che dovrebbe avere lo stesso valore che sotto fBSD) vale 100.
Domani se mi ricordo checcko sul serverino. 
-- 
non vincono, non vinceranno, non hanno domani
la forza è nel puntello impugnato da oneste fortissime mani

 vale 100.
Unix è una marca registrata. Non è Unix chi vuole. In
particulare, ne FreeBSD ne Linux sono Unix.
Officialemente, in ogni casa.
Mà infatti, mi son basato sulla norma. Non ho verificato tutti
sistemi che chiamiamo abitualemente Unix.


 sistemi che chiamiamo abitualemente Unix.
No, era solo per fare presente che chi ci facesse conto deve stare
attento. Per dire su Linux credo sia il valore indicato da te. E in
pratica anzi credo che fBSD sia un eccezione. Sulle man pages di nBSD e
oBSD per dire non dice nulla.
Ma è una questione di lana caprina, in effetti :)
