aprendiendo programacion

5/12/2018 aprendiendo programacion - slidepdf.com

http://slidepdf.com/reader/full/aprendiendo-programacion 1/73

Cómo aprender a programar y no morir en el intento: Parte 1

Antes de comenzar, para dejar todo bien claro:

Nota: En Como Lo Hago no somos ni gúrus ni profesionales de la programación, por lo que no nos atreveríamos a ofrecer

estas guías como un método seguro llame sha, 100% garantizado, un abdomen más plano en 7 días ni infalible. No

utilizamos ninguna guía ni manual oficial para redactar esto, pero lo haremos lo más completo posible, a partir de las

experiencias personales de como aprendimos a programar e intentaremos traspasar todo eso en las siguientes líneas, por loque están en todo su derecho de disputar los contenidos de este y los tutoriales siguientes y obviamente de seguir sus

propios métodos si los estiman convenientes.

Con eso claro, veamos lo que cubriremos en la primera parte de este tutorial:

Contenidos:

1. ¿Qué es la programación?.

2. ¿Qué necesito para aprender a programar?.

3. Primeros pasos para aprender.

4. Los algoritmos: la base de todo.

Puede parecer poco, pero creanme que no lo es. Así que ya con todo eso definido, no hay más excusas, vamos. Esto escomo andar en bicicleta, una vez que se aprende nunca se olvida.

1.- ¿Qué es la programación?

Hum… que pregunta más amplia. La verdad es que definir que es la programación puede enfocarse desde una serie de

aspectos: Desde uno netamente técnico hasta uno más abstracto o conceptual, pero veamos.

Mirandolo desde un aspecto netamente técnico o computacional, la programación es la realización de programas (dah!), es

decir, la realización de una serie de instrucciones que interactuarán tanto con el hardware de nuestro computador, como con

otras aplicaciones y/o el usuario que las maneje.

En aspectos más simples aún, al programar en la mayoría de los casos lo que hacemos queda tan reducido como a

preparar una serie de instrucciones y operaciones que nos permitan hacer una recolección de datos, operar con esos datosde alguna forma y luego presentar una serie de resultados producto de esas operaciones.

Y finalmente mirandolo desde un aspecto más conceptual, la programación se refiere netamente a la resolución de

problemas. Cuando programamos lo que queremos hacer es otorgar una solución a una inquietud, abordando aquel

problema desde distintos puntos de vista hasta encontrar la respuesta más óptima y/o efectiva. De a poco iremos

comprendiendo más esta definición.

En los computadores, todo se maneja a base de números binarios (1’s y 0’s), por lo que cuando por ejemplo queremos

realizar una suma, nuestro equipo no entiende si le decimos “suma 2 + 2″ sino que entendería una instrucción o serie de

instrucciones en binario que le permita realizar la operación. Por eso cuando nosotros programamos, lo que hacemos es

crear un intermediario entre el usuario que usa un lenguaje “real” y nuestro equipo que utiliza un lenguaje “de máquina”.

¿Cómo hacemos esto?, bueno muy fácil (aunque no tanto): Los entornos de programación (tema que abordaremos másadelante en detalle) se encargan de realizar esa traducción de lenguaje real a lenguaje de máquina de las instrucciones que

programamos y luego de vuelta la traducción de lenguaje máquina a lenguaje real de los resultados de las operaciones. Así

que cuando vemos el resultado “4″ en pantalla es que nuestro equipo ha mandado el mensaje en binario y ha sido traducido

por el programa que hicimos.

Hasta ahora hemos visto conceptos algo complejos, pero no se preocupen, de a poco se irán entendiendo y en el fondo si

no llegan a entender eso no limitará su capacidad de programación.



2.- ¿Qué necesito para aprender a programar?

Bueno… tiempo.

Hablando un poco más en serio, podemos definir las necesidades en 2 tipos: las físicas y las“personales”.

a) Necesidades físicas:

¿Físicas?, ¿Say what?, ¿Es un concurso de popularidad?. No, en verdad por necesidades físicas nos referímos de ciertaforma a “implementos reales o computacionales” que se utilizarán para empezar a programar. Para las primeras guías solo

necesitaremos de nosotros mismos y a lo más una hoja de papel y un lápiz. (para jugar al gato en los ratos de ocio. No, ya

verán porque). Eventualmente cuando nos adentremos más necesitaremos de estas cosas:

1. Un computador (que si están leyendo me imagino que ya lo tienen).

2. Un entorno de programación (que dependerá del lenguaje en el que decidamos programar. Ya lo veremos con más

calma más adelante).

3. Una conexión a Internet (no es de vida o muerte, pero si ayuda).

Como pueden apreciar, no necesitamos nada de otro mundo. Son cosas que están accesibles a solo unos clicks de

distancia (a menos que no tengan computador, ya que no pueden ir clickeando por la vida para comprarse uno. O sea

pueden, pero cuesta más). Pero en todo caso no se preocupen por esos ítems aún, ya lo veremos con más calma cuando

sea necesario.

b) Necesidades “personales”:

Personales es un término que utilizamos con bastante cuidado, ya que en verdad a lo que nos referimos es a una serie de

características y habilidades (natas y/o adquiridas) personales que ayudan mucho en el aprendizaje. Si bien el no tener

alguna de estas puede que termine por no ser un impedimento si sirve de mucho tenerlas. Nos referimos a:

1. Paciencia, y mucha: Y hacemos mucho hincapié en este punto, por eso lo hemos puesto al tope de la lista. La

programación puede llegar a ser muy frustrante y en muchas ocasiones podemos quedarnos pegados por un buen

rato en la busqueda de una solución a un problema, por muy pequeño que sea. Más adelante daremos algunos

consejos sobre esto. Lo importante es tener paciencia y entender que siempre hay baches en el camino, por muy

buenos que lleguemos a ser.2. Perseverancia: Va ligado netamente al punto anterior. En la programación siempre hay que ser perseverante para

poder lograr los objetivos que nos proponemos. En muchas ocasiones nos encontraremos con distintos problemas

que van desde: no saber como afrontar un problema, hasta bloqueos mentales o desconocimiento. Saldremos

adelante solo siendo perseverantes y solo continuando cuando pensemos que ya debemos tirar la esponja. Estas

últimas 2 cualidades es lo que separa a los buenos programadores de los malos. No los conocimientos de

lenguajes, sino la paciencia y la perseverancia es lo que los llevará a ser buenos.

3. Mirar las situaciones desde distintos puntos: Esto es muy útil y nos refleja a nosotros mismos de como enfrentamos

la vida. Cuando se nos presenta una situación de cualquier tipo, mientras de más puntos o lados la miremos y

obtengamos ciertas conclusiones, aumentamos más la posibilidad de encontrar una buena solución. Debemos

siempre tener en cuenta que todas las personas piensan de distinta forma y por lo tanto todos pensamos distintas

soluciones y más aún, distintas formas de implementar estas soluciones. Si bien es siempre bueno definir hacia

nosotros mismos una metodología para resolver los problemas, es muy útil tener la habilidad de abstraerse y mirar

la situación desde otro lado. En más de alguna ocasión con esto obtendremos mejores soluciones que las que

habiamos pensado originalmente.

4. Pensar lógica y básicamente: Algún tiempo atrás, cuando estaba en la universidad, un profesor nos dijo “Señores,

les contaré algo que nadie se ha atrevido a decirles hasta ahora: Estas máquinas que están frente a Uds. que son

conocidas mundialmente como computadores capaces de hacer cosas que la mente humana no puede, son en

verdad tremendamente básicas y tontas”. ¿Curioso, no?. Es una tremenda verdad. Los computadores son

máquinas tremendamente estúpidas que saben realizar solo un par de operaciones básicas como cargar, grabar o

sumar. Todo lo demás que pueden hacer es, o bien una combinación de esas operaciones, o el producto de otros



programadores que han desarrollado aplicaciones que les permiten a estas máquinas realizar otros trabajos. ¿A

qué vamos con esto?, a que siempre hay que tener presente lo básico de la forma de pensar de los computadores

cuando programamos y por eso muchas veces debemos pensar igual de básico que ellos. Cuando necesitamos

encontrar una solución, debemos enfrentar la situación como un computador lo haría sin saber otro tipo de

informaciones que nosotros sabemos y debemos diseñar nuestras soluciones de la forma más básica para poder

implementarlas.

5. Ser estructurado: A pesar de que los programadores tienen la fama de ser medios “locos y volados” para encontrar

solución a las respuestas, también son tremendamente estructurados. Y es que cuando pensemos una solución a

implementar mediante programación, debemos pensarla estructurada de la forma: Bueno, para hacer esto, primero

hay que hacer esto, luego esto, luego esto y finalmente esto. Ese orden y esa estructuración nos irá ayudando a no

tener que volver sobre el mismo camino hecho para agregar cosas que deberían haber estado ahí.

6. Conocimientos matemáticos: Si bien no es extremadamente necesario y no necesitamos ser unos magos de los

números, ya que hoy con Internet tenemos acceso a la información de manera rápida y sencilla, si es bueno tener

nociones matemáticas sobre operaciones, conocimientos algebraicos, geométricos ya que al programar

utilizaremos uno o varios de estos conceptos en ocasiones.

7. Ser curioso y tener disposición a resolver problemas: La programación nos presenta problemas, problemas y más

problemas. Por eso es bueno tener curiosidad de como resolverlos de distintas formas y siempre tener la

disposición a encontrar soluciones, en especial la más adecuada. Es nuestra curiosidad y nuestro espíritu de

superación lo que eventualmente nos irá convirtiendo en mejores programadores.

Es por esto que en las carreras relacionadas con el área de la computación e informática, previo a la programación siempre

nos pasan (muchas veces odiandolo y sin entender bien porque) Cálculo y Álgebra. El primero nos enseña a expandir la

mente y mirar los problemas desde distintos puntos y el segundo nos enseña a establecer una estructura de pensamiento.

Así que ya saben, a dejar de odiar a esos viejos pelados (¿referencia personal?) que nos llenan de funciones, sistemas de

ecuaciones y gráficos.

Y finalmente un detalle a siempre tener en consideración: En la programación, siempre hay más de una forma de resolver

los problemas.

3.- Primeros pasos para aprender

Si hemos aguantado leer los primeros extensos parrafos llegamos al punto de: Ok, creo que tengo todo. Ahora ¿Cómo

parto?. Bueno partamos con una pregunta que quizás no nos hemos hecho hasta ahora:

¿Cualquier persona puede aprender a programar?

Bueno, si y no. Según muchos “expertos”, hay gente que no sirve para programar. Si bien tienen razón hasta cierto punto

creo, sin considerarme en lo más mínimo experto en el tema, que cualquier persona que tenga el interés y deseo de

aprender puede llegar a hacerlo. Quizás no se puede garantizar a que llegue a ser realmente bueno, pero creo que teniendo

las ganas, la paciencia, la perseverancia y el espíritu de superación se puede llegar muy cerca. Eso y harta práctica, que

bueno, como para todo en la vida, nunca está demás.

Entonces, ¿Por donde partimos?, por el principio por lo más básico. Partimos por empezar a preguntarnos ¿Cómo funcionan

las cosas?. Me explico: Debemos empezar a entrenar nuestra mente y forma de pensar a descubrir como funcionan las

cosas y como se resuelven los problemas. Para hacer esto hay una serie de formas y métodos, pero en el fondo debemos

encontrar el que más nos acomode. Desde sentarnos en la vereda y ver como un conductor está haciendo funcionar su

automóvil hasta abrir la calculadora de Windows y ver como es el modo de interpretar una operación que le indiquemos

realizar. No necesitamos intentar descifrar el procedimiento exacto y detallado, si no que plantearnos esas inquietudes y ver

como funcionan.

Por ejemplo, cuando le decimos a la calculadora de Windows que realice una suma y le damos los datos, esta lo que hace

es leer los datos que le dimos, interpretar cuales son números y cuales signos. En base al signo, ve la factibilidad de realizar

la operación y la hace. Así de “simple”.



Una vez que empecemos a entrenar nuestra forma de pensar de esa manera, podemos empezar a entrar a cosas mucho

más concretas como el punto que viene a continuación.

4.- Los algoritmos: La base de todo.

¿Los algo-qué?. Algoritmos. Chanfle.

Los algoritmos son la base de la programación. Antes de entrar de lleno, pasemos a una definición:

¿Qué es un algoritmo?

Muchas veces se tiende a confundir un algoritmo con algo netamente computacional o tecnológico. En el fondo no es así.

Un algoritmo es básicamente una lista definida, ordenada y finita que nos indica como resolver un problema

determinado (¡Grande Wikipedia!), o sea un how-to bien básico y definido para una operación determinada.

Si no quedó muy claro, utilizaremos otro ejemplo que nos ocurrió en la Universidad:

El mismo profesor que nos indicó la estupidez de nuestros queridos computadores, el día que nos quisó enseñar lo que eran

los algoritmos, nos pidió el primer día de clases y sin darnos explicación alguna que definieramos el algoritmo para hacer un

huevo frito.

La cara de duda era unánime en los rostros presentes, ya que todos nosotros, sin experiencia previa, relacionabamos losalgoritmos con procesos netamente computacionales, entonces no tenía lógica alguna. Luego nos otorgó la ayuda

necesaria diciendonos: “Lo que necesito es que me definan lo que Uds. harían desde un principio para hacer un huevo frito”.

Fue ahí donde nos dimos cuenta que uno puede definir algoritmos para cualquier tipo de procesos, desde los de la vida

misma hasta cosas más evolucionadas y tecnológicas.

Ahora, a diferencia de como uno ve los problemas en la vida real, al realizar un algoritmo sobre cualquier cosa, siempre es

bueno plantearse los supuestos de cualquier problema que pudiese ocurrir y que soluciones se pueden establecer al

respecto.

¿A qué vamos con esto?, a darnos cuenta de que los algoritmos son la premisa básica de cualquier solución de

programación que vayamos a implementar. Con sus operaciones, sus supuestos, su contingencia y su desarrollo

estructurado. Mientras más completos sean los algoritmos que nos planteamos, mejor será nuestra programaciónpropiamente tal.

Veamos un ejemplo, ¿les parece?, ya que después de tanta teoría vamos a marearnos un poco. Viendo la misma historia

antes mencionada, intentemos hacer un algoritmo (básico) de como haríamos un huevo frito:

Algoritmo para hacer un huevo frito:

1. Voy a la cocina.

2. Saco un huevo del refrigerador.

3. Saco una sartén.

4. Pongo un poco de aceite en la sartén.

5. Hecho el huevo a la sartén.

