Newsgroup: it.comp.programmare.win32
Titolo: [API] Ricavare data dai millisecondi

Se io ho una variabile (long double, per esempio) contenente dei
millesecondi (da me trovati), c'e' qualche funzione delle API (uso il
C) che mi consente di trasformare questi  millisecondi in
secondi,minuti,ore e giorni (anche separati tra di loro). 
Grazie.
--
Scritto da Gordon
E-mail: 
tbe...@avpu.vg

 secondi,minuti,ore e giorni (anche separati tra di loro). 
Non credo, comunque due domande per chiarire il problema:
1) I millisecondi che hai sono trascorsi da quando?
2) Ti serve per forza un'API o va bene qualunque funzione C?
Steve.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

2) Ti serve per forza un'API o va bene qualunque funzione C?
si', anche una funzione C.
Senno' altrimenti posso provare a farla da me, ma mi serve un po' di
documentazione su come gestire le conversioni, visto che i secondi
hanno un massimo di 60 ed e' un bel problema.



..e le ore in un giorno 24. Sento che mi sta arrivando un bel mal di testa.
;-)
Questo lo scrissi tempo fa, non mi ricordo se funzionava. Occhio !!!
#define MSxGIO  (1000*60*60*24)
#define MSxORA  (1000*60*60)
#define MSxMIN  (1000*60)
#define MSxSEC  1000
void StampamiLaDataSenzaLeAPI( float ms) {
 int giorni = (int)(ms/MSxGIO);
 ms = ms-(float)MSxGIO*giorni;
 int ore = (int)(ms/MSxORA);
 ms = ms-(float)MSxORA*ore;
 int minuti = (int)(ms/MSxMIN);
 ms = ms-(float)MSxMIN*minuti;
 int secondi = (int)(ms/MSxSEC);
 ms = ms-(float)MSxSEC*secondi;
 printf (
  "%d Giorni, %d ore, %d minuti, %d secondi e %d millisecondi\n",
  giorni,
  ore,
  minuti,
  secondi,
  (int)ms
 );
}
Ciao,
Giacomo

 hanno un massimo di 60 ed e' un bel problema.
Quali conversioni? Sono solo divisioni e sottrazioni...
1s = 1000ms.
1m = 60s.
1h = 60m.
1g = 24h.
HTH,


 secondi,minuti,ore e giorni (anche separati tra di loro).
