Compartir a través de

Fecha y hora

MFC admite varias maneras diferentes de trabajar con fechas y horas:

  • Compatibilidad con el tipo de datos DATE de Automatización. DATE admite valores de fecha, hora y fecha/hora. Las clases COleDateTime y COleDateTimeSpan encapsulan esta funcionalidad. Funcionan con la clase COleVariant mediante la compatibilidad con la Automatización.

  • Clases de tiempo de uso general. Las clases CTime y CTimeSpan encapsulan la mayor parte de la funcionalidad asociada a la biblioteca de tiempo estándar ANSI, que se declara en time.h.

  • Compatibilidad con el reloj del sistema. Con la versión 3.0 de MFC, se agregó compatibilidad a CTime con los tipos de datos SYSTEMTIME y FILETIME de Win32.

Fecha y hora: Compatibilidad con la Automatización

La clase COleDateTime proporciona una manera de representar información de fecha y hora. Proporciona una granularidad más fina y un intervalo mayor que la clase CTime. La clase COleDateTimeSpan representa el tiempo transcurrido, como la diferencia entre dos objetos COleDateTime.

Las clases COleDateTime y COleDateTimeSpan están diseñadas para su uso con la clase COleVariant. COleDateTime y COleDateTimeSpan también son útiles en la programación de bases de datos de MFC, pero se pueden usar siempre que quiera manipular valores de fecha y hora. Aunque la clase COleDateTime tiene un intervalo mayor de valores y una granularidad más fina que la clase CTime, requiere más almacenamiento por objeto que CTime. También hay algunas consideraciones especiales al trabajar con el tipo DATE subyacente. Para obtener más información sobre la implementación de DATE, consulte Tipo DATE.

Los objetos COleDateTime se pueden usar para representar fechas entre el 1 de enero del año 100 y el 31 de diciembre de 9999. Los objetos COleDateTime son valores de punto flotante, con una resolución aproximada de 1 milisegundo. COleDateTime se basa en el tipo de datos DATE, definido en la documentación de MFC en COleDateTime::operator DATE. La implementación real de DATE se extiende más allá de estos límites. La implementación de COleDateTime impone estos límites para facilitar el trabajo con la clase.

COleDateTime no admite fechas del calendario juliano. Se da por supuesto que el calendario gregoriano se extiende hacia atrás en el tiempo hasta el 1 de enero del año 100.

COleDateTime omite el horario de verano (DST). En el ejemplo de código siguiente, se comparan dos métodos para calcular un intervalo de tiempo que cruza la fecha de conmutación de DST: uno con CRT y el otro con COleDateTime.

El primer método establece dos objetos CTime, time1 y time2, en el 5 de abril y el 6 de abril, respectivamente, mediante las estructuras estándar de tipo C tm y time_t. El código muestra time1 y time2, y el intervalo de tiempo entre ellos.

El segundo método crea dos objetos COleDateTime, oletime1 y oletime2, y los establece en las mismas fechas que time1 y time2. Muestra oletime1 y oletime2, y el intervalo de tiempo entre ellos.

CRT calcula correctamente una diferencia de 23 horas. COleDateTimeSpan calcula una diferencia de 24 horas.