6. Lo frío.7. Me lo como.

Si bien tenemos los pasos básicos establecidos de forma correcta, podemos empezar a ver de que nuestro algoritmo tiene

ciertas fallas, como por ejemplo: ¿Qué pasa si no hay huevos?, ¿Qué pasa si no hay aceite?, ¿Qué pasa si no hay gas?.

Pueden ser preguntas y respuestas algo básicas, pero reflejan lo que decíamos de plantearnos supuestos. Cuando

programamos siempre tenemos que cubrir todos los aspectos necesarios, ya que por muy bien que conozcamos nuestro

programa, el usuario puede no saberlo todo, y es por esto que debemos estar preparados para cubrir cualquiera de estas

situaciones. Una versión mejorada del algoritmo sería:

Algoritmo para hacer un huevo frito 2.0:



1. Voy a la cocina.

2. Veo si hay huevos en el refrigerador.

3. Si hay, saco un huevo y salto al paso 8

4. Si no hay, voy a comprar.

5. Para comprar, voy a buscar plata.

6. Si hay plata, saco y voy al paso 8

7. Si no hay plata, no se hace el huevo frito.

8. Veo si hay gas.

9. Si hay, prendo la cocina y voy al paso 14.

10. Si no hay, busco dinero para pedir gas.

11. Si no hay dinero, no hago el huevo.

12. Si hay, encargo y salto al paso 14.

13. Espero que llegue el gas.

14. Saco una sartén.

15. Si no hay sartén, no hago el huevo.

16. Etc, etc.

Creo que la idea se entiende. Si, es cierto, puede parecer excesivo ponerse en todos los supuestos y quizás estemos

cubriendo aspectos sumamente extraños, pero mientras más situaciones que puedan ocurrir consideremos y tengamossoluciones presentes para eso, más completo será nuestro algoritmo y por ende nuestro programa.

En el fondo siempre debemos pensar que existe la “mala intención de los usuarios”, un concepto que más adelante veremos

en detalle y que es una de las cosas más importantes a tener en consideración por parte de los programadores.

Es una excelente práctica empezar con el tema de los algoritmos. Empezar a plantearnoslos para resolver distintas

situaciones, desde la vida cotidiana, hasta situaciones computacionales, linguísticas, de lógica, matemática, en realidad para

todo. Siempre que hay un problema, hay un algoritmo que se pueda realizar para encontrar la solución.

Así que los instamos a practicar un poco este tema, mientras nosotros vamos desarrollando la que será la segunda parte de

esta guía para aprender a programar y no morir en el intento.

Por ahora lo dejaremos hasta aquí, ya que hemos cubierto los aspectos más básicos y necesarios y han leído bastante. Es

momento de descansar la vista un poco y seguir pensando, que es la mejor práctica posible.

En la próxima edición de “Como aprender a programar y no morir en el intento”:

1. Áreas de memoria alias “Como almacena la información una máquina”.

2. Introducción al Pseudo-código.

3. Haciendo nuestro primer programa.

Todo, a la misma batihora, en el mismo baticanal.

Como siempre, este tutorial ha sido desarrollado mediante un complejo algoritmo y documentado (no hemos podido

determinar su efectividad en general, al menos con nosotros funcionó), por el equipo de Como Lo Hago, por lo que cuenta

con nuestro infalible, siempre seguro, con un poquito de gusto a limón y establecido Sello de Garantía. Cualquier problema,

duda o comentario, sientanse libres de realizarlos en el área habilitada a continuación. Asistiremos sus dudas a la brevedadposible.

Y recuerden, que pronto, conocerán a las “mentes maestras”.

Esperamos que este tutorial haya sido de utilidad para Uds.



Con las Fiestas Patrias ya quedando atrás, y luego de una tonelada algunos tutoriales de cocina que les dejamos en estos

días, volvemos un poco más a la normalidad en Como Lo Hago, y que mejor que trayéndoles la segunda parte de esta saga

de tutoriales que hemos estado preparando para aquellos que quieren adentrarse en el mundo de la programación.

Bueno sin más preambulo les digo, que como siempre, todo el detalle está después del salto.

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

Nota: Si por alguna razón se perdieron la primera parte de esta saga, pueden leerla en este enlace.

Tenemos harto que aprender hoy, y un recuento de lo pasado sería solo acumular líneas, así que vamos, manos a la obra:

Contenidos:

Tal como lo prometimos en el tutorial anterior, hoy veremos los siguientes temas:

1. Áreas de memoria alias “Como almacena un computador la información”.

2. Introducción al Pseudo-Código.

3. Haciendo nuestro primer programa.

¿Listos?, ¿Fueron a buscar bebida?, yo no he ido, así que esperenme -> !.

1.-Áreas de memoria.

Quizás para gente más experimentada en el tema de la programación, pueda parecer algo repentino entrar a esto tan luego,

pero hay una razón de fondo que es empezar a relacionarnos con el concepto de las variables de cierta forma.

Pero bueno, ¿Qué son las áreas de memoria?. Para contestar esta pregunta, nos haremos otra, ¿Cómo almacena la

información una máquina/equipo/computador?.

Básicamente lo hace de 2 formas, o mediante el uso de 2 tipos de memoria: la volátil y la no volátil.

La memoria volátil es toda aquella que una vez que apagamos el computador se vacía (Ej: Memoria RAM). Tiene la ventaja

de ser de mayor acceso (lectura/escritura) y obviamente la desventaja de que su almacenamiento no es “permanente”.

http://www.comolohago.cl/2008/09/como-aprender-a-programar-y-no-morir-en-el-intento-parte-1/






Por su lado la memoria no volátil es justamente lo contrario a la anterior, ya que una vez que almacenamos información ahí,

quedará hasta que decidamos borrarla o “alguien” lo decida por nosotros. Ejemplos de memoria no volátil son los

almacenamientos magnéticos (discos duros) o los ópticos (CD, DVD, etc).

En la programación se utilizan ambos tipos de memoria. Por un lado se utiliza la memoria volátil para el trabajo

con variables (explicaremos eso en detalle) y por otro lado la memoria no volátil cuando estamos trabajando con archivos o

en otras situaciones que iremos viendo a medida que ocurran.

En una representación gráfica, la memoria volátil que utiliza la programación (RAM), sería algo como esto, guardando las

proporciones:

Cada cuadradito representa un área de memoria, el cual posee una dirección expresada en valores hexadecimales (algo por

ejemplo como FA2246) la cual se llama dirección de memoria, y es utilizada cuando se quiere acceder a los datos

almacenados en ese “cuadradito”.

¿Se acuerdan esa vez que les dijimos que explicaríamos las variables en detalle?, que tiempos aquellos ¿no?, bueno el

momento es ahora.

Las variables

Esta definición no intenta ser técnica ni mucho menos. Solo pretendemos que el concepto quede claro para que lo

intentamos lograr.

Una variable es un “enlace contenedor” de y a un dato. ¿Por qué enlace contenedor?, porque una variable esta relacionada

a una dirección de memoria, por ende enlace, y contiene un valor correspondiente a un dato que podemos recibir o tomar de

otro lado (usuario, otra variable, el resultado de una operación, etc), ergo contenedor. Esta definición se irá haciendo más

clara a medida que vayamos avanzando.

Las variables tienen ciertas características, como son:

Nombre: Corresponde al identificador de la variable. Los nombres de variables dentro de un programa deben ser únicos, no

empezar con un número, no contener símbolos y respetar las palabras reservadas dentro de un lenguaje de programación

(Por ej: En Java, la palabra new es reservada, por lo que no se puede nombrar una variable así).

Tipo: Corresponde al tipo de datos que podrán almacenarse en la variable. Si bien en lenguajes como PHP no es necesario

definir el tipo, la mayoría de los otros lenguajes lo piden. Los tipos más comunes son:



1. Int: Corresponde a números enteros (correspondiente al universo Z de las matemáticas). El rango que abarca

(valores máximos y mínimos que se les puede dar) varía del lenguaje en uso. Existen 2 variaciones comunes como

son el short int o short y el long int o long. Varían en el rango.

2. Float: Corresponde a valores de punto flotante (números decimales correspondientes al universo Q de las

matemáticas). En algunos lenguajes se puede utilizar como double, short double o long double. Su rango difiere del

lenguaje a utilizar.

3. Char: Corresponde a valores de caractéres alfanuméricos (0 a 9 y abecedario). Solo se puede almacenar un valor

dentro de este tipo de variables.

4. Boolean: Corresponden a valores de tipo lógico. Almacenan sólo 2 posibles valores: true o false.

5. String: Corresponde a una cadena de caractéres, por ejemplo una palabra o frase. Su rango depende de cada

lenguaje.

Además debemos tener presente que las variables pueden cambiar su valor a lo largo del programa (a no ser que sean

definidas como constantes, ya veremos eso más adelante) y existen observaciones sobre las operaciones que ejecutamos

sobre ellas. Estos puntos los detallaremos más adelante.

Dejando esa definición un poco más clara, volvemos al tema de las áreas de memoria.

Cuando creamos una variable, o bien la definimos, el equipo le asigna automáticamente un área de memoria en la cual

almacenará su valor. En caso de sobrepasar el área asignada, se le asignará una nueva área de memoria, y asísucesivamente.

Esta sección de las áreas de memoria irá quedando cada vez más clara según vayamos avanzando.

2.- Introducción al Pseudo-Código

El Pseudo-Código, como su nombre lo indica, es una especie de “lenguaje de programación” utilizado para introducir a los

futuros programadores a la estructura de la realización de programas.

En él, se utilizan todos los recursos de un lenguaje de programación normal, a pesar de que los nombres y conceptos

puedan variar dependiendo de quien lo enseñe, y se busca principalmente practicar un poco la lógica que posteriormente

debemos implementar.

Lo principal que se debe entender, es que a pesar de establecer algunas reglas sobre como se operará con el pseudo-código, los únicos errores que se pueden cometer son de lógica y no como expresamos las distintas funcionalidades del

programa, así que hay que irse sintiendo lo suficientemente libres para experimentar.

Antes de entrar de lleno a este tema, es bueno detenernos y explicar un poco el tema de los paradigmas de programación.

Paradigmas de programación

En la programación existen una serie de paradigmas que se refieren principalmente al enfoque que le daremos a un

problema para solucionarlo o bien “la forma en que veremos las cosas”. Los paradigmas más comunes son:

1. Paradigma de programación estructurada.

2. Paradigma de programación orientada a objetos.

3. Paradigma de programación orientada a eventos.4. Paradigma de programación orientada a aspectos.

Para las primeras etapas de estas guías nos enfocaremos en el paradigma estructurado. A medida que vayamos avanzando

nos interiorizaremos más en esto.

Volviendo al tema del Pseudo-código, y habiendo establecido el punto de los paradigmas, veamos el formato clásico y

básico de un programa:

Inicio

Definición/declaración de variables



Cuerpo del programa

Fin

A medida que vayamos haciendo programas más complejos veremos como este formato se va a ampliando. Una

explicación de las partes:

1. Inicio: Se refiere al comienzo del programa.

2. Definición/declaración de variables: Aquí indicamos todas las variables que utilizaremos para la realización denuestro programa, junto con su tipo y en algunos casos, su valor inicial.

3. Cuerpo del programa: Aquí irá el desarrollo de nuestro programa, indicando información que recolectaremos,

operaciones y salidas (entrega de información).

4. Fin: Se refiere al fin del programa.

Cumpliendo esos pasos básicos, podemos empezar a hacer nuestros primeros programas. Así que a tomar una hoja de

papel, un lápiz y una goma, porque de seguro deberemos borrar más de alguna cosa por ahí.

3.- Haciendo nuestro primer programa

Para hacer nuestro “bautizo oficial” en el mundo de la programación, partiremos por realizar el ejercicio más clásico que

aparece en todos los libros de programación de aquí a la eternidad, el famoso “Hola mundo”.En este programa lo que haremos será simplemente mostrar un mensaje en pantalla que diga “ Hola Mundo”. El código a

continuación, y los comentarios van en negritas, cursiva y entremedio de /* y */.

Ejercicio 1: Hola Mundo

Inicio

/* Establecemos el inicio del programa */

Principal( )

/* Definimos la función “Principal” que es donde irá el cuerpo del programa. Ya adentraremos el

tema de las funciones */

mostrar “Hola Mundo”;

/* Utilizamos la sentencia “mostrar” para enviar un mensaje que se despliegue en pantalla y entre

comillas la frase que mostraremos, en este caso “Hola Mundo”. Luego de la sentencia ponemos un

punto y coma para indicar el fin de esta, algo que utilizaremos mucho cuando estemos

programando en algún lenguaje, ya que eso le indica al entorno de programación que es el fin de

la sentencia */

Fin



/* Finalizamos el programa */

Y así de simple. Hemos hecho nuestro primer programa enviando un mensaje “Hola Mundo” que

se mostrará en la pantalla. Para este programa, como solo mostramos un mensaje, podrán ver que

no hicimos uso de variables, por eso nos saltamos la parte de la definición de ellas. En posteriores

ejercicios haremos uso de eso.

Por hoy ya hemos visto bastante, así que es momento de asimilar la información y descansar un poco. Para recapitular, hoyhemos aprendido sobre:

1. Áreas de memoria.

2. Variables.

3. Pseudo-código.

4. Paradigmas de programación.

5. Hicimos nuestro primer programa.

¿Bastante, no?, pues bueno, en la próxima guía nos enfocaremos principalmente en más sobre Pseudo-código:

1. Definición de variables.

2. Leyendo datos desde teclado (ingresados por el usuario).

3. Iteraciones condicionales (Si, Si no).4. Ciclos o búcles.

En una próxima edición, a la misma batihora y en el mismo baticanal.

Por ahora es mi deber recordar que como siempre, este tutorial ha sido desarrollado, probado y documentado por el equipo

de Como Lo Hago por lo que cuenta con nuestro infalible y a veces programable Sello de garantía. Cualquier comentario,

problema o duda que puedan tener, sientanse libre de dejarnos unas líneas en el área habilitada a continuación.


Continuando con esta saga, hoy les traemos la 3a edición de estas guías donde estamos cubriendo el tema de la

programación paso a paso desde sus principios más básicos.



Ya hemos visto en los dos números anteriores toda la información básica antes de empezar a llevar código a papel, por lo

que de este número en adelante nos dedicaremos de lleno a la programación en sí.

Todo el detalle, como siempre, después del salto.


Nota: Recomendamos leer las primeras 2 partes de esta guía si no lo han hecho, las cuales pueden encontrarlas en:

• Parte 1.

• Parte 2.

Como es habitual, partamos por revisar los contenidos de esta edición:

Contenidos:

1. Definición de variables.

2. Leyendo datos desde teclado.

3. Operaciones matemáticas.

4. Iteraciones condicionales.

Es harta información, así que vamos de lleno a los temas:

1.- Definición de variables

En el tutorial anterior ya dimos una explicación de lo que son las variables y como se encuentran involucradas en los

procesos de la programación, por lo que hoy nos enfocaremos solamente a su definición y uso dentro del código

propiamente tal.

Las variables tienen lo que se llama un “ciclo de vida”, que representa toda la duración de una variable a través de un

programa. Este ciclo de vida se inicia con la definición o creación de la variable y termina con la finalización del programa o

la liberación del área de memoria donde estaba contenida.

Para crear o definir una variable en pseudocódigo siempre se utiliza la siguiente sintaxis, la cual representa fielmente la

utilizada en los lenguajes de programación reales:

Tipo Nombre Valor Inicial (opcional)

Tal como vimos en el tutorial anterior, en los lenguajes de programación se utilizan ciertos tipos para definir los tipos (valga

la redundancia) de información que puede almacenar la variable en cuestión. Les recomiendo revisar ese tutorial como

recordatorio de los tipos que vimos. En pseudocódigo utilizaremos los siguientes tipos:

1. Número: Este tipo de variables almacenarán cualquier valor de tipo número, ya sea entero (conjunto Z) o bien real

(conjunto R del universo de las matemáticas, o sea, enteros más decimales). Cabe recordar que en los lenguajes

reales hay distintos tipos para los enteros y para los decimales, pero aquí los agruparemos todos dentro de este

mismo tipo.

2. Letra: Este tipo de variables almacenarán cualquier valor de tipo alfanumérico, ya sean caracteres (0-9 o A-Z) o

palabras y/o frases (como “gato”, o “la casa roja”). Tal como en el tipo anterior, hay que recordar que en los

lenguajes de programación reales hay distintos tipos para tratar los caractéres y las cadenas de palabras, pero aquí

los agruparemos dentro de un mismo tipo.

3. Lógico: Este tipo de variables almacenarán valores de tipo lógico (verdadero o falso). En vez de almacenar las

palabras “verdadero” o “falso” le asignaremos un 0 si se trata del primero y un 1 si se trata del segundo.

Vale la pena mencionar, que a pesar de que las variables de tipo Letra puedan almacenar caracteres correspondientes a

números, no podremos realizar operaciones matemáticas sobre ellos, por lo que si necesitamos este tipo de operaciones es

recomendable almacenar en variables de tipo Número.











Durante el ciclo de vida de la variable (periodo entre su declaración y su fin) podemos modificar su contenido cuantas veces

queramos, siendo bastante útil al momento de querer reciclar una variable para no tener que crear otra del mismo tipo,

hecho que nos termina ayudando a ahorrar memoria en uso.

Tal como indicamos en la sintaxis, toda variable debe llevar un nombre, el cual puede ser cualquiera, pero debe respetar los

siguientes criterios:

1. Debe ser único. No pueden haber 2 variables con el mismo nombre.

2. No puede empezar con un número ni un underscore. Sin embargo pueden contenerlos dentro de su nombre. Si

bien no se puede nombrar variables como “2auto” o “_perro” si podemos tener otras como “auto2″ o “perro_”.

3. No pueden llevar como nombre una palabra reservada del lenguaje. Todos los lenguajes tienen ciertas “palabras

reservadas” que son utilizadas para definir tipos de variables o funciones del lenguaje propiamente tal. Por ejemplo,

nunca podríamos nombrar una variable como “while” ya que los lenguajes reservan esa palabra para una función

de tipo ciclo. De a poco iremos conociendo las palabras que están reservadas para cada lenguaje, aunque no hay

de que preocuparse, ya que siempre nos avisará al momento de compilar el programa y nos obligará a cambiarla

para que no hayan conflictos.

Además, indicamos en la sintaxis que a una variable podemos asignarle opcionalmente un valor inicial. El“opcionalmente” se

debe a que al momento de crear la variable podemos asignarle un valor, pero si no lo hacemos no afecta, ya que lo

podemos hacer más adelante. Lo único en lo que hay que fijarse es que la variable contenga ya algún valor cuandoqueramos operar con ella. Por ejemplo, si deseamos sumar un valor almacenado en una variable, esta no puede estar en

blanco.

Veremos a continuación, algunos ejemplos que cubren todo lo que hemos visto en las líneas anteriores:

Retomando el ejemplo del “hola mundo” que vimos en el tutorial anterior, ahora en vez de desplegar directamente el

mensaje, lo desplegaremos con el uso de una variable. (comentarios en negrita, cursiva y entre /* y */):

Inicio


Letra mensaje=”Hola mundo”;

/* A continuación definimos una variable de tipo “Letra”, de nombre

“mensaje” y le damos un valor inicial de “Hola mundo”, el mensaje que

queremos mostrar. Luego de la sentencia ponemos un punto y coma para

indicar el fin de esta, algo que utilizaremos mucho cuando estemos

programando en algún lenguaje, ya que eso le indica al entorno de

programación que es el fin de la sentencia */

Principal( )

/* Definimos la función “Principal” que es donde irá el cuerpo del

programa. Ya adentraremos el tema de las funciones */



mostrar mensaje;

/* Utilizamos la sentencia “mostrar” para enviar un mensaje que se

despliegue en pantalla y luego la variable que contiene el mensaje, en

este caso “mensaje”. Cerramos la sentencia con un punto y coma para

indicar que se ejecute la línea */

Fin


Como podemos ver, en este ejemplo hemos definido una variable de tipo Letra, llamada mensaje y

le hemos asignado como valor inicial el mensaje que vamos a mostrar por pantalla. Ahora, ¿Qué

pasa si no queremos asignar un valor inicial, y se lo damos más adelante?, sería algo como esto:

Inicio


Letra mensaje;

/* A continuación definimos una variable de tipo “Letra”, de nombre“mensaje”. Luego de la sentencia ponemos un punto y coma para indicar

el fin de esta, algo que utilizaremos mucho cuando estemos



Principal( )



mensaje=”Hola mundo”;

/* Asignamos el valor “Hola mundo” a la variable mensaje y cerramos

con punto y coma*/



mostrar mensaje;





Fin


Esos son los pasos fundamentales para ir trabajando con variables. Todo esto se irá haciendo

cada vez más claro a medida que vayamos desarrollando nuestros programas.

2.- Leyendo datos desde teclado

Hasta ahora, toda la información que hemos ido desplegando en nuestros programas ha sido proporcionada por nosotros

mismos, algo que cuando estemos realizando programas para “terceros”nunca será suficiente, ya que muchas veces

deberemos operar con información proporcionada por los usuarios que utilizan los programas o por fuentes de datos

externas. Para esto se utiliza el término “Leer datos”.

Leer datos se refiere a recopilar información desde una fuente externa, ya sea un usuario que los ingrese vía teclado, o de

una fuente de datos como un archivo con registros o una base de datos. En esta primera etapa nos centraremos en la

lectura de datos desde teclado, o sea, proporcionada por los usuarios.

Los datos se leen y se almacenan en una variable de tipo concordante al dato que se ingresa, por lo que es muy importante

definir el tipo de dato correcto, ya que si indicamos una variable de tipo letra y el usuario ingresa un número, se guardará

como caracter. Ya veremos esto en más detalle en el ejemplo.

Esta información podemos manipularla de la forma que estimemos conveniente y despues desplegarla en pantalla de la

misma forma que lo hemos hecho hasta ahora.

Veamos un ejemplo, basandonos en el mismo ejercicio “Hola mundo” que hemos visto hasta ahora. En vez de desplegar

nosotros el mensaje, le diremos al usuario que ingrese un mensaje para mostrar.(comentarios en negrita, cursiva y entre /* y

*/):

Inicio


Letra mensaje;

/* A continuación definimos una variable de tipo “Letra”, de nombre

“mensaje”. Luego de la sentencia ponemos un punto y coma para indicar






Principal( )



mostrar(“Ingrese un mensaje para mostrar: “);

leer(%letra,mensaje);

/* Utilizamos la función mostrar para desplegar un mensaje por pantalla .

Luego con la función leer indicamos entre parentesis el tipo de dato que

recolectaremos, en este caso letra (acompañado de un porcentaje, esto

es netamente para ir acostumbrándonos a como leeremos los datos en

lenguajes reales) y luego de la coma el segundo parámetro,

correspondiente a la variable donde almacenaremos la información, o

sea, mensaje. Terminamos todo con un punto y coma. */

mostrar mensaje;





Fin


Con esto podemos recibir toda la infromación que necesitemos por parte del usuario y desplegarla

sin problemas en pantalla.

3.- Operaciones matemáticas

En los lenguajes de programación, una forma de realizar operaciones con los valores almacenados en las variables es

mediante las operaciones matemáticas. Los lenguajes soportan las operaciones más comunes que podemos utilizar en la



matemática y con ellas se puede trabajar tanto variable vs variable, como variable vs constante, y constante vs constante.

Las operaciones más comunes soportadas son:

1. +: Suma.

2. -: Resta.

3. *: Multiplicación.

4. /: División.

5. Raíz cuadrada (la sentencia depende de cada lenguaje).6. Potenciación (la sentencia depende de cada lenguaje).

7. %: Módulo de la división (resto).

8. ++: Incremento.

9. –: Decremento.

10.<: Menor a.

11.>: Mayor a.

12.==: Igual a. (Se debe usar doble signo ya que el signo simple es para asignar valores).

13.!=: Distinto de.

14.&&: Y.

15.||: ó.

Hay algunas otras que iremos viendo más adelante.

Ahora veremos un ejemplo donde operaremos con un número ingresado por teclado (comentarios en negrita, cursiva y entre

/* y */):

Inicio


Numero edad;

Numero resultado;

/* A continuación definimos una variable de tipo “Numero”, de nombre

“edad” y luego una variable de tipo “Numero”, de nombre

“resultado”.Luego de la sentencia ponemos un punto y coma para indicar


programando en algún lenguaje, ya que eso le indica al entorno deprogramación que es el fin de la sentencia */

Principal( )





mostrar(“Ingrese su edad: “);

leer(%numero,edad);

/* Utilizamos la función mostrar para desplegar un mensaje por pantalla .Luego con la función leer indicamos entre parentesis el tipo de dato que

recolectaremos, en este caso numero (acompañado de un porcentaje,

esto es netamente para ir acostumbrándonos a como leeremos los datos

en lenguajes reales) y luego de la coma el segundo parámetro,

correspondiente a la variable donde almacenaremos la información, o

sea, edad. Terminamos todo con un punto y coma. */

resultado=edad + 10;

/* En la variable resultado ahora almacenamos lo que nos dará el

sumarle 10 al valor ingresado para edad */

mostrar (“Su edad en 10 años sera: %numero”,resultado);


despliegue en pantalla, seguido del tipo de variable que desplegaremos,

o sea numero y luego la variable que contiene la información, en este

caso “edad”. Cerramos la sentencia con un punto y coma para indicar

que se ejecute la línea */

Fin


De esta forma desplegaremos un resultado de operar con un dato ingresado por el usuario. Dentro

de esas operaciones podemos hacer todas las detalladas con anterioridad.

4.- Iteraciones condicionales

Dentro de la programación, en muchas ocasiones nos encontraremos con situaciones en donde se deberá seleccionar uno

de dos o varios caminos a seguir dependiendo de los datos con los que se este trabajando. Para esto se cuenta con lo que

se llama “iteraciones condicionales”, lo que básicamente nos dará el pie de tomar un camino a seguir dependiendo de una

condición que indiquemos. Cada uno de estos caminos puede incluir una serie de operaciones que perfectamente pueden

ser distintas las unas de las otras.



La iteración condicional por excelencia es, en el caso del pseudocódigo el “Si” y “Si no”(if y else en los lenguajes reales).

Un “Si” puede o no llevar un “Si no”, mientras que un “Si no” debe ir necesariamente a continuación de un “Si” ya que trabaja

a partir de la condición especificada más arriba. Además es bueno indicar que dentro de un “Si no”, pueden ir infinitos “Si” y

“Si no”.

Ejemplificando un poco esto, podría ser algo así:

Recogemos un dato respectivo a la edad de un usuario.

Si (edad cumple una condición)

sentencia 1;

sentencia 2;

Si no

sentencia 3;

sentencia 4;

Veamos un ejemplo práctico sobre el uso de estas iteraciones condicionales, basándonos en el

ejemplo anterior:

Inicio


Numero edad;

/* A continuación definimos una variable de tipo “Numero”, de nombre

“edad”. Luego de la sentencia ponemos un punto y coma para indicar el

fin de esta, algo que utilizaremos mucho cuando estemos programando

en algún lenguaje, ya que eso le indica al entorno de programación que

es el fin de la sentencia */

Principal( )





mostrar(“Ingrese su edad: “);

Si (edad > 18)

mostrar “Ud. es mayor de edad”;

Si no

mostrar “Ud. es menor de edad”;

/* Utilizamos la iteración condicional “Si” con la condición si la edad es

mayor a 18, y en caso de que sea desplegamos el mensaje “Ud. es

mayor de edad” con la función mostrar. Luego utilizamos “Si no” lo que

significa “Si no es mayor a 18″ y mostramos el mensaje “Ud. no es mayor

de edad con la función mostrar. */

Fin


Claramente el ejemplo anterior presenta una de las iteraciones condicionales más básicas. Pueden

realizarse modificaciones para hacer iteraciones multiples e incluso más de una condición, ya sea

excluyente o no excluyente, pero eso lo veremos en una próxima edición, ya que hoy hemos

cubierto más que suficiente.

En la próxima edición de “Como aprender a programar y no morir en el intento – Parte 3″:

1. Iteraciones condicionales multiples y uso de más de una condición.

2. Switch: Otra iteración condicional.

3. Ciclos o búcles.

Así que a armarse de paciencia, que hemos avanzado bastante pero aún queda un largo camino por recorrer.

Como siempre este tutorial ha sido desarrollado, probado y documentado por el equipo de Como Lo Hago, por lo que cuenta

con nuestro Sello de Garantía. Cualquier consulta o problema que puedan tener, no duden en dejarnos unas líneas a

continuación.




¡Es la hora, es la hora!, es la hora de seguir programando.

Tal como lo prometimos, ahora les traemos la cuarta parte de esta guía que está sacando chispasmuchos esperaban, en la

