Laboratorio Nro. 4

#include <windows.h>
#include <stdlib.h>

int WINAPI WinMain
(
   HINSTANCE hInstance,     // Handle a la instancia del programa actual
   HINSTANCE hPrevInstance, // Handle a la instancia del previa al programa actual
   PSTR szCmdLine,          // String que muestra la línea de comandos
   int nCmdShow             // Muestra el comando
)
{
   MessageBox
   (
      NULL,
      TEXT ("Hola Mundo en Windows XP!"),
      TEXT ("- Mensaje -"),
      0
   );

   return EXIT_SUCCESS;
}

Escrito por cursodecpp el 28/10/2009 05:17 | Comentarios (0)

Laboratorio Nro. 3

#include <iotream.h>
#include <stdlib.h>
#include "fecha1.h"

clsFecha cfFecha1;
clsFecha cfFecha2;

long dif; // Diferencia en dias de ambas fechas

int main()
{
   int i;

   // Captura por pantalla valores en i hasta que alcance uno
   // en el rango válido 1 a 9999 y luego lo asigna al año de
   // la primera fecha almacenada en la variable 'cfFecha1'.
   do
   {
      cout << "Introduzca el año de la 1ra. fecha: ";
      cin >> i;
      cout << endl;
   }
   while(i > 9999 || i < 0);
   cfFecha1.pone_a_o(i);

   // Captura por pantalla valores en i hasta que alcance uno
   // en el rango válido 1 a 12 y luego lo asigna al mes de
   // la primera fecha almacenada en la variable 'cfFecha1'.
   do
   {
      cout << "Introduzca el mes de la 1ra. fecha: ";
      cin >> i;
      cout << endl;
   }
   while(i > 12 || i < 0);
   cfFecha1.pone_mes(i);

   // Captura por pantalla valores en i hasta que alcance uno
   // en el rango válido 1 al último del mes ya previamente
   // capturado y en concordancia con si el tambien ya capturado
   // año y el hecho de ser bisiesto o no, y luego lo asigna al
   // día de la primera fecha almacenada en la variable 'cfFecha1'.
   i = 0;
   while(i < 1 || i > ultimo(cfFecha1.dame_mes(), cfFecha1.dame_a_o())
   {
      cout << "Introduzca el día de la 1ra. fecha: ";
      cin >> i;
      cout << endl;
   }
   cfFecha1.pone_dia(i);

   // Captura por pantalla valores en i hasta que alcance uno
   // en el rango válido 1 a 9999 y luego lo asigna al año de
   // la segunda fecha almacenada en la variable 'cfFecha2'.
   do
   {
      cout << "Introduzca el año de la 2da. fecha: ";
      cin >> i;
      cout << endl;
   }
   while(i > 9999 || i < 0);
   cfFecha2.pone_a_o(i);

   // Captura por pantalla valores en i hasta que alcance uno
   // en el rango válido 1 a 12 y luego lo asigna al mes de
   // la segunda fecha almacenada en la variable 'cfFecha2'.
   do
   {
      cout << "Introduzca el mes de la 2da. fecha: ";
      cin >> i;
      cout << endl;
   }
   while(i > 12 || i < 0);
   cfFecha2.pone_mes(i);

   // Captura por pantalla valores en i hasta que alcance uno
   // en el rango válido 1 al último del mes ya previamente
   // capturado y en concordancia con si el tambien ya capturado
   // año y el hecho de ser bisiesto o no, y luego lo asigna al
   // día de la segunda fecha almacenada en la variable 'cfFecha2'.
   i = 0;
   while(i < 1 || i > ultimo(cfFecha2.dame_mes(), cfFecha2.dame_a_o())
   {
      cout << "Introduzca el día de la 2da. fecha: ";
      cin >> i;
      cout << endl;
   }
   cfFecha2.pone_dia(i);

   if(cfFecha1.dame_a_o() == cfFecha2.dame_a_o())
   {
      if(cfFecha1.dame_mes() == cfFecha2.dame_mes())
         dif = cfFecha2.dame_dia() - cfFecha1.dame_dia();
      else
         dif = ultimo(cfFecha1.dame_mes(), cfFecha1.dame_a_o()) - cfFecha1.dame_dia() + dias(cfFecha1.dame_mes() + 1, cfFecha2.dame_mes() - 1, cfFecha1.dame_a_o(), cfFecha2.dame_a_o()) + cfFecha2.dame_dia();
   }
   else
   {
      dif = ultimo(cfFecha1.dame_mes(), cfFecha1.dame_a_o()) - cfFecha1.dame_dia() + dias(cfFecha1.dame_mes() + 1, cfFecha2.dame_mes() - 1, cfFecha1.dame_a_o(), cfFecha2.dame_a_o()) + cfFecha2.dane_dia();
   }
   cout << "La diferencia en días es de: " << dif << endl;

return EXIT_SUCCESS;
}

Escrito por cursodecpp el 28/10/2009 05:12 | Comentarios (0)

Laboratorio Nro. 2

A continuación el código de la librería fecha1.h, la cual está incompleta. Terminar para la próxima clase. Es de carácter obligatorio.

// *********************************************************************************
// ** **
// ** Biblioteca: Clase clsFecha. **

// ** **
// *********************************************************************************

#ifndef __FECHA_H__
#define __FECHA_H__
#include <math.h>
class clsFecha
{
   private:   // Datos o Atributos de la clase clsFecha
      int nD; // Día de una fecha clsFecha
      int nM; // Mes de una fecha clsFecha
      int nA; // Año de una fecha clsFecha

   public:    // Funciones o Métodos de la clase clsFecha
      // Tus comentarios van aquí
      void pone_dia(int nParam)
      {
         nD = nParam;
      }

      // Tus comentarios van aquí
      void pode_mes(int nParam)
      {
         nM = nParam;
      }

      // Tus comentarios van aquí
      void pode_a_o(int nParam)
      {
         nA = nParam;
      }

      // Tus comentarios van aquí
      int dame_dia()
      {
         return nD;
      }

      // Tus comentarios van aquí
      int dame_mes()
      {
         return nM;
      }

      // Tus comentarios van aquí
      int dame_a_o()
      {
         return nA;
      }

      // Tus comentarios van aquí

      // terminar esta función
      clsFecha incr()
      {
         switch(nM)
         {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
               if(nD == 31)
               {
                  nD = 1;
                  nM++;
               }
               else
                  nD++;
               break;

            case 12:
               if(nD == 31)
               {
                  nD = 1;
                  nM = 1;
                  nA++;
               }
               else
                  nD++;
               break;

            case 4:
            case 6:
            case 9:
            case 11:
               if(nD == 30)
               {
                  nD = 1;
                  nM++;
               }
               else
                  nD++;
               break;

            case 2:
               if((int)fmod(2009, 4) == 0)
                  cout << "BISIESTO";
               else
                  cout << "REGULAR";
               break;

            default: // No debería ocurrir nunca
         }

         return fTemp;
      }

      // Tus comentarios van aquí
      clsFecha decr()
      {
         clsFecha fTemp;
         // Terminar esta funcion
         return fTemp;
      }

      // Tus comentarios van aquí
      void muestra(int nFormato)
      {
         switch(nFormato)
         {
            case 1: // dd-mm-aaaa
               if(nD <= 9)
                  cout << "0";
               cout << nD << "-";
               if(nM <= 9)
                  cout << "0";
               cout << nM << "-" << nA;
               break;

            case 2: // dd/mm/aaaa
               if(nD <= 9)
                  cout << "0";
               cout << nD << "/";
               if(nM <= 9)
                  cout << "0";
               cout << nM << "/" << nA;
               break;

            case 3: // dd-mmm-aaaa
               if(nD <= 9)
                  cout << "0";
               cout << nD << "-";
               switch(nM)
               {
                  case 1: // Enero
                     cout << "ENE-" << nA;
                  case 2: // Febrero
                     cout << "FEB-" << nA;
                  case 3: // Marzo
                     cout << "MAR-" << nA;
                  case 4: // Abril
                     cout << "ABR-" << nA;
                  case 5: // Mayo
                     cout << "MAY-" << nA;
                  case 6: // Junio
                     cout << "JUN-" << nA;
                  case 7: // Julio
                     cout << "JUL-" << nA;
                  case 8: // Agosto
                     cout << "AGO-" << nA;
                  case 9: // Septiembre
                     cout << "SEP-" << nA;
                  case 10: // Octubre
                     cout << "OCT-" << nA;
                  case 11: // Nobiembre
                     cout << "NOV-" << nA;
                  case 12: // Diciembre
                     cout << "DIC-" << nA;
               }
               break;

            case 4: // dd/mmm/aaaa
               if(nD <= 9)
                  cout << "0";
               cout << nD << "/";
               switch(nM)
               {
                  case 1: // Enero
                     cout << "ENE/" << nA;
                  case 2: // Febrero
                     cout << "FEB/" << nA;
                  case 3: // Marzo
                     cout << "MAR/" << nA;
                  case 4: // Abril
                     cout << "ABR/" << nA;
                  case 5: // Mayo
                     cout << "MAY/" << nA;
                  case 6: // Junio
                     cout << "JUN/" << nA;
                  case 7: // Julio
                     cout << "JUL/" << nA;
                  case 8: // Agosto
                     cout << "AGO/" << nA;
                  case 9: // Septiembre
                     cout << "SEP/" << nA;
                  case 10: // Octubre
                     cout << "OCT/" << nA;
                  case 11: // Nobiembre
                     cout << "NOV/" << nA;
                  case 12: // Diciembre
                     cout << "DIC/" << nA;
               }
               break;

            case 4: // dd/mmm/aaaa
               if(nD <= 9)
                  cout << "0";
               cout << nD << " de ";
               switch(nM)
               {
                  case 1: // Enero
                     cout << "enero de " << nA;
                  case 2: // Febrero
                     cout << "febrero de " << nA;
                  case 3: // Marzo
                     cout << "marzo de " << nA;
                  case 4: // Abril
                     cout << "abril de " << nA;
                  case 5: // Mayo
                     cout << "mayo de " << nA;
                  case 6: // Junio
                     cout << "junio de " << nA;
                  case 7: // Julio
                     cout << "julio de " << nA;
                  case 8: // Agosto
                     cout << "agosto de " << nA;
                  case 9: // Septiembre
                     cout << "septiembre de " << nA;
                  case 10: // Octubre
                     cout << "octubre de " << nA;
                  case 11: // Nobiembre
                     cout << "noviembre de " << nA;
                  case 12: // Diciembre
                     cout << "diciembre de " << nA;
               }
               break;
         }
      }

      // *******************************************************************
      // *        Nombre: clsFecha.                                        *
      // *   Descripción: Método constructor o función constructora de la *
      // *                clase denominada clsFecha. Inicializa a la fecha *
      // *                base por defecto, que es, el 01-01-1980.         *
      // *      Retorno: Ninguno.                                         *
      // *   Parámetros: Ninguno.                                         *
      // * Precondición: No existe la fecha;                              *
      // *                {}.                                              *
      // * Postcondición: La fecha es el 01-01-1980;                       *
      // *                {nD = 1, nM = 1, nA = 1980}.                     *
      // *         Autor: Augusto César Molina.                            *
      // *      Ceado el: 23-SEP-2009.                                     *
      // * Modificado el: 06-OCT-2009 por A.C.M.                           *
      // *******************************************************************
      clsFecha()
      {
         nD = 1;
         nM = 1;
         nA = 1980;
      }

      // *******************************************************************
      // *        Nombre: ~clsFecha.                                       *
      // *   Descripción: Método destructor o función destructora de la    *
      // *                clase denominada clsFecha. Destruyec un objeto o *
      // *                una instancia de la clase fecha 'clsFecha'.      *
      // *      Retorno: Ninguno.                                         *
      // *   Parámetros: Ninguno.                                         *
      // * Precondición: Cualquier fehca;                                 *
      // *                {nD = dddd, nM = mmmm, nA = aaaa}                *
      // * Postcondición: No existe la fecha;                              *
      // *                {}                                               *
      // *         Autor: Augusto César Molina.                            *
      // *      Ceado el: 23-SEP-2009.                                     *
      // * Modificado el: 06-OCT-2009 por A.C.M. - Intradocumentación      *
      // *******************************************************************
      ~clsFecha()
      {
         // No se hace nada por ahora.
      }
};

// *******************************************************************
// *        Nombre: bisiesto.                                        *
// *   Descripción: Función que determina si un año dadp es o no     *
// *                bisiesto, es decir, que tiene 366 días en vez de *
// *                365 como los años regulares. Los años bisiestos *
// *                son divisibles por 4, con la excepción de los    *
// *                años que terminan en 00 o divisible entre 100,   *
// *                que deben ser divisibles por 400 para ser con-   *
// *                siderados como bisiestos.                        *
// *      Retorno: un boleano o valor lógico.                       *
// *                Entero pasado por valor constante 'a'.           *
// *   Parámetros: El año en cuestión, un entero (a as integer) .   *
// * Precondición: El año pero sin saber si es bisiesto.            *
// *                { a = k, bisiesto = ? }.                         *
// * Postcondición: El año, sabiendo si es bisiesto o no.            *
// *                { a = k, bisiseto = verdadero | falso }.         *
// *         Autor: Augusto César Molina.                            *
// *      Ceado el: 23-SEP-2009.                                     *
// * Modificado el: 06-OCT-2009 por A.C.M. - Intradocumentación      *
// *******************************************************************
int bisiesto(int a)
{
   if((int)fmod(a, 100) == 0)
   {
      if((int)fmod(a, 400 == 0)
         return -1
      else
         return 0
   }
   else
   {
      if((int)fmod(a, 4 == 0)
         return -1
      else
         return 0
   }
}

// *******************************************************************
// *        Nombre: bisiesto.                                        *
// *   Descripción: Función que determina si un año dadp es o no     *
// *                bisiesto, es decir, que tiene 366 días en vez de *
// *                365 como los años regulares. Los años bisiestos *
// *                son divisibles por 4, con la excepción de los    *
// *                años que terminan en 00 o divisible entre 100,   *
// *                que deben ser divisibles por 400 para ser con-   *
// *                siderados como bisiestos.                        *
// *      Retorno: un boleano o valor lógico.                       *
// *                Entero pasado por valor constante 'a'.           *
// *   Parámetros: El año en cuestión, un entero (a as integer) .   *
// * Precondición: El año pero sin saber si es bisiesto.            *
// *                { a = k, bisiesto = ? }.                         *
// * Postcondición: El año, sabiendo si es bisiesto o no.            *
// *                { a = k, bisiseto = verdadero | falso }.         *
// *         Autor: Augusto César Molina.                            *
// *      Ceado el: 23-SEP-2009.                                     *
// * Modificado el: 06-OCT-2009 por A.C.M. - Intradocumentación      *
// *******************************************************************
int ultimo(int m, int a)
{
   switch(m)
      case 1: // Caso para meses de 31 días
      case 3:
      case 5:
      case 7:
      case 8:
      case 10:
      case 12:
         return 31;

      case 4: // Caso para meses de 30 días
      case 6:
      case 9:
      case 11:
         return 30;

      case 2: // Caso para meses de 28 ó 29 días
         if(bisiesto(a))
            return 29;
         else
            return 28;

      default:
         // Nunca debe ocurrir
   }
};

// *******************************************************************
// *        Nombre: bisiesto.                                        *
// *   Descripción: Función que determina si un año dadp es o no     *
// *                bisiesto, es decir, que tiene 366 días en vez de *
// *                365 como los años regulares. Los años bisiestos *
// *                son divisibles por 4, con la excepción de los    *
// *                años que terminan en 00 o divisible entre 100,   *
// *                que deben ser divisibles por 400 para ser con-   *
// *                siderados como bisiestos.                        *
// *      Retorno: un boleano o valor lógico.                       *
// *                Entero pasado por valor constante 'a'.           *
// *   Parámetros: El año en cuestión, un entero (a as integer) .   *
// * Precondición: El año pero sin saber si es bisiesto.            *
// *                { a = k, bisiesto = ? }.                         *
// * Postcondición: El año, sabiendo si es bisiesto o no.            *
// *                { a = k, bisiseto = verdadero | falso }.         *
// *         Autor: Augusto César Molina.                            *
// *      Ceado el: 23-SEP-2009.                                     *
// * Modificado el: 06-OCT-2009 por A.C.M. - Intradocumentación      *
// *******************************************************************
int bisiesto(int a)
{
   if((int)fmod(a, 100) == 0)
   {
      if((int)fmod(a, 400) == 0)
         return -1;
      else
         return 0;
   }
   else
   {
      if((int)fmod(a, 4) == 0)
         return -1;
      else
         return 0;
   }
}

// *******************************************************************
// *        Nombre: bisiesto.                                        *
// *   Descripción: Función que determina si un año dadp es o no     *
// *                bisiesto, es decir, que tiene 366 días en vez de *
// *                365 como los años regulares. Los años bisiestos *
// *                son divisibles por 4, con la excepción de los    *
// *                años que terminan en 00 o divisible entre 100,   *
// *                que deben ser divisibles por 400 para ser con-   *
// *                siderados como bisiestos.                        *
// *      Retorno: un boleano o valor lógico.                       *
// *                Entero pasado por valor constante 'a'.           *
// *   Parámetros: El año en cuestión, un entero (a as integer) .   *
// * Precondición: El año pero sin saber si es bisiesto.            *
// *                { a = k, bisiesto = ? }.                         *
// * Postcondición: El año, sabiendo si es bisiesto o no.            *
// *                { a = k, bisiseto = verdadero | falso }.         *
// *         Autor: Augusto César Molina.                            *
// *      Ceado el: 23-SEP-2009.                                     *
// * Modificado el: 06-OCT-2009 por A.C.M. - Intradocumentación      *
// *******************************************************************
int ultimo(int m, int a)
{
   switch(m)
      // Caso para meses de 31 días
      case 1:
      case 3:
      case 5:
      case 7:
      case 8:
      case 10:
      case 12:
         return 31;

      // Caso para meses de 30 días
      case 4:
      case 6:
      case 9:
      case 11:
         return 30;

      // Caso para meses de 28 ó 29 días
      case 2:
         if(bisiesto(a))
            return 29;
         else
            return 28;

      default:
         // Nunca debe ocurrir
   }
}

// *******************************************************************
// *        Nombre: bisiesto.                                        *
// *   Descripción: Función que determina si un año dado es o no     *
// *                bisiesto, es decir, que tiene 366 días en vez de *
// *                365 como los años regulares. Los años bisiestos *
// *                son divisibles por 4, con la excepción de los    *
// *                años que terminan en 00 o divisible entre 100,   *
// *                que deben ser divisibles por 400 para ser con-   *
// *                siderados como bisiestos.                        *
// *      Retorno: un boleano o valor lógico.                       *
// *                Entero pasado por valor constante 'a'.           *
// *   Parámetros: El año en cuestión, un entero (a as integer) .   *
// * Precondición: El año pero sin saber si es bisiesto.            *
// *                { a = k, bisiesto = ? }.                         *
// * Postcondición: El año, sabiendo si es bisiesto o no.            *
// *                { a = k, bisiseto = verdadero | falso }.         *
// *         Autor: Augusto César Molina.                            *
// *      Ceado el: 23-SEP-2009.                                     *
// * Modificado el: 06-OCT-2009 por A.C.M. - Intradocumentación      *
// *******************************************************************
long int dias(int m1, int m2, int a1, int a2)

{

   int i;
   int j;
   int nDias = 0;

   if(a1 == a2)
   {
      for(i = m1; i <= m2; i++)
      {
         nDias = nDias + ultimo(i, a1);
      }
   }
   else
   {
      for(i = m1; i <= 12)
      {
         nDias = nDias + ultimo(i, a1);
      }

      for(j = a1 + 1; j <= a2 - 1; j ++)
      {
         for(i = 1; i<= 12; i++)
         {
            nDias = nDias + ultimo(i, j);
         }
      }

      for(i = 1; i <= m2; i++)
      {
         nDias = nDias + ultimo(i, a2);
      }
   }
}

#endif

Escrito por cursodecpp el 27/10/2009 22:05 | Comentarios (0)

Laboratorio Nro. 1

Cátedra: Lenguajes de Programación

Unidad Curricular: Lenguaje de Programación III (C, C++)

Profesor: Augusto César Molina Y.

Laboratorio Nro. 1: Familiarizarse con el entorno de trabajo, instalar el sistema Dev-CPP y compila el primer programa en C.

Paso 1: Ubicar el ícono del sistema integrado de desarrollo y compilación para C y C++ denominado DEV-C++ Portable, versión 4.9.9.2 que está ubicado en el directorio local “Mis Documentos” y cuyo nombre es “Dev-CppPortable_4.9.9.2_Revision_4.PAF.