void CDTDlg::OnPaint()
{
   CPaintDC dc(this); // device context for painting

   time_t date1_t, date2_t;
   tm date_tm;

   date_tm.tm_hour = 12;
   date_tm.tm_min = 0;
   date_tm.tm_mon = 3;
   date_tm.tm_sec = 0;
   date_tm.tm_wday = 0; //Day of week (0-6; Sunday = 0)
   date_tm.tm_yday = 0;
   date_tm.tm_year = 97;
   date_tm.tm_isdst = -1; //Positive if Daylight Saving Time is in effect;
                         //0 if Daylight Saving Time is not in effect; 
                         //Negative if status of DST is unknown.

   date_tm.tm_mday = 6;
   date2_t = mktime(&date_tm);

   date_tm.tm_mday = 5;
   date_tm.tm_isdst = 0;
   date1_t = mktime(&date_tm);

   CTime time1(date1_t), time2(date2_t);
   CTimeSpan ts = time2 - time1;

   dc.TextOut(0, 0, CString(_T("CTime")));
   dc.TextOut(0, 20, time1.Format(_T("%H:%M:%S %A, %B %d, %Y")));
   dc.TextOut(0, 40, time2.Format(_T("%H:%M:%S %A, %B %d, %Y")));
   dc.TextOut(0, 60, ts.Format(_T("%H:%M:%S and %D days")));


   COleDateTime oletime1(date1_t), oletime2(date2_t);
   COleDateTimeSpan olets = oletime2 - oletime1;

   dc.TextOut(0, 120, CString(_T("COleDateTime")));
   dc.TextOut(0, 140, oletime1.Format(_T("%H:%M:%S %A, %B %d, %Y")));
   dc.TextOut(0, 160, oletime2.Format(_T("%H:%M:%S %A, %B %d, %Y")));
   
   //Work-around bug in COleDateTime::Format("%D")
   CString str;
   str.Format(_T("%s and %d days"), (LPCTSTR)olets.Format(_T("%H:%M:%S")), 
      olets.GetDays());
   dc.TextOut(0, 180, str);
}

Obtener la hora actual

En el procedimiento siguiente, se muestra cómo crear un objeto COleDateTime e inicializarlo con la hora actual.

Obtención de la hora actual

  1. Crear un objeto COleDateTime.

  2. Llame a GetCurrentTime.

    COleDateTime timeNow;
timeNow = COleDateTime::GetCurrentTime();

Cálculo del tiempo transcurrido

En este procedimiento, se muestra cómo calcular la diferencia entre dos objetos COleDateTime y obtener un resultado COleDateTimeSpan.

Cálculo del tiempo transcurrido

  1. Cree dos objetos COleDateTime.

  2. Establezca uno de los objetos COleDateTime en la hora actual.

  3. Realice una tarea que consuma una cantidad de tiempo.

  4. Establezca el otro objeto COleDateTime en la hora actual.

  5. Tome la diferencia entre las dos horas.

    COleDateTime timeStart, timeEnd;
timeStart = COleDateTime::GetCurrentTime();
// ... perform time-consuming task
timeEnd = COleDateTime::GetCurrentTime();
COleDateTimeSpan spanElapsed = timeEnd - timeStart;

Dar formato a una hora

Dar formato a una hora

Use la función miembro Format de COleDateTime o COleDateTimeSpan para crear una cadena de caracteres que represente la hora o el tiempo transcurrido.

COleDateTime time(1970, 12, 18, 17, 30, 0);
// 18 December 1970, 5:30 PM
CString s = time.Format(VAR_DATEVALUEONLY);
// s contains the date formatted based on 
// the current national language specifications
// (locale ID). The time portion is ignored for 
// formatting purposes in this case.

Para obtener más información, vea la clase COleVariant.

Fecha y hora: compatibilidad con bases de datos

A partir de la versión 4.0, la programación de bases de datos de MFC usa las clases COleDateTime y COleDateTimeSpan para representar datos de fecha y hora. Estas clases, que también se usan en la Automatización, se derivan de la clase COleVariant. Proporcionan una mejor compatibilidad con la administración de datos de fecha y hora que CTime y CTimeSpan.

Fecha y hora: compatibilidad con SYSTEMTIME

La clase COleDateTime tiene constructores que aceptan las horas de archivo y del sistema de Win32.

La estructura FILETIME de Win32 representa el tiempo como un valor de 64 bits. Es un formato más cómodo para el almacenamiento interno que una estructura SYSTEMTIME y es el formato utilizado por Win32 para representar la hora de creación de un archivo. Consulte SYSTEMTIME para obtener más información sobre la estructura SYSTEMTIME. Consulte FILETIME para obtener más información sobre la estructura FILETIME.

Consulte también

Conceptos
Temas generales de MFC

  • Last updated on