cual seguiremos viendo el maravilloso mundo de la programación de una manera sencilla.

Continuaremos justo desde donde terminamos la última vez, así que sin más que decir, los esperamos después del salto.


Nota: Si es primera vez que entran en estos tutoriales, les recomendamos leer las partes anteriores para estar al día con lo

que ya hemos cubierto:

• Parte 1.

• Parte 2.

•

Parte 3.Y tal como es costumbre, partiremos por revisar los contenidos de esta edición:

Contenidos:

1. Iteraciones condicionales múltiples y uso de más de una condición.

2. Switch: Otra iteración condicional.


Así que sin más que decir, manos a la obra:

1.- Iteraciones condicionales múltiples y uso de más de una condición.

En la edición anterior de esta saga, comenzamos a ver lo que son las iteraciones condicionales y como aplicarlas cuandodentro de un programa necesitamos tomar un camino u otro, en su mayoría mutuamente excluyente, a partir de una

condición dada. La simpleza de su utilización pudimos apreciarla a través de los ejercicios resueltos.

Pero la programación, como la vida, siempre se complica, y eso es lo que haremos ahora.

En los ejercicios anteriores hicimos uso de condiciones excluyentes para las iteraciones, o sea, algo como “Si se da esta

condición, haga esto, si no, haga esto otro” , lo cual es bastante sencillo de entender y aplicar. Sin embargo, cuando estemos

realizando programas a más alto nivel comunmente nos encontraremos con situaciones donde debamos evaluar multiples

iteraciones, como por ejemplo “Si se da esta condición, haga esto, si no se da, pero se da esta otra, haga esto y si no se da

ninguna de las 2, haga esto otro”. Con palabras es algo complicado, pero viendo según sentencias, sería algo así:









Si (condición)

sentencia 1;

Si no

Si(condición)

sentencia 2;

Si no

sentencia 3;

Ahora, tal como mencionamos en el tutorial anterior, dentro de un Si, pueden ir una infinidad

de Si y Si no, lo mismo dentro de un Si no. Sin embargo, lo único que debemos recordar es que

siempre un Si no debe ir precedido de un Si.

Teniendo eso claro, ¿Qué pasa ahora si dentro de nuestro Si debemos evaluar más de una condición o bien una de 2

posibles?.

Ahí es donde empezamos a utilizar el concepto de más de una condición. Dentro de un Si, podemos evaluar el número de

condiciones que nosotros queramos, utilizando los operadores && para “y”, y || para“ó”. Por ejemplo, si dentro de un Si

necesitaramos evaluar la condición de que una persona tuviese más de 18 años y su nombre fuera Juan, utilizaríamos algo

como esto:

Si (edad > 18 && nombre==”Juan”)

sentencia 1;

Si no

sentencia 2;

Por otro lado, si quisieramos evaluar alguna de las 2 condiciones como ciertas, bien que su edad

sea mayor a 18, o su nombre fuese Juan, haríamos algo como esto:

Si (edad > 18 || nombre==”Juan”)

sentencia 1;Si no

sentencia 2;

De esta forma, mediante esos operadores, podemos evaluar una serie de condiciones, tanto

excluyentes, como adherentes. Esta evaluación puede mezclarse con iteraciones múltiples, según

lo necesitemos.

2.- Switch: Otra iteración condicional.

A pesar de que el Si y Si no (if y else en los lenguajes reales) es la iteración condicional más utilizada, existe una bastante

útil al momento de evaluar distintos escenarios dentro de un programa, la cual es el famoso Switch, el cual evalúa el valor

de una variable y a partir de ese valor presenta distintas sentencias a partir de posibles casos que se puedan dar.

Su funcionamiento es bastante parecido a la iteración anterior, pero en este caso lo que basicamente se hace es:

Evaluación de la variable:

Si la variable es ‘x’:

Sentencia 1;



Salir;

Si la variable es ‘y’:

Sentencia 2;

Salir;

Si la variable es ‘z’:

Sentencia 3;

Salir;

Dentro de una iteración condicional Switch, podemos presentar todos los escenarios que

deseemos. Lo único a tener en consideración es que debemos conocer todos los posibles valores

que pueda tomar la variable para así plantear sus posibles desenlaces.

Además incluimos una nueva sentencia: Salir. Esta es utilizada debido a que por defecto, una iteración condicional de tipo

Switch recorre siempre todos los posibles escenarios (a pesar de que no ejecuta las sentencias correspondientes a

escenarios donde el valor no corresponde), por lo que al agregar Salir, ejecutará las sentencias correspondientes y luego

saldrá de la iteración, ahorrando tiempo de ejecución.

Adicionalmente es bueno añadir un escenario de tipo defecto (default en los lenguajes reales de programación), al cual se

ingresará si el valor ingresado en la variable no corresponde a ninguno de los escenarios posibles planteados. Esto quedará

mucho más claro más adelante cuando

Las iteraciones condicionales de tipo Switch son especialmente ideales al momento de plantear menús dentro de un

programa, ya que el usuario ingresará una opción y conoceremos todos los posibles valores para plantear sus sentencias.

Existen una gran cantidad de casos donde podemos utilizar Si y Si no, o Switch, eso dependerá del gusto de cada uno. Sin

embargo en algunos casos no podremos utilizar Switch, ya que la evaluación de valor se debe hacer con comparaciones

exactas (Si el valor es igual a 1 por ejemplo) y no comparaciones mediante operadores (Si el valor es mayor a cierto valor).

Veamos ahora un ejemplo para que todo esto quede más claro. Utilizaremos un Switch (llamándolo evaluar) para determinar

opciones de un menú. (comentarios en negrita, cursiva y entre /* y */).

Inicio/* Damos inicio al programa */

Numero opción;

Letra nombre;

/* Declaramos una variable de tipo número y de nombre opción la cual utilizaremos para que el

usuario ingrese la opción del menú a la cual quiere ingresar, y también una variable de tipo letra y

de nombre ‘nombre’ la cual usaremos dentro de las opciones del menú como ya veremos. */

Principal( ){

/* Definimos la función “Principal” que es donde irá el cuerpo del programa, además abrimos

parentesis de llaves para incluir dentro todo lo concerniente a esta función. Ya adentraremos el

tema de las funciones. */

mostrar(“Seleccione una opción: \n”);

mostrar(“1.- Ingresar usuario \n”);



mostrar(“2.- Borrar usuario \n”);

mostrar(“3.- Listar usuarios \n”);

/* Mediante la sentencia mostrar, desplegamos un mensaje en pantalla para que el usuario sepa

que debe ingresar su opción y luego vamos mostrando las opciones con la misma opción.

Utilizamos “\n” para indicarle al programa que haga un salto de línea */

leer(%numero, opcion);

/* Mediante la sentencia leer, recabamos el dato que quiere ingresar el usuario. A leer le damos

como parámetro primero el tipo de valor que queremos recolectar, o sea número con un % antes

para acostumbrarnos al formato de lenguajes reales y luego le damos la variable donde

almacenaremos el valor, o sea, opcion */

evaluar(opcion)

{

/* Llamamos a la iteración evaluar y le damos como parámetro el dato en el cual nos basaremos, o

sea, opcion, luego abrimos llaves para dar inicio al contenido de la iteración */

caso ‘1′: mostrar(“Ingrese el nombre del usuario: “);

leer(%letra,nombre);

…….

salir;

/* Definimos el caso ‘1′, que es decirle al programa “en caso de que la evaluación nos diga que la

opción seleccionada fue 1, haga esto” y luego definimos las sentencias a ejecutar, finalizando con

salir, tal como lo explicamos anteriormente. /*

caso ‘2′: mostrar(“Ingrese el nombre del usuario a borrar: “);

leer(%letra,nombre);……

salir;

/* Luego definimos el caso 2, tal como el anterior */

caso ‘3′: mostrar(“Los usuarios son: “);

…….

salir;

/* A continuación el caso 3 */

caso ‘defecto’: mostrar(“Seleccionó una opción no válida”);

salir;

/* Y finalmente el caso ‘defecto’ en caso de que haya seleccionado una opción no definida para el

menú. Luego de esta última definición, cerramos el paréntesis de llave correspondiente a la

iteración evaluar y el paréntesis correspondiente a la función principal, y finalizamos el programa

mediante Fin. */

}

}

Fin



Como podemos ver, hemos utilizado el nuevo tipo de iteración y definido todos sus posibles

escenarios. Tal como indicamos anteriormente, en las iteraciones de este tipo solo podemos

evaluar valores fijos y no hacer comparaciones mediante operadores. Esto nos dará la pauta sobre

que tipo de iteración utilizar para cada caso.

Hora de pasar al último punto del tutorial de hoy:

3.- Ciclos o Búcles

Un aspecto importantísimo de la programación, es el uso de ciclos o búcles, los cuales son utilizados en el 99,9% de los

programas de alto nivel, ya veremos porque.

Hasta este momento, hemos desarrollado una serie de programas donde damos inicio, ejecutamos algunas sentencias de

forma ordenada, secuencial y estructurada y los finalizamos. Con los conocimientos que poseemos hasta este punto, si

quisieramos ejecutar una operación un determinado número de veces, tendríamos que definir una línea para cada vez que

queramos ejecutar la operación, lo cual si el número de repeticiones es largo, se convertiría en una operación tediosa y

tendríamos un programa con un gran número de líneas.

Para economizar este proceso y hacer todo mucho más sencillo es que aparecen los ciclos, los cuales nos permiten ejecutar

una sentencia un número de veces que nosotros determinemos a partir de una condición dada.

Existen 3 ciclos comunes que se utilizan, cada uno de ellos con características especiales e ideales para cierto tipo de usos:

1. Mientras (o while en los lenguajes reales): Se ejecuta si es que la condición dada se cumpla y correrá tantas veces

según se respete esa condición.

2. Haga Mientras (o do-while en los lenguajes reales): Se ejecuta tantas veces según se respete la condición dada. A

diferencia del Mientras, este ciclo se ejecuta al menos una vez.

3. Para (o for en los lenguajes reales): Se ejecuta si es que la condición dada se cumple inicialmente y mientras se

siga cumpliendo. A diferencia de los 2 anteriores, en sus parámetros definimos todas las condiciones necesarias.

Las diferencias quedarán claras en los ejemplos que daremos más adelante. Tal como en el caso de las iteraciones

condicionales, existen situaciones ideales para el uso de cada uno de ellos. Sin embargo, hay una serie de casos donde

podemos usar cualquiera de ellos de forma eficiente.

Ahora, cuando usamos un ciclo, debemos definir ciertas cosas, como:

1. Una variable a utilizar en la condición que definirá la duración del ciclo, la cual puede ser definida por nosotros o

por un dato leído desde teclado.

2. Un valor inicial para esa variable, una vez más, definido por nosotros o por el usuario.

3. Una condición para evaluar esa variable y que definirá la duración de la ejecución del ciclo.

4. Una instancia de cambio de la variable. Esta instancia, debe ir modificando el valor de la variable para que en algún

momento cumpla la condición que define la duración del ciclo, de lo contrario, el ciclo se ejecutará infinitamente.

La diferencia entre cada tipo de ciclo se ve principalmente en la forma en que definimos y utilizamos las cosas de la lista

anterior.

Veamos unos ejemplos para que esto quede más claro:Haremos un programa donde enumeremos del 1 al 100, utilizando los 3 tipos de ciclos descritos con

anterioridad. (comentarios en negrita, cursiva y entre /* y */ )

Inicio

/* Damos inicio al programa */



Numero num=1;

/* Declaramos una variable de tipo Numero y nombre num, y le damos el valor inicial 1, que es

desde donde partiremos a enumerar */

Principal( )

{/* Definimos la función “Principal” que es donde irá el cuerpo del programa y abrimos llaves. Ya

adentraremos el tema de las funciones */

mientras(num<=100)

{

mostrar(%numero, num);

num++;

}

/* Definimos un ciclo de tipo mientras y le decimos que la condición es que se ejecute mientras

num sea menor o igual a 100, dentro de el mediante la sentencia mostrar desplegamos el valor actual de la variable y luego con el operador de incremento lo aumentamos en uno y se vuelve a

ejecutar. De esta forma la primera vez que entre mostrará 1 y luego irá aumentando y mostrando

hasta que llegue a 100 */

haga

{


num++;

}mientras(num<=100);

/* Ahora hacemos la misma operación pero usando un ciclo de tipo haga-mientras. Definimos lasmismas operaciones pero a diferencia del caso anterior, ahora declaramos la condición al final.

Como requisito de este tipo de ciclos, el mientras del final debe ir con un punto y coma al final.

Recordemos que este ciclo se ejecutará al menos una vez */

para(num=1;num<=100;num++)

{


}

/* Y finalmente hacemos el mismo proceso con un ciclo de tipo ‘para’. La diferencia con los 2

anteriores es que ahora dentro de sus parametros establecemos toda las condiciones para la

ejecución de este ciclo. Partiendo por un valor inicial para num, en este caso 1, la condición de

duración que es mientras sea menor o igual a 100 y el incremento para que se cumpla esta

condición. Dentro del ciclo solo ponemos la sentencia mostrar porque ya hemos definido lo demás

*/

}



Fin

Como podemos ver, hemos declarado la misma operación mediante 3 ciclos distintos. Cada uno de

ellos desplegará el mismo resultado, los números de 1 a 100, pero la forma en que definimos estos

ciclos es diferente. Con más práctica podremos ir viendo que tipo de ciclo es adecuado para que

situación. Idealmente a la sentencia mostrar en los 3 casos podríamos haberle añadido un salto de

línea, porque como esta declarado mostrará los números uno al lado del otro. Como es un ejemplono es necesario que lo definamos.

Es bueno añadir que dentro de un ciclo, cualquiera de ellos, podemos definir todas las operaciones que estimemos

conveniente, incluidas iteraciones condicionales y todo lo que hemos visto hasta ahora como muestra de datos, lectura de

datos de teclado, etc.

Además es bueno también recordar que todo ciclo debe tener un fin, por eso debemos ser cuidadosos al momento de definir

las condiciones de duración, ya que un ciclo que corrá eternamente matará nuestro programa.

Tal como debemos definir cuidadosamente el fin, un punto a considerar es que un ciclo no necesariamente debe siempre

ejecutarse, es por eso que definimos la condición de inicio y duración. Por ejemplo, podemos condicionar el inicio de un ciclo

a que cierta variable porte cierto valor y en caso de que no lo tenga, el ciclo nunca se ejecute.

El trabajo con los ciclos puede presentar cierta complejidad en sus inicios, pero a medida que vayamos avanzando se irásimplificando.