Certo, fai cosi`:
-Converti la tua ora/data di partenza in un filetime, usando
SystemTimeToFileTime();
-A questo punto la FILETIME contiene (in un intero a 64 bit suddiviso in
due DWORD) il numero di decimi di microsecondi trascorsi dal 1/1/1601
alla data che hai specificato;
-Aggiungi a questo intero a 64 bit i tuoi millisecondi, ovviamente
moltiplicati per 10000;
-Riconverti il FILETIME ottenuto in un system time, con
FileTimeToSystemTtime().
-- 
Lorenzo

 due DWORD) il numero di decimi di microsecondi trascorsi dal 1/1/1601
Ma i millisecondi li trova con GetTickCount() quindi non è una data
"assoluta" che vuole ottenere, ma semplicemente la visualizzazione in un
formato diverso (cioè giorni, ore, minuti, secondi anzichè millisecondi).
Almeno da quanto diceva nel post precedente.


1g = 24h.
per questi ultimi tre nelle divisioni non si perde un po' di
precisione?


 precisione?
Lavorando con i float certo un po' di precisione potresti perderla, ma
vedrai che sarà più che tollerabile. L'importante comunque è tenersi via
il dato originario (i millisecondi intendo) ed effettuare la conversione
solo quando necessario, per esempio se dovessi visualizzare il dato in
ore, minuti e secondi. Ma questo ovviamente dipende da quello che stai
realizzando.


ore, minuti e secondi. 
chiaro.


 millisecondi). 
copio/incollo dall'utility "tickcount" di ReactOS, che usa un algoritmo 
un po' intricato ma perfettamente funzionante:
/* $Id: tickcount.c,v 1.1 2003/02/09 21:17:21 hyperion Exp $
*/
/*
 tickcount -- Display the kernel tick count in human-readable format
 This is public domain software
*/
#include <assert.h>
#include <stdio.h>
#include <tchar.h>
#include <windows.h>
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#define TICKS_YEAR   (TICKS_DAY * ((uint64_t)365))
#define TICKS_MONTH  (TICKS_DAY * ((uint64_t)30))
#define TICKS_WEEK   (TICKS_DAY * ((uint64_t)7))
#define TICKS_DAY    (TICKS_HOUR * ((uint64_t)24))
#define TICKS_HOUR   (TICKS_MINUTE * ((uint64_t)60))
#define TICKS_MINUTE (TICKS_SECOND * ((uint64_t)60))
#define TICKS_SECOND ((uint64_t)1000)
#define SLICES_COUNT (sizeof(ticks_per_slice) / sizeof(ticks_per_slice[0]))
uint64_t ticks_per_slice[] =
{
 TICKS_YEAR,
 TICKS_MONTH,
 TICKS_WEEK, 
 TICKS_DAY,
 TICKS_HOUR,
 TICKS_MINUTE,
 TICKS_SECOND,
 1
};
_TCHAR * slice_names_singular[] =
{
 _T("year"),
 _T("month"),
 _T("week"),
 _T("day"),
 _T("hour"),
 _T("minute"),
 _T("second"),
 _T("millisecond")
};
_TCHAR * slice_names_plural[] =
{
 _T("years"),
 _T("months"),
 _T("weeks"),
 _T("days"),
 _T("hours"),
 _T("minutes"),
 _T("seconds"),
 _T("milliseconds")
};
void print_uptime
(
 uint64_t tickcount,
 uint64_t prevsliceval,
 _TCHAR * prevsliceunit,
 int curslice
)
{
 uint64_t tick_cur = tickcount / ticks_per_slice[curslice];
 uint64_t tick_residual = tickcount % ticks_per_slice[curslice];
 assert(tick_cur <= (~((uint64_t)0)));
 if(tick_residual == 0)
 {
  /* the current slice is the last */
  if(prevsliceval == 0)
  {
   /* the current slice is the only */
   _tprintf
   (
    _T("%u %s"),
    (unsigned)tick_cur,
    (tick_cur == 1 ? slice_names_singular : slice_names_plural)[curslice]
   );
  }
  else
  {
   /* the current slice is the last, and there's a previous slice */
   assert(prevsliceunit);
   /* print the previous and the current slice, and terminate */
   _tprintf
   (
    _T("%u %s %s %u %s"),
    (unsigned)prevsliceval,
    prevsliceunit,
    _T("and"),
    (unsigned)tick_cur,
    (tick_cur == 1 ? slice_names_singular : slice_names_plural)[curslice]
   );   
  }
 }
 else if(tick_cur != 0)
 {
  /* the current slice is not the last, and non-zero */
  if(prevsliceval != 0)
  {
   /* there's a previous slice: print it */
   assert(prevsliceunit);
   _tprintf(_T("%u %s, "), (unsigned)prevsliceval, prevsliceunit);
  }
  /* recursion on the next slice size, storing the current slice */
  print_uptime
  (
   tick_residual,
   tick_cur,
   (tick_cur == 1 ? slice_names_singular : slice_names_plural)[curslice],
   curslice + 1
  );
 }
 else
 {
  /*
   the current slice is not the last, and zero: recursion, remembering the
   previous non-zero slice
  */
  print_uptime(tick_residual, prevsliceval, prevsliceunit, curslice + 1);
 }
}
int _tmain()
{
 print_uptime((uint64_t)GetTickCount(), 0, NULL, 0);
 _puttc(_T('\n'), stdout);
 return 0;
}
-- 
  < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
      Don't stand, REACT!      version 0.1.1. C, C++ and ASM developers
                               and beta testers are welcome!

 millisecondi).
In pratica allora vuole visualizzare l'uptime della macchina? In tal
caso non serve nessuna conversione, bastano delle elementari divisioni
del tipo:
DWORD ticks = GetTickCount();
DWORD millisecondi = ticks % 1000;
ticks /= 1000;
DWORD secondi = ticks % 60;
ticks /= 60;
DWORD minuti = ticks % 60;
ticks /= 60;
e cosi` via...
-- 
Lorenzo

ticks /= 1000;
grazie a tutti per le soluzioni proposte.


 continuously for 49.7 days.
Triste, dovrebbe esistere un sistema per aggirare il problema..

 Triste, dovrebbe esistere un sistema per aggirare il problema..
non usare GetTickCount, ad esempio, e leggere l'uptime dalla SharedData 
direttamente (documentata, ma usabile solo nella famiglia NT)


 problema..
No, perche` leggere l'uptime con GetTickCount() non e` formalmente
corretto.
-- 
Lorenzo