0.1 Instalación del Visual C++

Aquí les dejo los pasos para instalarse una versión del Visual C++. Si bien es una versión de evaluación, cubre todas las necesidades del curso.

1° Paso: ir a www.microsoft.com. Una vez en el sitio, elegir las opciones del menú "Downloads" y "Download Center"






2° Paso: En el Download Center, elegir la opción "Visual Studio"

3° Paso: En la página de Visual Studio hay varias opciones para descargar (muchas de ellas requieren licencia o caducan a los pocos días).
Elegir en la sección "Visual Studio 2010 Express", la solapa "Visual C++ 2010 Express". Hacer click en "Instalar ahora".


 Al hacer click, se descargará el archivo vc_web.exe.

4° Paso: Una vez descargado, ejecutarlo y comenzará la instalación.
Durante la instalación, se debarán aceptar los términos de la Licencia. Luego se presenta la opción de descargar también componentes de SQL Server 2008. Son componentes para Administración de Bases de Datos, y no es necesario descargarlos para este curso.

Una vez instalado, se deberá reiniciar la PC y el Visual C++ ya está listo para ser utilizado. 



 




0.2 Escribir programas en Visual C++

Vamos ahora cómo poder ejecutar programas sencillos como los vistos en clase, en Visual C++2010 Express. En otras versiones del lenguaje, puede haber más o menos diferencias con respecto a lo que explicamos acá.

Al abrir el programa, se debe seleccionar en el menú: Archivo ==> Nuevo --> Proyecto.

El Visual C++ trabaja los programas como "Proyectos". cada proyecto incluye al archivo con el programa (archivo .cpp), el archivo ejecutable ( .exe) y otros archivos que utilice el programa. Todos estos archivos se guardan en una carpeta, dentro de la carpeta "Proyectos".
Se muestra entonces la solapa "Nuevo Proyecto":


Pantalla de "Nuevo Proyecto"

En esta ventana se presentan los diferentes tipos de aplicaciones que se pueden crear. Elegiremos siempre: Aplicación de Consola Win32.
Además, se debe colocar el nombre del proyecto. Abajo se indica la carpeta en donde se guardarán los archivos del mismo.
Según la configuración elegida, puede aparecer una ventana del asistente de aplicaciones. Si es así, dar click en "finalizar".

Se presenta entonces la ventana donde podremos escribir nuestro programa:





Pantalla de edición del programa, en blanco.

Las líneas en verde son comentarios, para incluir un comentario se debe escribir // al comienzo de la línea y todo lo que se escriba a continuación será un comentario (el compilador lo ignorará al ejecutar el programa)


Luego de los comentarios, hay un include, la línea "#include "stdafx.h". Este archivo contiene extensiones del Visual Studio necesarias para la mayoría de los programas, así que la dejaremos, comenzando nuestro programa a continuacíon. (borrando el ejemplo de main que se muestra por default en el archivo).

 
Pantalla de edición del programa, con el programa ya escrito.

Escribimos nuestros includes siguiendo al stdafx. Se debe tener en cuenta que el formato correcto del iostream en esta versión de visual C++ es:

#include "iostream" using namespace std;

Esto es:
- sin .h
- entre comillas
- using namespace std; indica los parámetros del iostream. Van a ser siempre los mismos (std).

Luego escribimos el programa, y antes del final agregamos una línea "cin>> x". Este cin, que pide que el usuario ingrese un valor en la variable x no hacen nada con dicho valor, sólo cumple la función de hacer una pausa al finalizar el programa hasta que el usuario ingrese un valor. Esta pausa servirá para que el usuario pueda ver el programa, ya que de lo contrario la ventana del programa se cerraría muy rápido antes de poder ver los resultados.

Una vez escrito el programa, podemos ejecutarlo.Para ello seleccionaremos en el menú "Depurar" la opción "Iniciar depuración". Otras formas alternativas son cliquear el triangulito verde en la barra de íconos, o presionar la tecla F5.
Al hacer esto, si el programa no tiene errores, se compila el programa, se genera el archivo .exe (en la carpeta del proyecto) y se ejecuta, abriendose en una ventana nueva.
Una vez hecho esto, si quiero ejecutar el programa nuevamente no preciso abrir el C++, simplemente puedo buscar el archivo .exe en la carpeta del proyecto y ejecutarlo.

 Programa de ejemplo, corriendo directamente desde Windows.
 














