(Clases Parte 3) Curso de Creación de Videojuegos


Curso de Creación de Videojuegos (Presentación)


Curso de Creación de Videojuegos (Nociones Generales)



Curso de Creación de Videojuegos (Introducción)



Curso de Creación de Videojuegos (Disparo Torreta)



Curso de Creación de Videojuegos (Efecto Torreta) 



Curso de Creación de Videojuegos (Tanque IA Basico)



Curso de Creación de Videojuegos (Sistema de Vida Tanque)



Curso de Creación de Videojuegos (Sistema de regeneración)



Curso de Creación de Videojuegos (Optimización de escena)




Curso de Creación de Videojuegos ("IA-Waypoints")





Como aprender a programar desde 0 (parte 11)


Cómo aprender a programar y no morir en el intento – Parte 11

Así que sin más introducción, los invitamos a seguirnos después del salto, en esta edición número 11 de “Cómo aprender a programar y no morir en el intento”, en donde empezaremos a cubrir un nuevo paradigma de desarrollo: Programación orientada a objetos.

Cómo aprender a programar y no morir en el intento – Parte 11

Contenidos:

  1. Introducción a la programación orientada a objetos.
  2. Programación orientada a objetos vs Programación estructurada.
  3. Hola, soy un objeto.
  4. Clases.
  5. Métodos.
Así que sin más, vamos, manos a la obra:

1.- Introducción a la programación orientada a objetos:

La programación orientada a objetos (o POO para los más amigos), es un paradigma de desarrollo definido y utilizado por una serie de lenguajes de programación que busca afrontar el desarrollo de aplicaciones desde un enfoque distinto al estructurado (que hemos visto hasta la fecha), mediante la definición y uso de, valga la redundancia, objetos que operen bajo un prisma similar a como vemos, reconocemos y actuamos las situaciones de la vida real.
A la fecha se ha convertido en el paradigma preferido por los principales lenguajes de programación, debido a una serie de ventajas (que iremos viendo a medida que avancemos) que permiten que el desarrollo sea más simple, seguro y completo. Si bien la transición desde el inicio a esta parte puede ser un poco compleja, especialmente por el cambio en el enfoque que se hace, una vez que las bases se entienden y dominan se puede comprender que es bastante simple.
Solo como referencia, algunos lenguajes que trabajan bajo este paradigma:
  • C++.
  • Java.
  • PHP (Desde la versión 5)
  • Ruby.
  • Objective C.
  • Python.
Iremos viendo nueva información en cada parte de esta nueva etapa con el fin de ir aprendiendo un poco más y no extendernos en demasía en un solo número.

2.- Programación orientada a objetos vs Programación estructurada:

Es inevitable que al comenzar a aprender un nuevo paradigma, empiecen las comparaciones y diferenciaciones de lo que ya se sabe. Y en este caso no será ninguna diferencia.
A la fecha todo lo que hemos visto en esta saga es relacionado al desarrollo estructurado, en el cual basicamente nos dedicamos a escribir programas con una lógica directa en base a una “plantilla”, la cual contiene código que es compilado y ejecutado desde un inicio hasta el final.  Esta lógica opera bajo el uso de funciones y procesos que operan sobre una serie de datos de entrada y que finalmente nos despliegan resultados o salidas que dependen de cada tarea que se realizó. Bastante simple, de arriba a abajo, de principio a final.
Por otro lado, en la POO, cambiamos el enfoque y comenzamos a hablar de objetos y clases. Si bien seguimos utilizando elementos clásicos de la programación estructurada, o bien de la programación propiamente tal como variables, ciclos e iteraciones, la base se rige por estos 2 elementos y es así como nuestras aplicaciones operan, lo que podremos ir viendo de forma clara a medida que vayamos desarrollando ejemplos.
Si hicieramos un paralelo entre ambos paradigmas, algo que probablemente no sea correcto, pero a modo de ejemplo quizás nos aclare más los conceptos, si en la programación estructurada en ocasiones trabajamos con librerías, las cuales contienen funciones, en la programación orientada a objetos trabajamos con clases, las cuales a su vez contienen métodos, y estos operan sobre cada uno de los objetos que declaremos. Como indicábamos, lo anterior solo sirve para hacer un paralelo, ya que en lo real varía un poco.
No obstante, a medida que nos adentremos más en el tema, iremos viendo una serie de características en las que podremos ir estableciendo comparaciones y que finalmente nos servirá para entender de mejor manera todo esto.
Sin embargo, independiente de cuantas comparaciones o definiciones veamos, siempre llegaremos a las 2 unidades base que mencionábamos antes y que comenzaremos a ver a continuación: Objetos y clases. A partir de esto, es posible ir escalando el conocimiento relacionado a la programación orientada  a objetos, y eventualmente empezar a desarrollar de aquella forma.