Con esto cerramos la lista de contenidos de esta edición del tutorial, definiendo que para el próximo número, veremos:

1. Introducción a los arrays o arreglos.

2. Arreglos unidimensionales: Vectores.

3. Arreglos bidimensionales: Matrices.

Todo a la misma batihora, en el mismo baticanal.

Como siempre, este tutorial ha sido desarrollado, probado y documentado por el equipo de Como Lo Hago, por lo que

cuenta con nuestro Sello de Garantía. Cualquier duda, problema o comentario, pueden dejarnos unas líneas en el área

habilitada a continuación.Esperamos que este tutorial haya sido de utilidad para Uds.



Lo prometido es deuda, así que llegamos con una nueva edición de esta guía en la que Como Lo Hago intenta ayudarlos a

adentrarse al mundo de la programación de la mejor manera posible.

En esta edición, cubriremos las últimas temáticas relativas a programación en pseudo-código para ya a partir de las

próximas entrar de lleno en los lenguajes reales.



Como es habitual, veamos lo que cubriremos en esta ocasión:

Contenidos

1.- Introducción a los arrays

2.- Vectores

3.- Matrices

Así que con todo especificado, vamos, a seguir aprendiendo:

Introducción a los arrays

Hasta ahora, todos los datos con los que hemos trabajado los hemos almacenado en variables, las cuales entre sus

características podemos indicar que son capaces de almacenar un valor “simple”, o sea un número (de uno o más dígitos) o

un carácter (o cadena de ellos) o un valor booleano. De cualquier forma siempre almacenan solamente un y nada más que

un valor a la vez.

Pero, ¿qué pasa si es que necesitamos almacenar más de un valor?. Podríamos usar más variables, sin embargo, cuando

los valores necesarios de almacenar son 10 o más, disponer de tantas variables, y más importante aún, recordar sus

nombres y manipularlas, puede ser bastante engorroso.

Para esto es que en la programación disponemos de los arrays o arreglos, los cuales son variables que nos permiten

almacenar más de un valor del mismo tipo y manipularlos, todo dentro de la misma variable.

Comunmente en los lenguajes de programación, los arreglos solo pueden contener múltiples valores del mismo tipo y hasta

una longitud finita indicada al momento de su declaración. Sin embargo, en algunos lenguajes especificos, existen tipos de

arrays que no se apegan a estas reglas (ya sea almacenando valores de distinto tipo o siendo dinámicos, o sea, creciendo a

medida que decidimos almacenar un nuevo valor en ellos).

Los arreglos pueden ser unidimensionales o bidimensionales. Los primeros en la programación son conocidos como

vectores, y los segundos como matrices.

Independiente de su dimensionalidad, los arrays deben cumplir con ciertas características, algunas similares a las variables

que hemos visto hasta ahora y otras no tanto.

1.- Nombre: Todo array debe tener un nombre, el cual debe cumplir con las mismas características de los nombres de

variable, o sea, debe ser único, no debe ser una palabra reservada del lenguaje, ni empezar con números, guiones o

underscores (pueden llevar alguno de los 3 últimos entremedio).2.- Tipo: Todo array debe tener un tipo, que corresponde al tipo de valores que se podrán almacenar en el. Pueden ser los

mismos tipos que para las variables vistas hasta ahora.

3.- Posición: Aquí entra la diferencia. Para facilitar la visualización, imaginémonos que una variable común y corriente es

una cajón en el que guardamos algo. Ahora, cuando pensamos en un array, pensemos que es una cajonera, con un número

de cajones, dentro de los cuales se pueden almacenar varias cosas. Cada uno de estos cajones corresponde a una

“posición del array”. Cada posición es como si fuera una variable dentro del array y almacena un valor. Después cuando

queramos rescatar ese valor, se accede a la posición necesaria.



Veremos algunos esquemas ahora que especificaremos los tipos de arrays.

Vectores

Los vectores en la programación, son arrays unidimensionales en los cuales se pueden almacenar múltiples valores (finitos)

y que cuentan con las características anteriormente definidas.

Para declarar un vector, en pseudocódigo, lo hacemos de la siguiente forma:

Numero vector[5];

Tipo nombre[largo];

El largo indicara cuantas posiciones tendrá el vector, y por ende, cuantos datos se podrán

almacenar.

Antes de seguir, debemos hacer una salvedad. En el mundo de la computación, siempre se empieza a contar desde el cero

y no el uno. Eso debemos tener en cuenta cuando queramos acceder a una posición, ya que estaremos accediendo al

número correspondiente a si empezáramos a contar desde el cero. Por ejemplo, con ese vector que recién declaramos,tendríamos algo como esto:

0 1 2 3 4

Si nos fijamos, a pesar de ser un vector de largo 5, sus posiciones van desde el 0 a la 4, siendo estas a las que debemos

acceder si queremos recuperar la información almacenada ahí.

Para almacenar valores en un vector los asignamos de la misma forma que a una variable común y corriente, a diferencia de

que ahora debemos indicar el indice correspondiente a la posición donde almacenaremos el valor, por ejemplo, si queremos

almacenar el valor 2 en la tercera posición de un vector de 5 posiciones:

Vector[2]=2;

Y si queremos leer el valor de un vector, lo hacemos de la misma forma. Por ejemplo, si queremos

comprobar un valor en un Si:

Si(vector[2]==2)

Tanto para ingresar datos, como para leerlos, una operación común es recorrerlos mediante ciclos,

ya sea con un ciclo de tipo Mientras o uno de tipo Para. Al hacer esto, declaramos una variable

para utilizar como indice, la cual se irá moviendo a lo largo del vector. Por ejemplo, si quisieramos

llenar un vector con números iguales a su indice, haríamos algo como esto, asumiendo que elvector es de largo 5:

i=0;

mientras(i<5)

{

vector[i]=i;



i++;

}

Si en vez de ingresar datos, quisiéramos leerlos, lo hacemos de la misma forma.

Para resumir, veamos un ejemplo. En este caso lo que haremos será declarar un vector, decirle al usuario que llene los

valores para sus posiciones y luego las mostraremos por pantalla.

Inicio

Damos inicio al programa

Numero vector[5];

Numero i=0;

Declaramos el vector y la variable que utilizaremos como índice para recorrerlo.

principal()

mientras(i<5)

{

Mediante un ciclo mientras, le mostramos un mensaje al usuario para que ingrese el valor

correspondiente a la posición del vector y luego leemos el dato.

mostrar(“Ingrese el valor %numero del vector”, i);

leer(vector[i], &numero);

i++;

i=0;

}

mostrar(“Los valores ingresados fueron: “);

Mostramos el mensaje avisando que desplegaremos los valores.

mientras(i<5)

{



Dentro de un ciclo mientras, mostramos todos los valores almacenados en el vector.

mostrar(“%numero”, vector[i]);

i++;

}

Fin

Trabajar con vectores lleva un poco de costumbre, pero con práctica nos veremos utilizándolos

más y más a menudo y viendo como nos facilitan todo.

Matrices

Al igual que los vectores, las matrices son arrays. Sin embargo, a diferencia de ellos, son bidimensionales, o sea operan en

2 dimensiones, a las cuales nos referiremos como filas y columnas, como si fueran una especie de tabla.

Algo así:

Para declarar una matriz se hace igual que un vector, pero ahora en vez de indicar el largo, debemos indicar el número de

filas y el número de columnas. Como ejemplo:

Numero matriz[4][4];

Esa es una matriz cuadrada, de 4 filas y 4 columnas. No es necesario que siempre tengan el

mismo número de filas y de columnas. Al igual que en el álgebra, pueden variar.

Para el proceso de ingreso de datos en una posición de la matriz, debemos indicar su posición relativa con respecto a filas ycolumnas. Por ejemplo, si quisieramos almacenar el valor 8 en la segunda fila y primera columna, diríamos algo como esto:

matriz[1][0]=8;

Al igual que en los vectores, cuando queremos ingresar o leer múltiples datos, hacemos uso de

ciclos. La diferencia ahora es que para las matrices debemos utilizar 2 ciclos, uno que recorra las

filas y otro las columnas. Sería ejemplificado algo así, con una matriz de 4 x 4 y llenando todas sus

posiciones con un 8:

i=0;

j=0;

mientras(i<4)

{



mientras (j<4)

{

Matriz[i][j]=8;

j++:

}i++;

}

Para recorrer sería el mismo proceso, pero en vez de ingresar datos, los leemos.

Veamos ahora un ejemplo, donde primero declararemos una matriz, luego le diremos a un usuario que ingrese valores y

finalmente los mostraremos:

Inicio

Damos inicio al programa.

Numero matriz[4][4];

Numero i=0;

Numero j=0;

Declaramos la matriz y las variables que utilizaremos para recorrerlas.

Principal()

mientras(i<4)

{

mientras(j<4)

{

Dentro de los 2 ciclos necesarios para recorrer filas y columnas en la matriz, mostramos un

mensaje para que ingresen un valor a esa posición y luego lo leemos.

mostrar(“Ingrese el valor correspondiente a la fila %numero y la columna %numero”,i,j);

leer(%numero, &matriz[i][j]);

j++;

}

i++;

}



i=0;

j=0;

mostrar(“Los valores ingresados son: “);

Avisaremos que mostraremos los valores

mientras(i<4)

{

mientras(j<4)

{

Mostramos los valores recorriendo la matriz con los 2 ciclos necesarios.

mostrar(“%numero”,matriz[i][j]);

j++;

}

i++;

}

Fin

Como podemos apreciar, es un proceso bastante sencillo. La mayor complejidad se presente en

poder entender el tema de los índices, pero una vez que lo logramos, todo se vuelve muy simple.

Con este ultimo tema estamos llegando al final de esta edición, en la cual hemos cubierto el tema de los arrays por

completo, desde sus declaraciones hasta usos variados.

En la próxima edición:

1.- Funciones

2.- Ultimas consideraciones de Pseudo-codigo

3.- Entrando a un lenguaje real.

4.- Mas sobre los paradigmas de programación.

Y recuerden que como siempre, este tutorial ha sido desarrollado, probado y documentado por el equipo de Como Lo Hago,

por lo que cuenta con nuestro Sello de Garantía. Cualquier duda pueden consultarnos en el área habilitada a continuación.




Continuando con nuestra interminable reconocida y solicitada saga orientada a quienes se empiezan a adentrar al mundo de

la programación, hoy les traemos una nueva edición, realmente la última que veremos sobre Pseudo lenguajes y además

las últimas consideraciones previas a la entrada a los lenguajes reales.



Nota: Tal como dice el título, esta es la 6ta parte de estas guías. Para un completo entendimiento, recomendamos, si no lo

han hecho, leer las partes anteriores, las cuales pueden ser encontradas en la categoría de Programación de nuestros

tutoriales.

Con eso claro, veamos los contenidos que cubriremos hoy:

Contenidos:

1. Funciones.2. Ultimas consideraciones sobre Pseudo-código.

3. Entrando a un lenguaje real.

4. Más sobre los paradigmas de programación.

Como pueden apreciar, hay harto que cubrir, así que vamos directo a eso:

http://www.comolohago.cl/category/categorias/computacion/programacion/




1.- Funciones.

El último tema que cubriremos sobre programación en pseudo-código propiamente tal, será el de las funciones, el cual es un

elemento de suma importancia tanto para estas etapas tempranas como para cuando nos adentremos aun más en la

programación.

Intentaremos simplificar este tema lo que más podamos. De cualquier forma, a pesar de la complejidad que puede

presentar, no se preocupen si no lo entienden a la perfección en un comienzo, ya que a medida que vayamos viendo losejemplos y en otros contenidos más avanzados iremos comprendiendo bien este tema.

Hasta ahora, cada vez que escribíamos un programa y dentro de el necesitábamos tener procedimientos de cálculo o

manipulación de datos, los escribíamos línea por línea estructuradamente dentro del principal de nuestro programa, algo así:

Definición de variable / asignación de valor

Operación 1

Operación 2

Operación 3

Asignación de resultados

Si las operaciones anteriores las necesitamos utilizar más de una vez o para distintas variables,

adicionalmente podíamos añadirlas dentro de un ciclo, si el tipo de variables nos lo permiten, o

bien repetir las operaciones dentro del programa las veces que sean necesarias.

Ahora, si la operación es de una sola línea, como una operación matemática por sí sola, no presenta mayores

complejidades ni costos repetirla todas las veces que sean necesarias. Sin embargo, cuando hablamos ya de un proceso

que contiene varias operaciones, y por ende varias líneas de código, es cuando el tema se vuelve mucho más complejo y

engorroso, ya que nuestros programas empiezan a aumentar de tamaño y será mucho más costoso (computacionalmente

hablando) ejecutarlos.

Para esto es que se definen las Funciones, las cuales, como su nombre lo indica, ofrecen la funcionalidad de agrupar y

ejecutar una serie de operaciones, tanto por si solas como dependiendo de ciertos parámetros que les entreguemos, y a la

vez dándonos la opción de retornarnos un valor que puede ser constante o variable dependiendo de los resultados de las

operaciones y cálculos internos de la función.

La programación está compuesta fundamentalmente de funciones, y hasta ahora, a través de los contenidos y ejemplos,

hemos utilizado una serie de ellas. Por ejemplo, la parte principal que declaramos en cada programa que hacemos es una

función, es la que contiene los contenidos principales del programa que escribimos, valga la redundancia. A esa función no

le entregamos ningún tipo de parámetros y no nos retorna nada. Otras funciones que hemos utilizado hasta ahora son las

iteraciones condicionales (Si, Si no), los ciclos (mientras, para, haga mientras) y otras como leer, mostrar, etc.

¿Qué ventajas presentan las funciones?

Principalmente orden, comodidad y economía. El uso de funciones nos permite no tener que repetir operaciones según el

número de veces que las vayamos a necesitar y en vez de eso solo definirlas una vez y llamarlas cuando sea necesario.

Eso también implicará que nuestro programa sea mucho más liviano al momento de ejecutarse. Existen una serie de otras

ventanas que iremos descubriendo más adelante.

Las funciones se escriben fuera de la función principal (normalmente por orden, se escriben después) y se definen de

acuerdo a la siguiente estructura:

tipo nombre_función(parámetro 1, parámetro 2, etc.)

{

operación 1;



operación 2;

sentencia 1;

sentencia 2;

retorno de variable;

}

Donde:

1. Tipo: Detalla el tipo de valores que devuelve la función. Estos tipos pueden ser los mismos que los de las variables,

los cuales han sido especificados en los números anteriores de esta saga. Sin embargo, no hay que confundirse,