1.1 - Primer programa en C++

Veamos el siguiente programa en C++:

 // ejemplo1.cpp: Primer programa en C++
#include "stdafx.h"
#include <iostream>
using namespace std;
void main()
{
        cout<<"¡Hola Mundo!";
}

Pueden copiar y pegar este programa en cualquier compilador de C++. Este programa está hecho en Visual C++, para correrlo en otra versión de C++ sólo deben eliminar la segunda línea
#include "stdafx.h"


Este es un programa muy sencillo que muestra por pantalla el texto "HOLA MUNDO!" A pesar de ser tan sencillo, tiene varias líneas con diferentes instrucciones. Las cuatro primeras líneas, no son instrucciones propiamente dichas, sino mensajes al compilador, acerca de cómo debe "armar" el programa ejecutable.
La prmera línea

           // ejemplo1.cpp: Primer programa en C++

es un comentario. Todo lo que se escribe después de las dos barras // es tomado por el compilador como un mensaje a los programadores que vayan a leer el programa y por lo tanto, es ignorado al momento de ejecutar el programa.
Las siguientes tres líneas

          #include "stdafx.h"
          #include <iostream>
          using namespace std;

son instrucciones para el compilador: Le indican al C++ cómo debe "armarse" el programa ejecutable.
El programa propiamente dicho empieza en la línea

          void main()

y todo lo que está entre las llaves {    } es la parte ejecutable del programa.
main (principal en inglés) es el nombre del programa, y debe ser siempre el mismo. Cuando se ejecuta el programa, el procesador busca la función llamada main y a partir de allí comienza a ejecutar las demás instrucciones. Si nuestro archivo no contiene una función llamada main, el programa no podrá ejecutarse.
La palabra void indica el tipo de función que es, al igual que los paréntesis () a continuación del nombre. Por ahora, todos los programas que haremos serán void main(), ya veremos otras opciones en la entrada dedicada a funciones.

Pasemos ahora a el contenidodel del programa, esto es lo que está entre las llaves {}:

Este programa consta de una única instrucción,
 
         cout<<"¡Hola Mundo!";

La instrucción cout se utiliza para mostrar cosas por pantalla, en este caso el texto "HOLA MUNDO". En C++, todo lo que está entre comillas dobles se considera como texto, y el programa lo copiará literalmente, sin analizar su contenido.
La instrucción cout no es una instrucción "estándar" de C++, sino que ha sido programada utilizando otras instrucciones fundamentales. Al no ser estándar, se debe indicar al C++ en dónde se encuentra programada. Para ello están las primeras líneas del archivo:
     #include <iostream>
     using namespace std;
Allí se le indica al compilador que incluya el archivo "iostream" en nuestro programa. El archivo iostream contiene las definiciones necesarias para la instrucción cout. Como prácticamente todos los programas que hagamos van a tener que mostrar un resultado por pantalla, y por lo tanto usarán la instrucción cout, estas dos líneas también serán constantes en los diferentes programas. La segunda línea using namespace std; contiene parámetros acerca de cómo se usarán las instrucciones contenidas en iostream.

Podemos ver que las diferentes partes del programa están en diferentes colores, según su significado. Estos colores pueden variar según el software utilizado, en este caso (Visual C++) son:

Verde: indica comentarios para otros programadores que lean el código, serán ignorados por el compilador.
Azul: indica las palabras clave, los nombres de las instrucciones del lenguaje que no se pueden utlizar para otra cosa.
Rojo: Indica los caracteres literales y mensajes de texto, que serán copiados literalmente por el compilador, sin analizar su contenido.






Imagen del escritorio de Visual C++ con la ventana de ejecución del programa (La que tiene fondo negro). Por diferencias en la codificación de los textos, algunos caracteres especiales (¡ ¿ á é í ó ú ñ ü entre otros)  pueden no salir correctamente en pantalla.





1.2 Instrucciones secuenciales básicas

// ejemplo2.cpp: Instrucciones básicas
#include "stdafx.h"
#include <iostream>
using namespace std;
void main()
{
        int a,b,c;
        cout<<"Ingrese dos numeros:";
        cin>>a>>b;
        c=a*b;
        cout<<endl<<"El producto es "<<c<<endl;  

        cin>>a;
}

Este programa permite al usuario ingresar dos valores numéricos y muestra el producto de los mismos.
Veamos las instrucciones del mismo:

          int a,b,c;