3.- Hola, soy un objeto:

Y llegamos a la unidad básica que de ahora en adelante aparecerá en cada cosa que veamos y en cada ejemplo que codifiquemos: Los objetos.
Si entramos a la definición más purista del paradigma, es posible definir un objeto como todo lo que vemos en el mundo real. Desde una casa, hasta un perro o incluso una fruta, todo es reconocido de esta forma y como tal debe ser modelado para luego poder operar sobre el.
Los objetos son la base de la POO, tal como indica el mismo nombre, y por ende es necesario cambiar la forma en que modelamos, diseñamos y desarrollamos aplicaciones para ajustarnos a este nuevo enfoque. Desde el inicio más básico hasta lo más avanzado, siempre operaremos en torno a ellos y serán lo que construirán y definirán los distintos procesos que utilizaremos.
Un objeto es definido, y diferenciado de otros, por sus características o atributos, tal como lo vemos en la vida real. Por ejemplo, si tomamos dos casos arbitrarios que consideraríamos objetos en la vida real, como una persona y un auto, es posible ver que cada uno de ellos posee atributos que lo diferencian el uno del otro:
  • Persona – Sus atributos serían: Nombres, Apellidos, Edad, etc.
  • Auto – Sus atributos serían: Marca, color, patente, etc.
Si comparamos los ejemplos anteriores, sus atributos específicos son los que nos ayudan a diferenciar cuando hablamos de uno y cuando hablamos del otro. En el caso de la POO es exactamente lo mismo. Definimos objetos y los diferenciamos en base a sus atributos. Posteriormente, dependiendo del objeto que tratemos, operamos de acuerdo a sus características para ejecutar procesos y obtener resultados, tal como cualquier tipo de programación.
Como podemos ver, esta es una definición bastante básica, e intencionalmente ha sido así considerando que este es nuestro primer acercamiento al paradigma. A medida que vayamos avanzando iremos viendo otros detalles importantes. Pero no se preocupen, con esto por ahora podremos seguir avanzando sin problemas. La intención es que vayamos comprendiendo cada concepto desde su punto de vista más básico y de a poco interiorizarnos en temas más avanzados.

4.- Clases:

Hemos hablado de los objetos y ahora es momento de cubrir el otro punto base que habíamos indicado.
¿Por dónde partir? Por lo más básico.
En su definición más básica podemos decir que una clase es una plantilla que describe a un objeto. ¿Cómo lo describe? con 2 partes:
  • Sus características.
  • Su comportamiento.
La manera en que una clase describe las características de un objeto es mediante la definición de sus atributos. Si, exactamente los mismos atributos que mencionábamos más arriba que ayudan a diferenciar a un objeto de otro. Al definirlos se nos dice que son estos, y solamente estos, los atributos reconocidos para tal objeto y los que nos servirán como base para operar en nuestras aplicaciones.
Por otro lado, describe el comportamiento de un objeto mediante la definición de métodos, los cuales operan y ejecutan tareas sobre los atributos de un objeto en particular entregándonos resultados para su respectivo despliegue.
La estructura básica de una clase es como sigue:
  • Definición de la clase.
  • Definición de atributos.
  • Métodos.
Tan simple como eso. A medida que veamos ejemplos podremos ir desglosando cada una de esas partes para un análisis más detallado.

5.- Métodos:

Un método es una función, declarada en una clase, que tiene como fin operar sobre un objeto para ejecutar tareas sobre sus atributos y obtener resultados, ya sea para seguir operando, o bien para entregar una salida al sistema y desplegarla en pantalla al usuario de la aplicación.
Tal como cuando se definían funciones en el desarrollo estructurado, los métodos corresponden a un tipo de dato que debe coincidir con el resultado que retornan.
Por ej: Podemos definir un método de tipo int que se llame retornaEdad y que devuelva un entero que contiene la edad de un objeto de tipo persona. Si este método fue definido como entero, no puede devolver un tipo de dato distinto, debido a su definición inicial.
Todos los métodos que definamos deben devolver un tipo de dato que coincida con su definición, a excepción de los tipo void, que tal como en la programación estructurada, pueden no devolver nada.
También, al igual que en las funciones, los métodos pueden recibir parámetros que pueden ser utilizados en sus operaciones internas para producir resultados.
En una clase cualquiera, declararemos siempre como mínimo 2 tipos de métodos: 1 que crea el objeto(constructor – que veremos en el próximo número) y 1 o más que operen sobre el objeto creado.
Con esta definición de los métodos, daremos por concluida la parte 11 de Cómo aprender a programar y no morir en el intento. Sabemos que este número ha sido mucho más conceptual que técnico y práctico, pero tengan paciencia. Los conceptos explicados acá son necesarios de entender antes de empezar a meter mano de lleno, algo que haremos desde el próximo número cuando ya empecemos a codificar nuestra primera aplicación.
Fin