ya que por el hecho de que una función sea de un determinado tipo, no significa que dentro de las operaciones no

puedan declararse y usarse variables de otros tipos, solo debemos fijarnos que las variables que retornamos si lo

sean. Se debe definir un tipo para la función obligatoriamente.

2. Nombre de la función: Es un nombre único, tal como si estuviésemos definiendo una nueva variable. El nombre de

la función puede ser cualquiera, pero es recomendable, por orden, darle un nombre adecuado. Por ejemplo si

definimos una función que encuentre el número máximo entre una serie de valores, es recomendable nombrar a

esa función como numero_maximo. De esa forma, siempre podremos ver que hace cada parte de nuestroprograma rápidamente cuando lo estemos revisando.

3. Parámetros: Tal como hemos definido en distintas partes de esta saga de tutoriales, los parámetros que recibe una

función son los que utilizará para operar dentro de ella y devolver resultados. Normalmente las operaciones

declaradas en una función son procedimientos estándar que varían dependiendo de los valores que manejamos.

En una función podemos recibir múltiples parámetros y estos pueden ser de distintos tipos, solo debemos

asegurarnos de escribir primero el tipo y luego el nombre de ese parámetro, tal como si definiéramos variables.

Estos nombres no pueden repetirse dentro de la función.

4. Operaciones y sentencias: Básicamente podemos hacer lo mismo que hacemos dentro de nuestros programas, ya

sea usar operadores matemáticos, iteraciones condicionales, ciclos, mostrar, leer, etc. Todo está permitido.

5. Valor a retornar: Esto es opcional, una función puede o no retornar un valor, ya que muchas veces el resultado

podemos mostrarlo directamente en pantalla con la función mostrar. Si decidimos devolver un valor, lo hacemosmediante la sentencia retornar junto al valor o variable que enviemos. Solo debemos recordar que el valor o

variable retornado tiene que coincidir con el tipo de la función.

Con toda la definición ya más clara, veremos un ejemplo de declaración y uso de funciones:

Ejemplo: Realizaremos un programa en donde crearemos una función que defina que número es mayor entre 2 entregados

como parámetros. Los comentarios, como siempre, en negrita, cursiva y entre /* y */:

Inicio

/* Damos inicio al programa */

Numero num1, num2, mayor;

/* Declaramos 3 variables de tipo Número: num1 y num2 que serán 2 números que el usuario

ingresará por teclado, y mayor, que será donde se almacenará el número mayor después de que la

función nos devuelva el resultado */



principal ( )

{

/* Declaramos la función principal del programa */

mostrar(“Por favor ingrese el número 1: “);

leer(%numero, &num1);mostrar(“Por favor ahora ingrese el número 2: “);

leer(%numero, &num2);

/* Mediante mostrar y leer, recibimos por teclado los 2 números ingresados por el usuario */

mayor=numero_mayor(num1, num2);

/* A la variable mayor, le asignamos el resultado de llamar a la función numero_mayor, especificada

luego de la función principal, pasándole como parámetros las variables num1 y num2 */

mostrar(“El número mayor de los que ingreso es: %numero”, mayor);/* Nuestra variable mayor ya recibió el resultado de la función, así que lo desplegamos */

}

numero numero_mayor(numero valor1, numero valor2)

{

/* Declaramos una función de tipo numero, llamada numero_mayor y que recibe como parámetro

2 variables de tipo numero, llamadas valor1 y valor2, que corresponden a los num1 y num2

enviados desde arriba */

Si(valor1 > valor2)

{

retornar valor1;

}

Si no

{

retornar valor2;

}

/* Mediante una iteración condiciional, hacemos una comparación entre los 2 números y

retornamos el mayor de los 2 para que se le asigne a la variable mayor y se muestre por pantalla al

usuario. */

}



Fin

Con este simple ejemplo hemos podido apreciar un poco el funcionamiento y uso de las funciones

en la programación. Hay un importante concepto que hemos utilizado ahora, pero que

detallaremos más en profundidad cuando estemos hablando de lenguajes reales, que es el paso

de parámetros desde una función a otra (lo que hicimos cuando llamamos a la función y lo que

esta recibe por el otro lado). Por ahora no vale la pena entrar en esos detalles, pero ya losveremos más completamente.

Con las funciones sucede lo mismo, esta pasada que le hemos dado ahora es bastante superficial, pero iremos cubriendo

otros aspectos y descubriendo sus usos completos y más complejos a medida que vayamos programando más y más. Por

ahora es una buena técnica ir combinando los otros contenidos que hemos visto en los capítulos anteriores con esto e ir

practicando. Por ahora, al siguiente tema.

2.- Últimas consideraciones sobre el Pseudo-código:

En estos momentos que estamos llegando al final de nuestra cobertura sobre el pseudo-código o pseudo-lenguaje, es

bueno repasar algunas consideraciones antes de adentrarnos al lenguaje real en el que decidamos programar, por ejemplo:

1.- Recordemos que el pseudo-lenguaje no es un lenguaje de programación real, y por ende, lo que hemos cubierto hastaacá no lo encontrarán en libros o puede que aparezca de forma distinta. No se preocupen, el objetivo nunca ha sido ni será

que nos convirtamos en expertos de pseudo-código, si no que entendamos como se desarrollan los procedimientos en la

programación y como plantearnos soluciones a los problemas mediante el entendimiento de la estructura de los programas.

2.- El pseudo-código, a pesar de no ser un lenguaje real, utiliza un paradigma estructurado y por la forma y palabras que

normalmente se uilizan, se asemeja bastante al lenguaje C, por lo que es la opción natural para seguir. Veremos más de

esto en el próximo punto.

3.- Lamentablemente, al no tratarse de un lenguaje real, no existe ningún software que podamos utilizar para programar y

así ver nuestros errores para poder solucionarlos. Esto por un lado es bueno, ya que agudiza nuestra forma para leer el

código y detectar errores, algo que nos servirá de sobremanera más adelante.

4.- Es recomendable que repasemos e intentemos entender de la mejor forma todos los puntos explicados en esta ypasadas ediciones de esta saga. Si bien hemos cubierto una pequeña parte de todo lo que comprende la programación,

hasta ahora hemos visto las bases fundamentales para entender los lenguajes reales y todo el resto de aplicaciones dentro

de la programación, por lo que entender de la mejor manera estas bases será esencial para que la enseñanza no se

complique más adelante.

3.- Entrando a un lenguaje real:

Ahora que hemos de alguna forma “terminado” con el pseudo-lenguaje ha llegado un momento importante: Decidir el

lenguaje de programación que empezaremos a aprender.

Esta decisión no es sencilla, y depende de varios factores, entre ellos el paradigma de programación, la facilidad del

lenguaje, la extensibilidad y funcionalidades, actualización con los tiempos e incluso preferencia personal entre muchas

otras razones.

Al momento de elegir debemos tomar esas consideraciones, aunque también fijarnos en otras como la documentación

disponible, grupos de usuarios y todo lo que nos pueda apoyar a que el aprendizaje sea más sencillo.

Como experiencia personal, y el camino que seguiremos en esta saga de tutoriales, una de las mejores opciones para

continuar es el lenguaje C, esto debido a lo similar que es al pseudo-código que hemos visto y porque ambos comparten el

mismo paradigma estructurado, con lo que la transición se hace mucho más sencilla y así es posible pasar a otros lenguajes

con mayor facilidad en el futuro. Así que prepárense, que para allá vamos.



4.- Más sobre los paradigmas de programación:

Tal como veíamos en este tutorial, actualmente existen 4 paradigmas comunes de programación, como son (ojo que son

definiciones básicas, para que nos hagamos la idea de cada uno):

1. Paradigma estructurado: Es el paradigma que hemos estado viendo hasta ahora con el pseudo-lenguaje y que

luego veremos con C. Este paradigma, como su nombre lo indica, expresa una declaración y funcionamiento

estructurado para sus programas, en donde desde arriba a abajo en una misma “plantilla de programa” debe estar el inicio, la declaración de las variables del programa y las funciones (la principal y otras funciones). Todo definido

desde su inicio a su final. Además, los lenguajes estructurados se enfocan principalmente en el tratamiento de

datos, recibiéndolos, operando con ellos y mostrando resultados. No tienen más profundidad que eso.

2. Paradigma orientado a objeto: A diferencia del estructurado, en este paradigma, todo se trata como un objeto, cada

uno de ellos con atributos, tal como si habláramos de objetos del mundo real. Los lenguajes de POO (programación

orientada a objetos), operan mediante distintas clases, que son plantillas que determinan el comportamiento de un

objeto. Pueden haber clases donde se determine un objeto, sus atributos y los métodos (parecido a las

funciones) que se aplican a ellos y otras clases donde solo se encuentre el método principal (como la función

principal). Este es un paradigma mucho más complejo que no queremos detallar por ahora para no confundirnos,

porque el paso desde un lenguaje estructurado a uno POO complica al principio, pero no se preocupen, ya lo

veremos.3. Paradigma orientado a eventos: En este paradigma se habla de lenguajes que dentro de un programa, presentan

una serie de acciones que están “siempre listas” y se encuentran en espera para dispararse de acuerdo a un

evento que ocurra (normalmente ejecutado por un usuario). Por ejemplo, tenemos programas como Word o Excel,

que en sus menús y botones cuentan con múltiples mini-programas listos para ejecutarse cuando el usuario

presione el botón o seleccione el menú. Por ahora no adentraremos más en esto, por las mismas razones el caso

anterior.

4. Paradigma orientado a aspectos: Este es un paradigma que actualmente se encuentra bajo investigación, por lo

que no hay gran información disponible. Decidimos mencionarlo más por anécdota que por cubrirlo propiamente tal.

Quizás cuando estemos en números futuros de esta saga podamos ir adelantando más información.

Con esto podemos tener un poco más claro por qué existen distintos lenguajes de programación y que los diferencia, es

principalmente su paradigma.

Para casos de esta saga, por las razones antes descritas, seguiremos con el lenguaje C, el cual nos servirá de base para

todo el aprendizaje que tendremos que hacer.

Por ahora lo dejaremos hasta aquí, ya que hemos cubierto suficiente y es momento de tomar un descanso hasta tutoriales

futuros donde ya empezaremos a utilizar un lenguaje real de programación.


1. Introducción al lenguaje C.

2. Variables en C.

3. Funciones básicas.


Como siempre recuerden que este tutorial ha sido:







En la última edición de esta saga, dimos por concluído el aprendizaje de Pseudo-código, un paso importante al momento de

aprender a programar. Tan importante como el que prometimos que daríamos ahora, el ingreso al mundo de los lenguajes

reales de programación.

Hoy, y en las próximas ediciones, nos adentraremos de lleno en la programación en C, donde intentaremos cubrir todo lo

posible para que podamos convertirnos en unos aces de la programación.



Viendo que ahora ingresaremos a la programación propiamente tal, es bueno indicar los:





Implementos necesarios:

1. Un entorno de programación en C (recomendamos Dev C/C++ de Bloodshed, un buen entorno de programación

que además es gratuito. Ese es el que utilizaremos a través de los siguientes tutoriales. Pueden descargarlo

en este enlace).

Con todo eso claro, vamos a los contenidos que cubriremos hoy:

Contenidos:

1. Introducción al lenguaje C.

2. Librerías.

3. Variables en C.

4. Funciones básicas.

5. Primer programa en C.

1.- Introducción al Lenguaje C:

Nota: La instalación del entorno de programación, hemos decidido no cubrirla, ya que es bastante estándar en lo que a

instalaciones de programas se refiere. Les recomendamos hacer la instalación de forma normal, dándole siguiente en las

ventanas y dejando las opciones que vienen por defecto. Más adelante indicaremos si es necesario hacer cambios sobreesto.

Y bueno, llegamos al momento que tanto esperabamos: Empezar a trabajar con lenguajes reales de programación.

Para comenzar, hemos optado por el lenguaje C, debido a que por su forma y paradigma, es un buen y simple lenguaje para

continuar el aprendizaje. Además, como iremos viendo a medida que nos adentremos en los siguientes capitulos, tiene

mucha similitud con el Pseudo-código que hemos visto hasta ahora.

C es un lenguaje de programación que fue creado en 1972 en los laboratorios Bell. Utiliza un paradigma

estructurado (también denominado como imperativo y/o procedural) y presenta una eficiencia notable en su código, además

de características de bajo nivel que permiten controlar algunos aspectos de memoria y perifericos, por lo que se convierte en

la elección favorita e idónea al momento de desarrollar aplicaciones e incluso desarrollos para Sistemas Operativos.

Los programas desarrollados en C, presentan una estructura bastante similar a la que habíamos visto hasta el momento en

Pseudo-código, con algunas adiciones (como las librerías, que ya veremos) y uno que otro cambio, sobretodo en las

palabras reservadas y algunas formas de definir cosas. Todo esto lo iremos viendo a su debido tiempo.

En resumen, algunos puntos a considerar para el futuro:

• Los programas en lenguaje C, se escriben en entornos de programación, en realidad si queremos podemos

escribirlos en block de notas, pero los entornos de programación presentan funcionalidades que nos hacen la vida

mucho más fácil, desde la detección de errores hasta la orientación sobre algunas palabras reservadas y/o

comandos.

• En C, tal como en otros lenguajes, al momento de terminar nuestros programas, en el entorno de programación

podemos “compilarlos”, lo que significa que el entorno hará una revisión del programa completo en busca de

errores y nos advertirá sobre ellos para poder corregirlos.• Entre los tipos de errores que se pueden presentar al momento de compilar o terminar un programa, principalmente

tenemos 2: los léxicos y los sintácticos. Los primeros se refieren a cuando tenemos algo dentro de nuestro

programa que está mal escrito, por ejemplo si en vez de un ciclo while escribimos whlie. Por otro lado tenemos los

errores sintácticos, que se refieren a cuando lo que hemos escrito no tiene sentido, por ejemplo el querer asignar

un valor numérico a una variable de tipo carácter o algo por el estilo.

Iremos viendo más sobre estas y otras consideraciones y detalles a medida que vayamos avanzando en nuestro

aprendizaje.

http://prdownloads.sourceforge.net/dev-cpp/devcpp-4.9.9.2_setup.exe





2.- Librerías:

Un punto muy importante dentro de la programación, en especial en el lenguaje C, son las famosas y nunca bien

ponderadas librerías.

¿Qué es una librería?

Una librería es una plantilla que contiene una serie de funciones, las cuales pueden ser utilizadas

por un programa que ha invocado esta librería al inicio. Las librerías normalmente representan