Esta instrucción es una declaración de variables: Indica al programa que reserve espacio en la memoria de la computadora para tres valores, a los que de ahora en adelante se llamará como a, b y c. Estas variables tendrán valores enteros, ya que así lo establece la instrucción int (por integer, entero en inglés). A partir de ahora no interesa la posición de memoria en la que se guarden estas variables (incluso, puede ser una posición diferente cada vez que se ejecute el programa) ya que las utilizaremos mediante sus nombres.
Luego viene una instrucción cout que, como vimos en el ejemplo anterior, se utiliza para enviar un mensaje a la pantalla. En este caso, el texto "Ingrese dos números:".
La siguiente instrucción:

          cin>>a>>b;

es una instrucción de entrada de datos.  Lo que hace esta instrucción es esperar que el usuario ingrese un dato (por teclado) y guarda el dato ingresado en la variable que está luego de los signos ">>". En este caso, son dos variables, por lo que el programa espera dos valores distintos, separados por un espacio en blanco o presionando la tecla "Enter" luego de cada uno.

Las instrucciones cin y cout son las intrucciones de entrada y salida de datos (data in/out) del C++. Como ya dijimos antes, no están programadas en el núcleo de instrucciones del lenguaje (Vemos que no aparecen en azul como palabras reservadas), sino que están incluidas en el archivo <iostream>

Luego, hay una instrucción de asignación.

          c=a*b;

Esta instrucción resuelve la operación matemática que está a la derecha del signo "=". Para ello, busca en la memoria las variables llamadas a y b, reemplaza los nombres de las variables por el contenido de las mismas y luego ejecuta la operación. Finalmente, guarda el resultado de la operación en la variable a la izquierda del signo (c).
Se debe tener en cuenta que es una asignación y no una igualdad matemática. Se resuelve en dos pasos: primero se resuelve la operación de la derecha y luego se guarda el resultado en la variable de la izquierda. Por lo tanto, es perfectamente válida la asignación c=c+1 (que como igualdad matemática es falsa). Lo que hace es tomar el valor de c; sumarle 1 y guardar el resultado en c.
Finalmente, tenemos otra instrucción de salida:

          cout<<endl<<"El producto es "<<c<<endl;

Esta instrucción manda 4 cosas distintas a la pantalla. Primero, el caracter especial endl (fin de línea) Cada vez que se envía este caracter a la pantalla, el siguiente elemento que se envíe, aparecerá en la línea inferior. Luego, se envía el texto "El producto es " que, como está entre comillas, se envía a la pantalla textualmente. Luego se envía una c. Al no estar entre comillas, se interpreta como una variable. El programa busca una variable llamada c, y envía su contenido a la pantalla. (en este caso, el resultado de la operación anterior). Y por último, se envía otro caracter endl a la pantalla.
  


 Al final del programa, hay otra instrucción cin, que lee un valor en la variable a. Esta instrucción no cumple ninguna función en el programa, ya que al ingresar el valor, finaliza el programa y se borran todas las variables, incluyendo a, sin haber hecho nada con ello. El único objetivo de esta instrucción es que una vez finalizado, el programa haga una pausa esperando el dato, y así se evita que se cierre la pantalla antes de poder leer el resultado.







1.3 Variables

Una variable es un espacio en la memoria que se reserva para contener un dato de un tipo específico y se identifica con un nombre. El valor del dato contenido se puede modificar a lo largo del programa, de ahí el nombre de variable.

Tipos de datos

Los datos contenidos en las variables pueden ser de diferentes tipos:

int: Contienen datos numéricos enteros. Como mínimo los valores pueden ir de -32767 a  +32767 (cuando ocupa 2 bytes), aunque generalmente puede almacenar valores entre -2.147.483.648 y +2.147.483.647  (4 bytes)

float: Contiene datos numéricos "reales". Estrictamente hablando, no son valores reales, ya que éstos pueden tener infinitas cifras decimales, y la capacidad de almacenamiento de la memoria es limitada. Se almacenan como valores de punto flotante, separando la mantisa y el exponente.

Es conveniente utilizar variables de tipo entero siempre que sea posible, ya que las float tienen dos inconvenientes: por un lado, las operaciones matemáticas sobre estas variables son más lentas, y por otro, tienen un cierto margen de error por problemas de redondeo.

double: También contienen valores reales, con el doble de precisión que los float. Obviamente, ocupan el doble de espacio de memoria.