Como aprender a programar desde 0 (parte 10)


Cómo aprender a programar y no morir en el intento – Parte 10

 

Contenidos:

  1. Métodos de ordenamiento: Método de la burbuja.
  2. Métodos de búsqueda: Método secuencial.
  3. Funciones.
  4. Añadiendo un menú al terminal de venta.
Vamos, manos a la obra:

1.- Métodos de ordenamiento: Método de la burbuja.

En un escenario normal, el 99,9% de los programas que realicemos operan con una cantidad de datos mediana a alta, los cuales pueden ser o no ingresados por un usuario y son almacenados en distitnos medios, ya sea en variables, arreglos o archivos entre otras cosas.
Ahora, en un escenario más normal aún, estos datos nunca estarán necesariamente ordenados bajo algún criterio en particular, por lo que si necesitaramos acceder a ellos bajo un orden especial, sería imposible lograrlo por si solo.
Para esto es que en la programación existen los métodos de ordenamiento, los cuales son básicamente algoritmos que realizan una lectura de una serie de datos y un posterior ordenamiento de acuerdo a ciertos criterios(alfabeticamente, menor a mayor, etc).
Existen una serie de métodos de ordenamiento como el de la burbuja, quicksort, inserción, selección, etc. Cada uno de ellos se diferencia del otro tanto en su funcionamiento como en el costo (de ejecución) que significan para el programa en sí.
¿Qué método utilizar?
Si bien, como decíamos, cada método presenta ciertas ventajas por sobre otro, en ningún caso son diferencias radicales y en estricto rigor no se notan a menos que trabajemos con cantidades másivas de datos, por lo que el consejo por ahora es utilizar el método que encontremos más sencillo y/o nos acomode más. A pesar de esto hay escenarios que presentan una mejor adaptabilidad a un método en particular. Ya iremos viendo más de esto en futuras guías.
Partiendo veremos uno de los métodos más conocidos y utilizados como es el método de la burbuja, llamado de esta forma por la forma en que se realiza el ordenamiento de datos, emulando una burbuja.
¿Cómo funciona el método de la burbuja?
Este método, utilizado comunmente cuando se necesita ordenar datos dentro de un vector o una matriz, funciona mediante el uso de 4 variables:
  1. Un vector o matriz donde están almacenados los datos.
  2. Una variable que recorre el vector.
  3. Una variable que recorre el vector una posición más adelante que la variable anterior.
  4. Una variable auxiliar.
La forma de funcionamiento es bastante simple: Nuestro vector es recorrido por una variable (la definida en el número 2) y por otra en una posición más adelante. Vamos realizando una comparación entre las 2 variables y si se cumple el criterio establecido se hace un movimiento circular: El valor más adelantado pasa a la variable auxiliar, el valor más atrasado pasa a la posición adelantada y el valor de la variable auxiliar pasa a la posición retrasada. Esto se realiza hasta que se alcanza el final del vector en cuestión.
Veamos un ejemplo de este método de ordenamiento:
Ejemplo: Ordenar un vector de tamaño 5 de menor a mayor mediante el método de la burbuja (los comentarios, como siempre, en negrita, cursiva y entre /* y */):
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
 // Incluimos las librerías
int main()
{
int arreglo[5], aux, i, j;
/* Declaramos las siguientes variables:
arreglo = Un vector de 5 posiciones donde tendremos los valores.
i,j = Variables para recorrer el vector.
aux = Variable para guardar un valor mientras lo ordenamos
*/
printf (“Ingrese valores para llenar el vector:\n”);
// Mostramos un mensaje e introducimos valores al vector
for (i=0; i< 5; i++)
scanf(“%d”,&arreglo[i]);
/* Luego, ordenamos el vector mediante el algoritmo de burbuja:
Recorremos el vector con una variable más adelantada que la otra y
comparamos. Si el valor de la posición actual es mayor al de una
posición más, guardamos el valor actual en la variable auxiliar,
luego en la posición actual ponemos el valor de la posición siguiente
y en la posición siguiente guardamos el valor de la variable auxiliar*/
for (j=1; j <= 5; j++)
for (i=0; i< 4; i++)
if (arreglo[i] > arreglo[i+1])
{
aux = arreglo[i];
arreglo[i] = arreglo[i+1];
arreglo[i+1] = aux;
}
printf (“\nValores ordenados exitosamente!\n”);// Mostramos el vector ordenado
for (i=0; i< 5; i++)
printf (“arreglo[%d] = %d\n”, i, arreglo[i]);
getch();
}
Como podemos ver, es un algoritmo bastante simple que cumple la función solicitada, ordenar de menor a mayor aplicando el método de la burbuja. Existen otros métodos que serán de mayor utilidad cuando trabajemos con una cantidad de datos mayor, pero por ahora con este podremos cumplir el objetivo sin problemas.