una “categoría” de funciones (por ej. existe una librería donde están todas las funciones

matemáticas más comunes) y de acuerdo a eso las invocamos.

El lenguaje C nos proporciona múltiples librerías para nuestras necesidades, por lo que cada vez

que necesitemos realizar una determinada acción, podemos hacer una búsqueda de la función y

por ende librería correspondiente. Adicionalmente, podemos crear nuestras propias librerías y

utilizarlas libremente (así como otras que han sido creadas por otros usuarios y puestas adisposición en Internet).

Podemos reconocer las librerías por su extensión que es la letra “h”. Por ejemplo, si tuviéramos la

librería comolohago, la encontraríamos como comolohago.h. Estas librerías se encuentran en el

directorio include de nuestra instalación correspondiente al entorno de programación.

Tal como indicabamos en la definición, las librerías deben ser invocadas o en estricto

rigor “incluidas” en el programa donde las vayamos a utilizar. Para esto, al inicio, en las primeras

líneas de nuestro programa, debemos utilizar la sentencia #INCLUDE y el nombre de la librería

entre < y >. Por ejemplo, si quisiéramos incluir la librería “ejemplo.h”, pondríamos al inicio denuestro programa:

#INCLUDE <ejemplo.h>

Podemos incluir las librerías que queramos (siempre que existan). Sin embargo, no es

recomendable incluir librerías que no vayamos a utilizar, ya que es un gasto extra sobre el

programa. En caso de que alguna de las funciones, o sentencias de nuestro programa necesite de

una librería que no hayamos incluido, al momento de compilar nos lanzará un error avisándonos

del hecho.

Antes de concluir con el capítulo sobre las librerías, es bueno añadir que las más comunes que se usan en prácticamente el

100% de los programas en C son las librerias stdlib.h y stdio.h, por lo que siempre es bueno añadirlas. Otra de las comunes

es la conio.h, pero no es utilizada todo el tiempo y probablemente no la requeriremos hasta que vayamos mucho más

adelante.

3.- Variables en C:

Al igual que en Pseudo-código, en lenguaje C, así como en otros lenguajes, contamos con variables para almacenar, operar

y mostrar datos.



No entraremos en detalles sobre definiciones de que es una variable, porque esos temas ya los hemos cubierto en números

anteriores. Nos dedicaremos de lleno a cubrir las variables en C, las cuales son muy similares a las que utilizabamos en

Pseudo-lenguaje. Entre las más comunes que utilizaremos:

1. int: Se utilizan para almacenar y operar con números enteros (correspondiente al conjunto Z de las matemáticas).

Pueden almacenar tanto enteros positivos como negativos hasta un cierto rango (-32768 a 32767). Existen 2

variaciones que son el short int y el long int, los cuales varían en el rango permitido.

2. char: Se utilizan para almacenar caracteres, tal como el tipo Letra de Pseudo-código.3. float: Se utilizan para almacenar y operar con números decimales (correspondiente al conjunto Q de las

matemáticas). Adicionalmente se pueden utilizar para almacenar números enteros, pero no es lo recomendable. Su

rango va entre 3,4 *E-38 (elevado a) hasta 3,4 * E+38 (elevado a).

4. boolean: Almacenan datos de tipo booleano. Pueden tener 2 valores: true o false.

Esas son las variables principales que utilizaremos al programar. Iremos conociendo otras y viendo variaciones de estas

mismas a medida que vayamos adentrándonos más y viendo más ejemplos.

4.- Funciones básicas:

En nuestros primeros programas de Pseudo-código, utilizamos una serie de funciones básicas para leer datos desde teclado

o mostrarselos al usuario, así como operaciones matemáticas y otras cosas similares que nos ayudaron a llevar a cabonuestros programas más simples.

En C tenemos estos mismos operadores y funciones, con unas leves diferencias como veremos a continuación:

a) La Función Principal: En Pseudo-código utilizabamos la función principal ( ) que era donde escribíamos el cuerpo del

programa. En C también tenemos una función principal, pero la diferencia es que aqui tiene un tipo (tipo int) y su nombre

es main. Entonces, para declarar la función principal decimos:

int main( )

{

código del programa

}

Adicionalmente, podemos decir que la función main de C, cuenta con 2 parámetros como argc (de

tipo int) y argv (de tipo char, es un vector). Estos parámetros corresponden a argumentos que

nosotros le podemos dar a un programa particular, siendo el primero un entero que indica el

número de argumentos, y el segundo un vector de tipo char que contiene en cada posición los

argumentos que enviamos. Esto es un poco avanzado, así que no lo veremos aún, pero podremos

apreciar que es bastante útil.

b) Mostrando información por pantalla: Cuando queríamos mostrar algún tipo de información en pseudo-código, utilizabamos

la sentencia mostrar. En C, utilizaremos printf, la cual se utiliza de la misma forma que la veníamos utilizando hasta ahora,

es decir:

printf(“mensaje”);

o bien

printf(“%tipo de variable”,nombre de la variable);



Se puede utilizar una combinatoria de ambas. En la parte de %tipo de variable, utilizamos los tipos

definidos en el lenguaje C, como por ejemplo:

%d: Si la variable es un entero (int).

%f: Si la variable es un decimal o punto flotante (float).

%c: Si la variable es un caracter (char).

c) Leyendo información desde teclado: Tal como debemos recordar, en pseudo-código utilizabamos la sentencia leer. En

lenguaje C, utilizaremos scanf, que funciona de la misma forma que la hemos utilizado hasta ahora, es decir:

scanf(“%tipo de variable”,&nombre de la variable);

Como podemos apreciar, hay una diferencia con el caso de printf, y es que acá al momento de

hacer un scanf, al lado del nombre de la variable añadimos un &. Esto es necesario, ya que así le

decimos al programa que guarde la información en el área de memoria que asignamos para esa

variable cuando la declaramos. A esa área de memoria accedemos con &.

Cuando incluimos una sentencia de tipo scanf, el programa se detiene hasta que el usuario ingresa datos y presiona enter,

por lo que tenemos la seguridad que el resto del programa no se ejecutará hasta que se cumpla esa acción.

d) Operadores matemáticos y lógicos: Son bastante similares a los que utilizabamos en pseudolenguaje, o sea:

• +: Suma.

• -: Resta.

• *: Multiplicación.

• /: División.

• <: Menor que.

• >: Mayor que.

• ==: Igual a. (un solo igual es asignación de valor, no comparación).

• !=: Distinto que.

•

%: Módulo, o resto de la división.• ++: Incremento en uno.

• –: Decremento en uno.

Existen otros que iremos viendo a medida que los vayamos necesitando.

5.- Primer programa en C:

Para terminar con el capitulo de hoy, nos tomaremos un pequeño descanso de tanta teoría, y realizaremos nuestro primer

programa en C. Para eso, crearemos un archivo fuente donde estará nuestro código en nuestro entorno de programación (Si

instalaron Dev-C++ vamos al menú Archivo > Nuevo > Archivo Fuente o bien presionamos CTRL + N) con lo que se abrirá

una plantilla en blanco. Ahí es donde escribiremos el código.

Entonces bien, tal como fue clásico en pseudo-código, aquí lo seguirá siendo, así que haremos nuestro nunca bienponderado Hola Mundo, pero ahora en C. El código a continuación, y los comentarios como siempre, en negrita, cursiva y

entre /* y */:

#include <stdlib.h>

#include <stdio.h>

/* Partimos por incluir las librerías stdlib.h y stdio.h mediante #include */



int main() /* Declaramos la función principal */

{

printf(“Hola Mundo”); /* Mostramos el mensaje */

}

Con el código escrito, no nos queda más que probar nuestro programa. Así que primero vamos al

menúEjecutar > Compilar o bien presionamos CTRL + F9 en nuestro teclado. Esto nos pediráguardar el programa y se abrirá una ventana, ahí colocamos como nombre holamundo.c (o bien el

que uds quieran pero con la extensión .c) y en tipo seleccionamos C source files (*.c).

Guardamos y el entorno de programación compilará (o sea revisará el programa que escribimos en busca de errores). Si

encuentra algún error, nos indicará abajo donde está la falla. De lo contrario nos dirá que está listo y sin errores, por lo que

presionamos Cerrar en la ventana de aviso.

Luego, vamos al menú Ejecutar > Ejecutar o bien CTRL + F10 en nuestro teclado, y nuestro programa correrá (no saldrá

corriendo, sino que se ejecutará).

¿Funcionó?, ¿Se ejecutó y desapareció?, no se asusten. No hay nada malo con el programa. Es el entorno de

programación que por defecto cuando un programa termina, cierra la ventana de ejecución. Por ahora haremos un pequeño

truco para poder visualizar nuestro programa de forma correcta.Añadiremos luego del mensaje, una función básica de C llamada getch();, la cual cumple la función de dejar el programa en

espera hasta que el usuario presione una tecla, así podremos ver el resultado. Así que nuestro nuevo código quedaría de la

siguiente forma:

#include <stdlib.h>

#include <stdio.h>

int main()

{printf(“Hola mundo”);

getch();

}

Compilamos y ejecutamos de nuevo y veremos la ventana con el resultado de nuestro programa, o

sea, el mensaje “Hola Mundo”. Para cerrar solo presionamos una tecla.

Y con eso terminamos por hoy, donde hemos dado nuestros primeros pasos en el lenguaje C e incluso hemos realizado

nuestro primer programa.


1. Leyendo datos de teclado.2. Iteraciones condicionales.


Por ahora, recuerden que como siempre, este tutorial ha sido:



Cualquier duda o comentario, pueden dejarnos unas líneas en el área habilitada a continuación.




Ya dejando un poco atrás la locura navideña, y preparándonos para recibir este año 2009, hemos decidido hacer un alto de

las festividades (en confabulación con nuestro “maravilloso” servicio de hosting que nos ha fallado a diestra y siniestra, por

lo que ofrecemos nuestras disculpas) y traerles un nuevo número de esta gran saga que ha sacado chispas busca darles

una pequeña manito durante sus primeros pasos del mundo de la programación.

En el número anterior , nos adentramos en nuestro primer lenguaje real, C, haciendo una larga introducción y comparación

con lo que habíamos visto hasta ahora, terminando con nuestro primer programa. En esta ocasión, seguiremos

adentrándonos más en el tema y terminaremos con la confección de un programa algo más complejo.

Así que sin más espera, los invitamos a seguirnos después del salto, que no es en verdad un salto, sino que un “leer más”.


Nota: Como es habitual, les recomendamos, si no lo han hecho ya, leer los números anteriores de esta saga, que pueden

encontrar en la categoría de Programación de CLH.

Tal como prometimos en el número anterior, en este veremos los siguientes contenidos:

Contenidos:

1. Comentarios.

2. Leyendo datos desde teclado.



5. Ejercicio: Programando un terminal de venta simple.

Veremos bastante hoy, así que vamos, manos a la obra:

1.- Comentarios.

Si nos hemos fijado hasta ahora, siempre que realizamos algún ejemplo o ejercicio de código, en C, Pseudo-código o bien

en nuestros tutoriales de PHP, siempre ponemos las explicaciones entre unos símbolos /* y */.

Esto, junto a otros símbolos, es lo que en la programación (a todo nivel) se conoce como comentarios.

Los comentarios en la programación, si bien no son obligatorios, se convierten en una herramienta util y su mayor función esentregarnos la posibilidad de añadir pequeñas anotaciones sobre lo que estimemos conveniente, ya sea sobre el código

propiamente tal u otras cosas como notas de autoría o funcionamiento del programa en sí.

¿Por qué usar comentarios?

Principalmente por un tema de orden. Tenemos que pensar de que si bien nuestra memoria puede ser excelente, en más de

alguna ocasión nos tocará revisar códigos que hayamos realizado hace algún tiempo y puede que en ese programa

hayamos utilizado alguna función o lógica que no tiene sentido en este momento. Por eso el uso de comentarios nos

simplifica el tener que estar mucho tiempo deduciendo lo que alguna vez hicimos. Lo mismo se presta para cuando nuestro

código es revisado por terceros o bien nosotros revisamos códigos hechos por alguien más.

Hay 2 formas de comentarios: los de línea simple y los de múltiples líneas. La única diferenciación es en los símbolos que

utilizamos para iniciar y terminar los comentarios.

Cuando los comentarios son de línea simple solo debemos añadir al principio de la línea el símbolo // . Debemos tener en

cuenta de que solo será válido como comentario lo que escribamos en la misma línea. Si pasamos a otra línea lo tomará

como código y nos lanzará error, por lo que debemos utilizar símbolo de comentario de múltiples líneas.

Para múltiples líneas, utilizamos el mismo que hemos usado hasta ahora, o sea al principio del comentario ponemos /* y al

final del comentario cerramos con */. Todo lo que escribamos entremedio será considerado como comentario.

De cualquier forma, si es que les complica recordar los símbolos para cada caso, pueden utilizar siempre el formato de

múltiples líneas, que cubre comentarios ya sea en 1 línea o en varias.









2.- Leyendo datos desde teclado.

Cuando trabajabamos en Pseudo-código, una de las funcionalidades que más utilizabamos, era la lectura o recepción de

datos ingresados por un usuario vía teclado. Eso nos permitía interactuar de una mayor forma con quien utilizaba el

programa y realizar procesamientos mucho mejores y personalizados.

Pues bien, en C también podemos leer datos desde teclado, de una forma tan similar como en pseudolenguaje. Si

recordamos el tutorial anterior, hablábamos de la función scanf, la cual nos permitía realizar esa tarea y que se utiliza de lasiguiente forma:

scanf(“%tipodevariable”, &nombredelavariable);

Como podemos observar, esta función presenta 2 parámetros: %tipodevariable (entre

comillas) y&nombredelavariable, los cuales a su vez presentan 2 signos: % y &. Vamos por parte

explicando:

1. tipodevariable: Tal como hemos visto en numerosas ocasiones, cada variable que definimos en un programa

contiene un tipo de datos que puede almacenar (int, float, char, etc). A su vez, el lenguaje C utiliza unos simbolos

que representan esos tipos y que se incluyen en las funciones scanf y printf para decirle al compilador que tipo dedato es el que estamos leyendo/mostrando. Estos simbolos son la d para variables de tipo int, la f para variables de

tipo float y la c para variables de tipo char entre otras.

2. El símbolo %: Este símbolo siempre debe ir por obligación acompañando a los símbolos indicados en el punto

anterior, de esta forma el compilador comprenderá que estamos hablando de un tipo de dato y no de una

consonante por sí sola.

3. nombredevariable: Es el nombre que le damos a una variable en particular cuando la definimos.