char: Contienen caracteres de texto. Una variable char pueden contener una letra (mayúscula o minúscula, un dígito 0...9 ó cualquier otro caracter especial.

Hay otros tipos, pero estos serán más que suficientes para el presente curso.

Nombres de variables

En los ejemplos variables, utilizamos como nombres de variables "a", "b" y "c". En un programa más largo o complicado, es conveniente utilizar nombres más descriptivos, tales como "saldo" ó "suma".
Los nombres de variables deben cumplir ciertas reglas:

- Pueden contener cualquier combinación de letras y números, aunque el primer caracter debe ser una letra. "suma1" es un nombre válido de variable; pero "1suma" no es un nombre válido, ya que empieza con un número.

- Se debe tener en cuenta que el lenguaje distingue entre mayúsculas y minúsculas. "suma", "Suma" y "SUMA" son tres variables distintas. Para evitar confusiones de este tipo, se recomienda utilizar sólo minúsculas para los nombres de variables.


1.4 Operadores matemáticos

Los operadores matemáticos en C++ son sencillos, casi todos ellos idénticos a los utilizados en matemática. Las operaciones fundamentales utilizan 5 operadores básicos:

     +  suma
     -   resta
     *  multiplicación
     /   división
     % resto

El operador resto o módulo realiza la división entre dos números enteros, pero en lugar del resultado, toma el resto de la división. Así

  10 % 3 = 1
  11 % 3 = 2
  12 % 3 = 0
  13 % 3 = 1
  14 % 3 = 2
  15 % 3 = 0, etc.

mientras que

  10 / 3 = 3
  11 / 3 = 3
  12 / 3 = 4
  13 / 3 = 4
  14 / 3 = 4
  15 / 3 = 5, etc.

Las primeras cuatro operaciones están definidas tanto como para valores int como float, mientras que el resto sólo está definido entre valores int. Intentar utilizar el operador % con valores float dará un error al intentar compilar el programa.

Un uso muy importante para el operador % es ver si un número es múltiplo de otro, ya que si a es múltiplo de b, entonces a % b == 0.

La precedencia de operadores es similar a la de las expresiones matemáticas:
- Primero se resuelven las operaciones entre paréntesis. Si hay varios paréntesis anidados, se resuelven desde adentro hacia afuera.
- Luego las multiplicaciones, divisiones y restos, de izquierda a derecha.
- Por último, las sumas y restas de izquierda a derecha.

Se debe tener en cuenta que las operaciones entre enteros darán como resultados valores enteros, incluso la división. Así, la operación

          a = 16 / 3

guardará en a el valor entero 5, incluso si a es una variable de tipo float. Para evitar este truncamiento, el dividendo o el divisor deben ser de tipo float. El resultado correcto se obtiene haciendo

          a = 16 / 3.0

Así, al ser el divisor un valor float (3.0), la operación se realiza como float y se guarda el valor 5.3333 en a (si también es de tipo float)

1.5 Formatos numéricos y de presentación (Opcional)


 (*) Los contenidos desarrollados en este artículo no son fundamentales para comprender el contenido posterior del curso, y pueden saltearse o leerse más adelante. Algunas de las instrucciones aquí explicadas pueden variar mucho o no existir en diferentes versiones de C++.



Supongamos un programa sencillo, que imprima las los cuadrados de los números de 1 a  20:



// ejemplo.cpp: muestra los cuadrados de los números 1 a 20
//

#include "stdafx.h"
#include "iostream"
using namespace std;

void main()
       {
             int i,r;
             cout<<"-----------"<<endl;
             for (i=1;i<=20;i++)
             {
                    r = i*i;
                    cout<<"| "<<i<<" | "<<r<<" |"<<endl;
             }

             cout<<"-----------";
             cin>>i;

}


La instrucción for se ve en el apartado 1.11. lo que hace el programa es generar sucesivamente los números de 1 a 20 y, para cada uno de ellos calcular su cuadrado.

El programa los debería mostrar ordenados en una tabla, pero el poco satisfactorio resultado es:


Como cada número tiene diferente cantidad de cifras, ocupan una cantidad diferente de espacios en pantalla y se hace imposible encolumnarlos.
Para resolver este problema, se utiliza el comando setw, que está incluido en el archivo iomanip. setw le indica a la instrucción cout cuantos espacios debe ocupar como mínimo el próximo elemento que se envíe a la pantalla. Así, setw(3) indica que el siguiente elemento debe ocupar por lo menos tres caracteres. Si es más corto, lo rellena con espacios en blanco. Si es más largo, lo imprime completo, ocupando más de los tres caracteres previstos. Así bastará indicar en cada setw un valor mayor a la longitud del elemento más largo de la lista, y así se podrá imprimir la misma encolumnada.
Se debe incluir un setw antes de cada elemento que se desea formatear, y la línea #include <iomanip> al principio.



// ejemplo.cpp: muestra los cuadrados de los números 1 a 20
//

#include "stdafx.h"
#include "iostream"
using namespace std;
#include <iomanip>

void main()
       {
             int i,r;
             cout<<"------------"<<endl;
             for (i=1;i<=20;i++)
             {
                    r = i*i;
                    cout<<"| "<<setw(2)<<i<<" | "<<setw(3)<<r<<" |"<<endl;
             }

             cout<<"------------";
             cin>>i;

}


Con estos dos simples cambios, el resultado del programa es mucho más prolijo:



Otro problema que suele ocurrir es al querer escribir textos con acentos o caracteres especiales, aparece en lugar de ellos algún símbolo extraño:



Para solucionar esto, sólo hay que intercalar una línea en el programa:

#include <iostream>
using namespace std;

int main()
{
    setlocale(LC_ALL, "spanish");
    cout <<endl<< " ¡Próspero año nuevo!!" << endl;
    return 0;
}

La instrucción setlocale indica el juego de caracteres que se utilizará para interpretar los char y los strings del programa.


Los acentos, eñes y signos de puntuación aparecen correctamente.




1.6 - Instrucciones de selección: if

Hasta ahora, las instrucciones que vimos eran instrucciones que se ejecutaban siempre en el orden en el que figuraban en el programa, una después de la otra. Por eso se llaman instrucciones de secuencia: No hay forma de evitar que se ejecuten ni de modificar el orden en que lo hacen.
Ahora vamos a ver la instrucción if, que permite decidir si ejecutar o no otras instrucciones. Por ello a las instrucciones con esta posibilidad se las llama instrucciones de selección o decisión.

El formato de la instrucción es:

if (condición)
     {
      .... (Otras instrucciones 1)....
     }
else
     {
      .... (Otras instrucciones 2)....
     };

La condición es una expresión lógica, cuyo valor puede ser verdadero o falso. Si dicho valor es verdadero, se ejecuta el conjunto de instrucciones que están a continuación del if (Otras instrucciones 1). Si el valor de la condición es falso, se ejecuta el conjunto de instrucciones que están a continuación del else (otras instrucciones 2). De manera que se ejecuta uno de los dos bloques de instrucciones, según el valor de la condición, pero en ningún caso se ejecutarán ambos bloques.

Veamos el siguiente ejemplo:
 
 // ejemplo3.cpp: Instrucción if
#include "stdafx.h"
#include <iostream>
using namespace std;

void main()
{
    int nota;
    cout << "Ingrese la nota:";
    cin >> nota;
    if (nota >= 4)
    {
        cout << "Aprobado, felicitaciones!"<<endl;
    }
    else
    {
        cout << "No aprobado."<<endl;
    };
    cout <<"Gracias por participar. Fin del programa.";

    cin>>nota; // Sólo para evitar que cierre la ventana demasiado rápido
}


El comienzo del programa es similar a los ya vistos: Solicita un valor al usuario y lo guarda en la variable entera nota. Luego, llegamos a la instrucción if.

La instrucción if analiza la condición que se encuentra entre paréntesis (nota>=4). Como tiene una variable, busca el contenido de dicha variable en la memoria (El valor que ingresó el usuario) y lo compara con 4. Si es mayor o igual, el resultado de la condición es verdadero y se ejecuta la instrucción cout que está a continuación del if. Si el valor ingresado por el usuario es menor que 4, el resultado de la condición es falso, y se ejecuta la instrucción que está a continuación del else.
Luego de ejecutar la instrucción que corresponda, según el valor de la condición, el programa continúa normalmente con la instrucción siguiente al if:
       cout <<"Gracias por participar. Fin del programa.";

Se debe tener en cuenta el formato de la instrucción if, que debe cumplir ciertas reglas:
- La condición va siempre entre paréntesis, y no se debe colocar punto y coma luego de la misma.
- Luego, entre llaves, las instrucciones que se ejecutan si la condición es verdadera. No se debe colocar punto y coma luego de cerrar la llave. Si se coloca punto y coma aquí o luego de la condición, el programa considerará que aquí termina la instrucción if, y no sabrá interpretar el else.
- Por último, la palabra else y, también entre llaves, las instrucciones que se ejecutarán si la condición es falsa. Luego de esta llave sí se coloca el punto y coma, que indica el final de la instrucción if.
- Si dentro de las llaves hay una sóla instrucción (como en este ejemplo) pueden omitirse dichas llaves, aunque muchas veces sea conveniente dejarlas para dar mayor claridad al programa. Si hay dos o más instrucciones, las llaves son obligatorias.
- A veces, no hay instrucciones para ejecutar si la condición es falsa. En ese caso, se omite también la palabra else. Quedará un if sin else:

if (condición)
     {
      ...
     };

En este caso sí va el punto y coma luego de la llave del if, precisamente para indicar que allí termina la instrucción y que no hay else.
- Las instrucciones que van dentro de los bloques if o else, pueden ser cualquier tipo de instrucciones, incluso otras instrucciones if.
- Las diferentes condiciones que se pueden incluir en un if utilizarán operadores lógicos, que veremos a continuación.

1.7 Condiciones y Operadores relacionales

Dijimos que una condición es una expresión cuyo valor puede ser verdadero o falso, y pusimos el ejemplo

     ( nota >= 4 )

que resultaba verdadero si la variable nota contenía un malor mayor o igual a 4, o falso si dicho valor era menor.

El signo >= que compara los dos elementos, se llama operador relacional, y hay 6 operadores de este tipo definidos en C++:

     >=   mayor o igual
     <=   menor o igual
     >     mayor
     <     menor
     !=   distinto
     = = igual

Nótese que el operador "igual" lleva dos signos de igualdad, para diferenciarlo de la asignación:

a = 27    // Es una asignación, guarda el valor 27 en a y devuelve un valor verdadero si puede hacer la asignación (En la práctica, devuelve siempre verdadero)

a = = 27   // Es una comparación, devuelve verdadero si a es 27 ó falso si tiene otro valor. No cambia el contenido de a.

Una comparación sólo puede analizar dos elementos a la vez, por lo que la comparación de tres

   (a = = b = = c)

no es válida y es un error.

Para realizar esta comparación, se deben comparar de a dos: (a = = b) y (b = = c). Esta comparación se realiza utilizando el operador lógico && (and)

     (( a = = b) && (b = = c)) 

Esta operación da verdadero cuando se cumplen ambas comparaciones. Si al menos una de las comparaciones es falsa, la condición da falso.

De la misma manera, se utiliza el operador lógico || (or)

     (( a = = b) || (b = = c)) 

Esta condición da verdadero si al menos una de las comparaciones es verdadera.

Veamos el siguiente ejemplo:



// ejemplo4.cpp: DEterminar si un año es bisiesto o no
// Un año es bisiesto si es múltiplo de 4 y no es múltiplo de 100, a menos que sea múltiplo de 400.

#include "stdafx.h"
#include <iostream>
using namespace std;
void main()
{
       int a;
       cout<<"Ingrese un año:";
       cin>>a;
       if (a%4!=0)
       {
             cout<<"No es bisiesto";
       }
       else
       {
             if (a%100!=0)
             {
                    cout<<"Es bisiesto";
             }
             else
             {
                    if (a%400!=0)
                    {
                           cout<<"No es bisiesto";
                    }
                    else
                    {
                           cout<<"Es bisiesto";
                    }
             }
       }
       cin>>a;
}



Este programa utiliza tres instrucciones if una dentro de la otra para ver si un año es bisiesto o no. Utilizando los operadores || y && es posible escribirlo mucho más fácilmente:



// ejemplo4.cpp: DEterminar si un año es bisiesto o no
// Un año es bisiesto si es múltiplo de 4 y no es múltiplo de 100, a menos que sea múltiplo de 400.

#include "stdafx.h"
#include <iostream>
using namespace std;
void main()
{
       int a;
       cout<<"Ingrese un año:";
       cin>>a;
       if ( (a%4!=0) || ( (a%100==0) && (a%400!=0) ) )
       {
             cout<<"No es bisiesto";
       }
       else
       {
             cout<<"Es bisiesto";
       }

       cin>>a;
}