2.- Métodos de búsqueda: Método secuencial

Una funcionalidad que siempre es útil al momento de hacer un programa, es la de poder buscar un dato específico del que necesitamos saber información o bien trabajar con el.
En lenguajes de programación de 3a generación, orientados al proceso, como C, existen una serie de métodos de búsqueda que nos permiten cumplir esa tarea, entre ellos podemos destacar la búsqueda secuencial, la binaria, acceso directo y el trabajo mediante índices.
¿En que se diferencian?, tal como en el caso de los métodos de ordenamiento, cada uno de estos métodos se separa de otro por la forma en la que trabajan y el costo de ejecución que implica para el programa en sí. Todas a su vez tienen una serie de ventajas y desventajas, siendo la más “costosa” de todas la búsqueda secuencial, debido a que su forma de trabajo es buscar una referencia indicada registro por registro, uno a la vez como si examináramos una serie de filas una por una hasta encontrar lo que buscamos. Sin embargo, es esta última, la más sencilla de implementar y la que menos requerimientos tiene.
Su funcionamiento se explica mediante el siguiente algoritmo:
Consideremos que tenemos un vector, el cual está lleno de códigos numéricos de productos de un supermercado y necesitamos buscar un producto en particular. Al ingresar el código a buscar y decirle al programa que lo ubique en tal vector, operaría de la siguiente manera:
  1. Va a la posición 1.
  2. Compara el valor de esa posición con el ingresado a buscar.
  3. Si son iguales lanza un mensaje o guarda la posición para futuras referencias.
  4. De lo contrario pasa a la posición siguiente.
  5. Repite pasos 2,3,4.
Como podemos apreciar, es un funcionamiento simple y básico, pero que funciona. El gran problema radica cuando estamos operando con una cantidad masiva de datos, ya que los accesos a memoria serían demasiados y el costo de ejecución (algo que los programadores siempre deben tener en cuenta) sería alto.
Adicionalmente es bueno añadir que ese ejemplo referencia a un escenario ideal donde los códigos no están repetidos. En caso de que lo estuviesen, deberíamos avisar en cada posición que se encuentre una coincidencia.
Veamos un ejemplo de búsqueda secuencial:
Ejemplo: Llenar un vector de tamaño 5 con números y luego buscar algún valor y mostrar por pantalla la posición en la que se encuentra:
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
 // Incluimos las librerías
int main()
{
int arreglo[5],i,valor,x;
/* Declaramos las siguientes variables:
arreglo = Un vector de 5 posiciones donde tendremos los valores.
i = Variable para recorrer el vector.
valor = Variable para guardar el valor a buscar
x = Bandera que utilizamos para marcar que hayan valores.
*/

x=0; // Dejamos como 0 a x, lo que significa que no se han encontrado coincidencias
printf (“Ingrese valores para llenar el vector:\n”);// Mostramos un mensaje e introducimos valores al vector
for (i=0; i< 5; i++)
scanf(“%d”,&arreglo[i]);
// Solicitamos que se ingrese un valor a buscar
printf(“\nIngrese un valor a buscar: “);
scanf(“%d”,&valor);
/* Recorremos el vector y vamos comparando las posiciones con el valor a buscar,
si hay una coincidencia, mostramos la posición por pantalla y marcamos la variable
x con un 1 para indicar que se encontro valor */
for (i=0; i < 5; i++)
if (arreglo[i] == valor)
{
printf(“\nEl valor se encuentra en la posicion %d”,i);
x=1;
}
if(x==0)
printf(“\nNo se encontraron coincidencias”);
getch();
}

3.- Funciones

En la Parte 6 de esta saga, veíamos en una primera instancia lo que eran las funciones cuando hablabamos de pseudo-código. Los conceptos son exactamente los mismos, así como la forma de funcionamiento y operación de la función en sí, es decir:
tipo nombre_funcion(valor 1, valor 2… valor n)
{
operación 1;
operación 2;
.
.
operación n;
retorno de valor;
}
Veamos un ejemplo para dejar todo más claro:
Ejemplo: Determinar el mayor entre 2 números mediante el uso de una función:
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
 // Incluimos las librerías