4. El símbolo &: En el lenguaje C, cuando utilizamos el símbolo & junto al nombre de una variable, le estamos

diciendo al compilador que nos estamos refiriendo al área de memoria en el que esa variable almacena su

información. Como dijimos hace algún tiempo, toda variable al momento de ser creada, apunta a un área de

memoria interna del computador para manipular su información. A esta área accedemos con el símbolo & cuando

leemos un dato.Con esas definiciones claras, veamos un pequeño ejemplo, para lo que utilizaremos el entorno de programación que

instalamos en el número anterior:

Ejemplo: Realizar un programa que lea un dato numérico por teclado y luego mostrarlo por pantalla. (La explicación del

código, como siempre en negrita, cursiva y entre /* y */.

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

/* Partimos por agregar las librerías necesarias para nuestro programa, incluida la conio.h para

hacer uso de la función getch( ); */

int numero;

/* Declaramos una variable llamada numero de tipo int */



int main( )

{

/* Declaramos la función main o principal */

printf(“Ingrese un numero del 1 al 10: “);

/* Mostramos un mensaje al usuario para que ingrese un numero del 1 al 10 */

scanf(“%d”, &numero);

/* Con scanf leemos el dato, indicando con %d que es un dato de tipo int e indicamos que

guardaremos la información en el área de memoria de la variable numero poniendo &numero */

printf(“Ingreso el numero %d”, numero);

getch();

/* Mostramos el numero que ingreso el usuario, poniendo un mensaje con printf y en la posición

donde mostraremos el número ponemos el símbolo correspondiente al tipo de dato, o sea %d, yluego de la coma la variable que mostraremos. En la línea siguiente ponemos un getch ( ); para

que el programa quede en espera hasta que presionemos una tecla y así podamos ver el resultado

antes que se cierre */

} // Cerramos llave de la función main.

Compilamos el programa y no deberíamos tener errores. Lo ejecutamos y probamos que funcione.

Así de simple es la captura de datos vía teclado.

3.- Iteraciones condicionales.

Las iteraciones condicionales en C son bastante similares a las que vimos en pseudocódigo (Si y Si No, Switch) y cumplen

exactamente la misma función, esto es, ejecutar una serie de acciones a partir del cumplimiento de una condición. No

entraremos en mayor detalle, pues lo vimos de forma bastante completa en el pasado.

En lo que si adentraremos es en como se usan en C:

Si y Si no

En C se utiliza de la misma forma, radicando la diferencia en que en vez de ser Si y Si no, hablamos de if yelse. Esta

iteración tiene las mismas características que en pseudo, o sea, todo else debe ir luego de un if y dentro de un if y de un

else pueden ir múltiples if y elses. La forma de declaración es:

if(condición)

{

sentencia 1;

sentencia 2;

}

else

{



sentencia 3;

sentencia 4;

}

Cuando utilizamos if y else, podemos o no usar llaves para abrir y cerrar el if. Cuando un if y/o unelse tienen solo una sentencia a ejecutar, podemos escribirlos sin llaves para abrir y cerrar. Si es

más de una sentencia, necesariamente deben llevar llaves. Si desean, para evitar confusiones,

podemos utilizar siempre las llaves.

Veamos un ejemplo ampliando el caso anterior. También pediremos un dato al usuario, pero en vez de mostrarlo lo

someteremos a un simple if y else para ver si el número es mayor a 5:

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

int numero;

int main()

{

printf(“Ingrese un numero del 1 al 10: “);

scanf(“%d”,&numero);

/* Primero vemos con un if si el numero es igual a 5. Recordemos que para comparar utilizamosdoble signo igual */

if(numero==5)

printf(“El numero ingresado es 5″);

else // Si no es igual a 5

if(numero > 5) // Si es mayor a 5 mostramos el mensaje

printf(“El numero ingresado es mayor a 5″);

else // Si es menor a 5 mostramos el mensaje

printf(“El numero ingresado es menor a 5″);

getch();

}

A medida que vayamos avanzando, el uso de if y else será más complejo y largo, pero la lógica es

básicamente la misma.

La iteración switch la veremos en el próximo número, ya que implica un mayor nivel de detalle y no queremos extendernos

por sobre los demás contenidos de momento.



4.- Ciclos o búcles.

Tal como las iteraciones, en pseudolenguaje también definimos y utilizamos ciclos y búcles que cumplen la misma

funcionalidad que en C, por lo que no nos desviaremos definiendo nuevamente esos temas, si no que veremos cada caso

para C y luego un ejemplo que los reune a todos.

Mientras

El ciclo mientras que usabamos en Pseudocódigo, en C (y otros lenguajes) es conocido como while y es uno de los más

usados. La forma de utilizarlo es la misma, o sea:

while(condición)

{

sentencia 1;

sentencia 2;

}

Tal como en Pseudo, este ciclo sólo se ejecutará (y se mantendrá en ejecución) mientras la

condición se cumpla.

Para

Este ciclo en lenguaje C es conocido como for y se utiliza de la misma forma, o sea:

for(inicialización de variable ; condición ; aumento o decremento de la variable)

{

sentencia 1;

sentencia 2;

sentencia 3;

}

Tal como en el caso del ciclo while, este ciclo se continuará ejecutando mientras se cumpla la

condición, pero a diferencia del anterior, este siempre se ejecutará, ya que la variable para la

condición se inicializa dentro del propio ciclo.

Haga mientras

Corresponde al ciclo do-while, bastante similar al caso del while pero con 2 diferencias. Este ciclo se ejecutará al menos 1

vez aunque la condición no se cumpla y el while del final debe ir con punto y coma, o sea:

do

{

sentencia 1;

sentencia 2;

sentencia 3;

}while(condición);

Tal como en pseudolenguaje, hay ocasiones ideales para el uso de cada tipo de ciclo, pero en

muchas ocasiones podemos usar cualquiera de los 3 y dependerá más que nada del gusto

personal.

A continuación veremos un ejemplo en donde utilizaremos los 3 ciclos para resolver un mismo problema.



Ejercicio: Enumerar del 1 al 10 utilizando los 3 ciclos vistos hasta ahora.

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

int numero;

int main()

{

numero=1; // Asignamos el valor inicial a la variable

while(numero<=10) // Partimos con un ciclo while

{

printf(“%d\n”,numero); /* Mostramos el número y utlizamos \n para hacer salto de línea */

numero++; // Incrementamos el valor

}

for(numero=1;numero<=10;numero++) // Seguimos con un ciclo for especificando los parámetros

{

printf(“%d\n”,numero); // Mostramos el número

}

numero=1; // Reinicializamos el número a 1

do // Terminamos con un ciclo do-while

{

printf(“%d\n”,numero); // Mostramos el número

numero++; // Incrementamos el valor

}while(numero<=10); // Definimos la condición

getch(); // Dejamos el programa en espera

}

Luego de compilar y ejecutar podemos ver que como resultado se enumerará del 1 al 10, 3 veces

seguidas, 1 por cada ciclo que definimos.

5.- Ejercicio: Programando un terminal de venta simple.

Ahora que hemos visto aspectos básicos del lenguaje C, desarrollaremos un ejercicio en el que combinaremos todos los

conocimientos adquiridos hasta ahora.

Lo que haremos será programar un terminal de venta simple, en donde primero desplegaremos una lista de productos,

luego pediremos el código del producto, la cantidad que se desea llevar y mostraremos el total a cancelar. No nos

complicaremos mucho y en el futuro iremos añadiendo nuevas funcionalidades. Así que manos a la obra:



#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

int codigo, cantidad, valor, total, vuelto, pago; /* Declaramos las variables que usaremos, todas de

tipo int */

int main()

{

printf(“\t Lista de productos\n”); /* Partimos por listar los productos, utilizamos \t para separar los

textos, tal como si utilizaramos la tecla TAB */

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: “); /* Solicitamos el código del producto*/

scanf(“%d”,&codigo); /* Leemos el código */

printf(“\nIngrese la cantidad que desea llevar: “); /* Solicitamos la cantidad que llevarán */

scanf(“%d”,&cantidad); /* Leemos la cantidad */

if(codigo==1) /* Comparamos mediante iteraciones el código para asignar el valor total */

valor=100;

if(codigo==2)

valor=350;if(codigo==3)

valor=200;

total=valor*cantidad; /* Multiplicamos el valor por la cantidad para obtener el total */

printf(“\nEl total es de: %d”,total); /* Mostramos el total */

printf(“\nIngrese el pago: “); /* Solicitamos el pago */

scanf(“%d”,&pago); /* Leemos el pago */

if(pago<total) /* Vemos mediante un if si el pago es suficiente */printf(“\nEl pago no es suficiente”);

else

{

vuelto=pago-total; /* Obtenemos el vuelto */

printf(“\nEl vuelto es de: %d”,vuelto); /* Mostramos el vuelto */

}

printf(“\nVenta finalizada”); /* Damos el mensaje de despedida */

getch();



}

Y así tenemos nuestro simple terminal de venta. Como podemos apreciar, este programa no es lo

suficientemente óptimo, ya que solo podemos realizar 1 venta por sobre 1 sólo producto, así que

su aplicación es bastante limitada. Para poder realizar múltiples ventas o 1 venta de múltiples

productos es necesario el uso de ciclos para poder repetir las acciones necesarias.

Desde ya los incentivamos a que vayan modificando este programa y agregando esa funcionalidad. De cualquier forma enlas próximas lecciones le iremos añadiendo más y más cosas a este programa para crear una aplicación mucho más

completa.

Con esto damos por terminada la lección de hoy, hemos cubierto bastante y aún nos queda un largo camino por recorrer, así

que mucha paciencia.

En la próxima edición de Como aprender a programar y no morir en el intento veremos:

1. Iteración Switch.

2. Vectores.

3. Matrices.

4. Terminal de venta – 2da parte.

Recuerden que como siempre, este tutorial ha sido:


Muchas gracias por leer, y será hasta una próxima oportunidad.



Empezamos ya de lleno el 2009, y que mejor que seguir con lo que el 2008 nos dió tantos dolores de cabeza ayudó a entrar

de mejor forma al mundo de la programación.

Hoy, en la parte 9, o primera del 2009, seguiremos viendo contenidos del lenguaje C, así como el programa que empezamos

a confeccionar en la edición pasada.

Así que los invitamos a seguirnos, como siempre, después del salto.


Nota: Como siempre, les recomendamos, si es que no lo han hecho, leer los números anteriores de esta guía, los cuales

pueden ser encontrados en nuestra categoría de programación.

Si recuerdan el número anterior, en esta ocasión veremos:

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 comoexplicá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 switchdebe ser

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]);

}


}

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”);

}


}

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(“\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(“\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 */




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 */


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(“\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.

En la próxima edición de “Cómo aprender a programar y no morir en el intento”:



1. Método de ordenamiento: El método de la burbuja.

2. Método de busqueda: Búsqueda secuencial.

3. Funciones.

4. Continuación del términal de ventas: Añadiendo un menú.

Se nos acabaron las imágenes humorísticas

Bienvenidos a una nueva edición de “Como aprender a programar y no morir en el intento”. Soy su anfitrión, Juan Xabadu,

y tal vez me recuerden de películas como: “Querida, me caí del Taxi” y “Jurassic Park vs Forrest Gump” como siempre, los

acompañare en esta gran aventura en que nos hemos embarcado hace bastante tiempo, dando nuestros primeros pasos en

el mundo de la programación.

Hoy veremos los primeros contenidos sobre métodos de búsqueda y ordenamiento, así como funciones y continuaremoscon nuestro ejemplo del terminal de venta.

El detalle, como siempre, después del salto.


Tal como adelantábamos en el número anterior, los contenidos de hoy:

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 demenor 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 unahasta 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>


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>


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(“\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 */


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í seejecutará 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 */


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(“\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.

Y eso sería en la edición de hoy de Como aprender a programar y no morir en el intento. En el próximo número cubriremos:

1. Paso de parámetros por valor y por referencia.

2. Estructuras.

3. Recursividad.

Como siempre, les recordamos que este tutorial ha sido:



Bueno, bueno, bueno. Nos demoramos un poco (casi 13 meses), pero lo prometido es deuda: Volvemos con la saga que

intenta guiarlos por el largo y complejo camino de la programación.

¿Por qué nos demoramos tanto? Es una buena pregunta, gracias por hacerla -> !. La verdad es que una vez que

terminamos la parte 10 y estaban definidos los contenidos para continuar nos dimos cuenta que estábamos entrando en

temas bastante avanzados, lo que se alejaba de la intención inicial de estas guías, por lo que decidimos pausar el tema y

reconsiderar como seguir. Lamentablemente hubo otros temas que fue necesario cubrir en la cola de peticiones (nuestro

buzón explota cada día con todo lo que llega) y el tiempo fue pasando hasta que llegamos a la fecha.

Pero ha llegado el día de continuar y hemos reestructurado el modelo de esta saga para que tengamos una gran cantidad

de números por delante. ¿Cómo? se preguntarán. Bastante simple: En las primeras 10 partes estuvimos viendo desde los

conceptos más básicos de antes de programar hasta la base de desarrollo estructurado, por lo que empezando en este

número, veremos algo completamente nuevo(probablemente hasta el número 20) para entregar las nociones necesarias y

luego continuaremos con otro enfoque. Lo sabemos, es enredado, pero con el tiempo se irá entendiendo, confíen en

nosotros

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.


Nota: Si bien hoy comenzamos a trabajar con un paradigma nuevo, siempre recomendamos leer las partes anteriores de

esta saga, las cuales pueden ser encontradas en nuestra categoría deProgramación.

Pues bien, tal como anunciábamos, hoy comenzamos con programación orientada a objetos. Esta parte de la guía será

mucho más conceptual que técnica, ya que hay varios contenidos que es bueno que aclaremos para establecer una base

sólida y poder trabajar de mejor manera a futuro. Así que sin más, vamos:

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:

http://www.comolohago.cl/category/computacion/programacion/

http://www.comolohago.cl/category/computacion/programacion/



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 deventajas (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.

A contar de la parte 12 ya comenzaremos a operar bajo un modelo de una parte de conceptos y un ejemplo al final de cada

número, con el fin de que vayamos soltando la mano y vayamos aplicando todo lo que veamos.

En la próxima edición de ‘Cómo aprender a programar y no morir en el intento’:

1. El Constructor (Y no hablamos de Bob).

2. Permisos.

3. Clase principal.

4. Creando nuestra primera aplicación en POO.

aprendiendo programacion

Documents

Transcript of aprendiendo programacion