int numero_mayor(int valor1, int valor2); // Declaramos inicialmente la función
int main()
{
int num1, num2, mayor; //Declaramos las variables que utilizaremos
// Pedimos que se ingresen los numeros
printf(“\nIngrese Numero 1: “);
scanf(“%d”,&num1);
printf(“\nIngrese Numero 2: “);
scanf(“%d”,&num2);
// A mayor le asignaremos el resultado de la función 
mayor=numero_mayor(num1,num2);
// Mostramos el resultado por pantalla
printf(“\nEl numero mayor es: %d”,mayor);
getch();
}
int numero_mayor(int valor1, int valor2) // Recibimos los valores
{// Comparamos cual es mayor y lo retornamos
if(valor1>valor2)
return valor1;
else
return valor2;
}

4.- Añadiendo un menú al terminal de venta

Siguiendo con nuestro clásico ejemplo del terminal de ventas, si recordamos, la última vez habíamos dejado nuestro ejemplo adaptado para poder realizar más de una venta y vender en cada una de ellas más de un producto.
Bueno, el trabajo que realizaremos hoy será confeccionar un menú para que la aplicación sea más completa y la función de ventas solo sea una parte de ese menú.
Como recordaremos, al final del ejemplo anterior, teníamos el siguiente código:
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
 /* Incluimos las librerías */
int codigo, cantidad, valor, total, vuelto, pago; /* Declaramos las variables que usaremos en el proceso */int ok=1; /* Adicionalmente declaramos una variable ok, que nos servirá de bandera para un ciclo que usaremos */
int opcion=1; /* Declaramos una variable opcion, que regulara si queremos hacer más de una venta */
int main()
{
while(opcion==1)
{
while(codigo!=4)
 /* Definimos un ciclo que se ejecute siempre que el usuario no presione la tecla para finalizar la venta */
{
printf(“\t Lista de productos\n”);
 /* Listamos los productos */
printf(“Codigo\t Nombre\t Precio\n”);
printf(“1\t Silla\t 100\n”);
printf(“2\t Puerta\t 350\n”);
printf(“3\t Sillon\t 200\n”);
printf(“\nPara cerrar la venta, presione 4″);
 /* Añadimos la opción para cerrar la venta */
printf(“\nIngrese el codigo del producto que desea llevar: “); /* Pedimos el código del producto */scanf(“%d”,&codigo);    /* Leemos el código del producto */
if(codigo==4) /* Si el código es igual a 4, significa que la venta está finalizada, así que cerramos el proceso de venta */break;
printf(“\nIngrese la cantidad que desea llevar: “);
 /* Pedimos la cantidad */scanf(“%d”,&cantidad); /* Leemos la cantidad */
if(codigo==1) /* Igualamos el código para asignar el precio */
valor=100;
if(codigo==2)
valor=350;
if(codigo==3)
valor=200;
total=total+(valor*cantidad); /* A total le asignamos, el total acumulado hasta ahora, más el nuevo valor y nueva cantidad, multiplicados entre sí */
}
printf(“\nEl total es de: %d”,total);
 /* Saliendo de la venta, indicamos el total */
while(ok==1) /* Declaramos un ciclo con la variable ok, para el proceso de pago y vuelto, así se ejecutará hasta que se pague la cantidad correcta */
{
printf(“\nIngrese el pago: “);
 /* Solicitamos el pago */
scanf(“%d”,&pago); /* Leemos el pago */
if(pago<total) /* Si el pago es inferior al total, mostramos un mensaje de error */
printf(“\nEl pago no es suficiente”);
else
 /* De lo contrario, cambiamos el valor de ok para romper el ciclo y mostramos los mensajes de vuelto */{
ok=0;
vuelto=pago-total;
printf(“\nEl vuelto es de: %d”,vuelto);
}
}
printf(“\n¿Desea hacer otra venta? (1=Si , 0=No): “); /* Preguntamos si desea hacer otra venta */scanf(“%d,”,&opcion); /* Leemos la respuesta */
}
printf(“\nVenta finalizada”); /* Mensaje final */
getch(); /* Programa en pausa hasta pulsar una tecla */
}
Todo aquel código se refiere a lo que nombraríamos como “módulo de ventas”, que es la funcionalidad principal del programa. Para confeccionar un menú, algo muy conveniente es hacer uso de un ciclo tipo do-while y un switch, de la siguiente forma, utilizando una nueva variable llamada menu para recoger la opción elegida, nuestro programa quedaría así:
llamado a librerías
declaración de variables
inicio de función main
do
{
printf(“1.- Módulo de ventas\n”);
printf(“2.- Administrar productos\n”);
printf(“3.- Administrar clientes\n”);
printf(“4.- Cerrar sistema\n”);
printf(“Ingrese opción: “);
scanf(“%d”,&menu);
switch(menu)
{
case 1: Aquí insertaríamos nuestro código anterior del módulo de ventas
break;
case 2: Por ahora en blanco, pero iría el código para administrar los productos
break;
case 3: Por ahora en blanco, pero iría el código para administrar los clientes
break;
case 4: break;
}
}while(menu!=4);
fin de función main
Con ese código, que dejaríamos al principio de nuestro programa, insertando el código anterior en el caso 1 del switch, le diríamos al menú que se ejecutase hasta que se seleccione la opción 4, que es cerrar sistema.
No es un código difícil de implementar, solo debemos fijarnos en el orden y no tendremos problemas.
Fin

Como aprender a programar desde 0 (parte 9)


Cómo aprender a programar y no morir en el intento – Parte 9

 

Contenidos:

  1. Iteración Switch.
  2. Vectores.
  3. Matrices.
  4. Continuación de la confección de un terminal de venta.
Así que vamos de lleno a la guía de hoy:

1.- Iteración Switch:

En el número anterior, veíamos las iteraciones condicionales if y else, las cuales nos permitían tomar distintos caminos dentro de un programa, dependiendo de una condición determinada. Además, cuando veíamos los números sobre pseudo-lenguaje, conocímos una iteración llamada Switch, la cual presentaba una funcionalidad bastante similar, pero tal como explicábamos aquella vez, es bastante mejor para usar en casos determinados.
El funcionamiento de esta iteración, ya lo hemos detallado en números anteriores, por lo que no adentraremos en repetir lo mismo, si no que veremos como funciona en lenguaje C.
Ahora, una buena pregunta, es ¿Cuándo usar if/else y cuándo usar switch?. La verdad, es que como todo en la programación, es cosa de gustos. A pesar de que pueden haber casos en los que sea más cómodo y/o ordenado usar una iteración sobre otra, las 2 cumplen la misma funcionalidad, por lo que pueden ser usadas sin problemas. En lo personal, lo cual en ningún sentido es un estándar, prefiero usar iteraciones de tipo Switch cuando en los programas definimos algún tipo de menú, por un tema de orden. En un ejemplo más adelante podremos apreciar porque.
Entonces, usando switch en C, lo primero que necesitamos es una variable que tome un valor (todo switch debeser inicializado por una variable) y conocer los valores, o la mayoría de ellos, que pudiése tomar, como veremos en el siguiente ejemplo.
Además, dentro de los casos, podemos definir un caso por defecto, el cual cubrirá todas las opciones no definidas. Esto es muy útil para prevenir que el usuario ingrese un valor que no tenemos cubierto dentro de nuestras opciones.
Veamos un ejemplo.
Ejemplo: Plantearemos un pequeño menú, y definiremos cada caso, utilizando una iteración de tipo switch.
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int opcion;
int main()
{
/* A continuación escribimos nuestro menú, tabulando y dando saltos de línea */
printf(“\tMenu”);
printf(“\n1.- Mostrar hola mundo”);
printf(“\n2.- Dar los buenos dias”);
printf(“\n3.- Salir”);
printf(“\nIngrese su opcion: “);
scanf(“%d”,&opcion); 
/* Leemos la opción que ingrese el usuario */
switch(opcion) // Activamos el switch con la variable opción.
{
case 1:      printf(“\nHola mundo”);
 /* En el caso que ingrese 1 */
break;
case 2:      printf(“\nBuenos dias”); /* En el caso que ingrese 2 */
break;
case 3:      break; /* En el caso que ingrese 3 */
default:     printf(“\nOpcion no valida”); /* Caso por defecto */
break;
}
getch(); /* Ponemos el programa en pausa hasta que se presione una tecla */
}
Como podemos ver, al final de cada caso, debemos incluir la sentencia break;, que indicará que después de ejecutar las sentencias correspondientes al caso, se debe salir del switch.
Compilamos y probamos. Ahora, como podrán apreciar, este switch solo se ejecuta una vez. En caso de que quisieramos hacerlo repetitivo hasta que se diga salir, podemos insertarlo dentro de un ciclo y poner como condición que se ejecute mientras no se seleccione la opción de salida.
Así de simple es la iteración switch. Es de gran utilidad para ordenar nuestras opciones y en especial para utilizarlo con menús, así que es muy recomendable aprender a usarlo y manejarlo para los programas que vayamos a desarrollar.

2.- Vectores:

Tal como veíamos en pseudo-lenguaje, en la programación existen unas variables especiales conocidas como arreglos, las cuales presentan la facultad de almacenar múltiples valores, ya sea unidimensionalmente o bidimensionalmente. Los vectores representan los primeros.
En C, también podemos utilizar vectores, de la misma forma en la que los planteabamos para pseudocódigo, es decir, declarándolos y rellenándolos según su posición, así como las mismas condiciones para recorrerlos y leerlos.
Tal como en todos los casos, no entraremos a repetir las definiciones que hemos hecho en guías anteriores y sólo nos preocuparemos de su uso en lenguaje C.
Veamos un pequeño ejemplo, para que nos quede todo más claro:
Ejemplo: Declararemos un vector, lo rellenaremos y luego mostraremos su contenido:
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int vector[5]; // Declaramos el vector
int main()
{
for(int i=0; i<5; i++) 
/* Definimos un ciclo para llenar el vector */
{
printf(“\nIngrese el valor de la posicion %d del vector: “,i);
scanf(“%d”,&vector[i]);
 /* Leemos los datos de cada posición */
}
printf(“\nLos valores ingresados fueron: “); 
/* Mostramos los valores */
for(int i=0;i<5; i++)
{
printf(“%d\t”,vector[i]);
}
getch(); /* Ponemos el programa en pausa hasta que se presione una tecla */
}
Como podemos ver, el procedimiento es el mismo que usabamos para pseudo-código, utilizando ciclos tanto para rellenar posiciones secuencialmente, como para leerlas, accediendo mediante el índice que marcamos con la variable i, que se va moviendo a lo largo del vector.
Ahora, si nos fijamos en el ejemplo, podemos ver que dentro del ciclo for, hemos definido la variable i y no al principio del programa. Esto es posible en este tipo de ciclos, pero esa variable solamente vive dentro del búcle y no después (por eso la volvemos a declarar en el segundo ciclo). Esta es una gran forma de matar variables rápidamente después de su uso y no gastar espacio innecesariamente.

3.- Matrices:

En el caso de las matrices, utilizamos procedimientos bastante similares a los de los vectores, salvo que, siendo arreglos bidimensionales, para recorrer una matriz necesitaremos de 2 ciclos, uno para las filas, y 1 para las columnas.
La definición también varía en el número de dimensiones que declaramos. Si para los vectores hacíamos una declaración del tipo “vector [5]“ por su unidimensionalidad, para las matrices aplicamos una definición del tipo“matriz [5[[5]“, la primera relacionada con sus filas, y la 2da con sus columnas.
Veamos un ejemplo para que nos quede más claro.
Ejemplo: Repetiremos el ejemplo anterior, pero en este caso utilizaremos una matriz:
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int matriz[3][3]; // Declaramos la matriz
int main()
{
for(int i=0; i<3; i++)
 /* Definimos un ciclo para las filas */
{
for(int j=0; j<3; j++) /* Otro ciclo para las columnas */
{

printf(“\nIngrese el valor para la fila %d y la columna %d: “,i,j);
scanf(“%d”,&matriz[i][j]);
}
}
printf(“Los valores ingresados son:\n “);
for (int i=0; i<3; i++)
 /* Mostramos los valores ingresados, tabulando y dando salto de línea para hacer la forma de la matriz */
{
for (int j=0; j<3; j++)
{
printf(“%d\t”,matriz[i][j]);
}
printf(“\n”);
}
getch();
 /* Ponemos el programa en pausa hasta que se presione una tecla */
}
El procedimiento es el mismo, pero solo nso enfocamos en recorrer 2 dimensiones en vez de una. A medida que vayamos utilizando vectores y matrices en nuestros programas nos iremos acostumbrando cada vez más a su funcionamiento.

4.- Terminal de venta:

Si recuerdan, al final del número anterior, realizamos la confección de un terminal de venta, en el cual listabamos unos productos y realizabamos una venta, especificando el vuelto correspondiente al cliente.
Hoy, seguiremos trabajando sobre ese terminal, añadiendo la funcionalidad de poder vender más de un producto en una venta y de realizar más de una venta. Si recordamos, teníamos este código:
include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int codigo, cantidad, valor, total, vuelto, pago;
int main()
{
printf(“\t Lista de productos\n”);
printf(“Codigo\t Nombre\t Precio\n”);
printf(“1\t Silla\t 100\n”);
printf(“2\t Puerta\t 350\n”);
printf(“3\t Sillon\t 200\n”);
printf(“\nIngrese el codigo del producto que desea llevar: “);
scanf(“%d”,&codigo);
printf(“\nIngrese la cantidad que desea llevar: “);
scanf(“%d”,&cantidad);
if(codigo==1)
valor=100;
if(codigo==2)
valor=350;
if(codigo==3)
valor=200;
total=valor*cantidad;
printf(“\nEl total es de: %d”,total);
printf(“\nIngrese el pago: “);
scanf(“%d”,&pago);
if(pago<total)
printf(“\nEl pago no es suficiente”);
else
{
vuelto=pago-total;
printf(“\nEl vuelto es de: %d”,vuelto);
}
printf(“\nVenta finalizada”);
getch();
}
Y ahora, añadiendole algunos ciclos, tendremos un código como este:
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
 /* Incluimos las librerías */
int codigo, cantidad, valor, total, vuelto, pago; /* Declaramos las variables que usaremos en el proceso */
int ok=1; /* Adicionalmente declaramos una variable ok, que nos servirá de bandera para un ciclo que usaremos */
int opcion=1; /* Declaramos una variable opcion, que regulara si queremos hacer más de una venta */
int main()
{
while(opcion==1)
{
while(codigo!=4)
 /* Definimos un ciclo que se ejecute siempre que el usuario no presione la tecla para finalizar la venta */
{
printf(“\t Lista de productos\n”);
 /* Listamos los productos */
printf(“Codigo\t Nombre\t Precio\n”);
printf(“1\t Silla\t 100\n”);
printf(“2\t Puerta\t 350\n”);
printf(“3\t Sillon\t 200\n”);
printf(“\nPara cerrar la venta, presione 4″);
 /* Añadimos la opción para cerrar la venta */
printf(“\nIngrese el codigo del producto que desea llevar: “); /* Pedimos el código del producto */
scanf(“%d”,&codigo);    /* Leemos el código del producto */
if(codigo==4)
 /* Si el código es igual a 4, significa que la venta está finalizada, así que cerramos el proceso de venta */
break;
printf(“\nIngrese la cantidad que desea llevar: “);
 /* Pedimos la cantidad */
scanf(“%d”,&cantidad); /* Leemos la cantidad */
if(codigo==1) /* Igualamos el código para asignar el precio */
valor=100;
if(codigo==2)
valor=350;
if(codigo==3)
valor=200;
total=total+(valor*cantidad); /* A total le asignamos, el total acumulado hasta ahora, más el nuevo valor y nueva cantidad, multiplicados entre sí */
}
printf(“\nEl total es de: %d”,total);
 /* Saliendo de la venta, indicamos el total */
while(ok==1) /* Declaramos un ciclo con la variable ok, para el proceso de pago y vuelto, así se ejecutará hasta que se pague la cantidad correcta */
{
printf(“\nIngrese el pago: “);
 /* Solicitamos el pago */
scanf(“%d”,&pago);
 /* Leemos el pago */
if(pago<total) /* Si el pago es inferior al total, mostramos un mensaje de error */
printf(“\nEl pago no es suficiente”);
else /* De lo contrario, cambiamos el valor de ok para romper el ciclo y mostramos los mensajes de vuelto */
{
ok=0;
vuelto=pago-total;
printf(“\nEl vuelto es de: %d”,vuelto);
}
}

printf(“\n¿Desea hacer otra venta? (1=Si , 0=No): “);
 /* Preguntamos si desea hacer otra venta */
scanf(“%d,”,&opcion); 
/* Leemos la respuesta */
}
printf(“\nVenta finalizada”); /* Mensaje final */
getch(); /* Programa en pausa hasta pulsar una tecla */
}
Como podemos apreciar en esta nueva versión, hacemos uso de algunos ciclos. De esta forma, podemos hacer una venta de múltiples productos, y validamos el pago hasta que sea el correcto, para así completar de forma correcta la venta. Además, luego de finalizar una venta, podemos hacer otra automáticamente al señalarlo y de esta forma no necesitamos volver a ejecutar el programa cada vez que queramos vender algo.
Recordemos que nuestro programa lo vamos construyendo de a poco, aún hay muchos puntos que pueden ser mejorados y eso es lo que iremos haciendo en los próximos números. Por ahora lo dejaremos aquí, pero los incentivamos a que vayan añadiendo nuevas cosas de lo que hemos ido aprendiendo.
Fin

 
Design by Free WordPress Themes | Bloggerized by Lasantha - Premium Blogger Themes | Bluehost Review