FUNDAMENTOS DE PROGRAMACIÓN · Unidad Il. Fundamentos de programación estructurada ... Gestionar...

I N S T I T U T O P O L I T É C N I C O N A C I O N A L

2013

FUNDAMENTOS DE

PROGRAMACIÓN RODRIGO AVILÉS VILLAREAL

ESIME TICOMÁN

1

ÍNDICE

Unidad I. Introducción a la Programación .................................................................................................. 1

1. Definición, características y función de un Sistema Operativo........................................................ 1

1.1 Análisis comparativo de Sistemas Operativos. Linux y Windows. ...................................... 5

2. Definición de características de los Lenguajes de programación. Visual Basic, Java y

Lenguaje “C”. ............................................................................................................................................. 10

3. Compilador (Dev C++) ........................................................................................................................ 16

Unidad Il. Fundamentos de programación estructurada ........................................................................ 19

1. Estructura general de un programa. .................................................................................................. 20

1.1 Tipos de variables ..................................................................................................................... 28

1.2 Constantes (uso de #define) ................................................................................................... 42

1.3 Operadores ................................................................................................................................ 45

2. Funciones de entrada .......................................................................................................................... 68

2.1 La función scanf() ...................................................................................................................... 68

2.2 Las funciones getch() y getche() ............................................................................................. 70

3. Funciones matemáticas ....................................................................................................................... 73

4. Funciones generadas por el usuario ................................................................................................. 78

4.1 Declaración y definición de una función ..................................................................................... 78

4.2 Función sin argumentos que no devuelve ningún valor .......................................................... 80

4.3 Función con argumentos que no devuelve ningún valor ......................................................... 82

4.4 Función sin argumentos que devuelve un valor ....................................................................... 85

Unidad III. Sentencias de control ............................................................................................................... 90

1. Sentencia de control for ...................................................................................................................... 90

2. Sentencias de control while y do while ............................................................................................ 96

3. Sentencia de control if else .............................................................................................................. 105

4. Sentencia de control break ................................................................................................................ 112

5. Sentencia de control switch .............................................................................................................. 116

6.Sentencia de control goto ................................................................................................................... 123

Fundamentos de Programación Unidad I. Introducción a la Programación

Unidad IV. Estructuras de datos .............................................................................................................. 133

1. Arreglos (Arrays) Unidimensionales ................................................................................................ 133

2. Arreglos de caracteres (strings) ...................................................................................................... 140

3. Arreglos (Arrays) Bidimensionales ................................................................................................... 148

4. Apuntadores (Punteros) Concepto ................................................................................................. 155

5. Operadores con apuntadores ........................................................................................................... 162

6. Relación de apuntadores con arreglos........................................................................................... 166


1

Unidad I. Introducción a la Programación

1. Definición, características y función de un Sistema Operativo

Mapa de conceptos

Introducción.

Cuando se enciende una computadora comienza a trabajar en ella un conjunto de programas de aplicación. Para que este conjunto de programas trabajen ordenadamente se requiere de un Sistema Operativo.

El Sistema Operativo es un programa que proporciona el ambiente sobre el cual los demás programas funcionarán, además de brindar una interfaz entre el usuario y la computadora.

Para todo programador es necesario identificar el concepto, características y función de

un sistema operativo ya que los programas que desarrollarás en esta unidad de

aprendizaje y en otras unidades, se ejecutarán dentro de un sistema operativo, por lo

tanto es necesario conocer el ambiente sobre el cual se trabaja.

Comentamos en líneas anteriores, acerca de un Sistema Operativo, pero veamos

exactamente a que nos referimos.

Definición, características y función de un Sistema

Operativo

Unidad I

Introducción a la Programación

Definición de características de los Lenguajes de programación. Visual Basic, Java y Lenguaje “C”.

Compilador

(Dev C++)

Análisis

comparativo

de Sistemas

Operativos.

Linux y

Windows


¿Qué es un Sistema Operativo?

Un Sistema Operativo (SO) es el programa encargado de

controlar y administrar tanto el software como el hardware y

todos los recursos en una computadora.

Por ejemplo Windows es el SO en el cuál se pueden correr

programas como Microsoft Oficiey Adobe Reader,Windows

se encarga de gestionar y brindar los recursos y

herramientas que estos programas requieren para su

funcionamiento.

Un SO provee un ambiente sobre el cual puedan ejecutarse

otros programas los cuales se apoyan en él para poder

acceder a los recursos que necesitan como memoria o la

atención del procesador, es decir, que el procesador le

brinde un poco de “tiempo” ya sea a las funciones que realizan el monitor, descargar un

archivo, o utilizar un teclado, entre otras funciones.

El SO brinda a los usuarios los medios necesarios para que pueda establecerse una

comunicación con él, para dar órdenes e instrucciones a la computadora, con el objetivo

principal de lograr que tanto el software (los programas) como el hardware (los

componentes físicos de la computadora) se empleen eficientemente.

Nótese que un error común es denominar al conjunto completo de herramientas y

programas sistema operativo, por ejemplo pensar que Microsoft Office, Internet Explorer,

WinRAR, etc., son parte del SO, esto es un error ya que solamente Microsoft Windows es

el sistema operativo y los otros mencionados son aplicaciones de propósito específico.

En otras palabras un SO es el software (Windows, Linux) sobre el cual se instalan y

ejecutan otros programas (office, adobe Reader, AutoCad, etc.).

¿Cuáles son las características más importantes de un Sistema Operativo?

En general, un Sistema Operativo tiene las siguientes características:

Conveniente. Un SO hace más sencillo el uso de una computadora cuando el sistema operativo brinda una interfaz gráfica. Por ejemplo: el escritorio de una computadora cuando la encendemos.


Eficiente. Un Sistema Operativo hace que todos los recursos de una computadora trabajen lo más eficientemente posible. Flexible. Un SO permite el desarrollo, prueba o introducción efectiva de nuevas funciones del sistema sin interferir con el correcto funcionamiento del equipo de cómputo. Por ejemplo, Instalar una actualización sin interferir con el trabajo que se está realizando en un documento Word. Administrador eficiente. El SO es encargado de administrar y manejar eficientemente todos los recursos de una computadora, por ejemplo: la memoria RAM, el disco duro, el procesador, la tarjeta de video y los puertos. Gestor de dispositivos El SO se encarga de controlar la comunicación entre los dispositivos periféricos, cuando el usuario así lo requiera, por ejemplo, se encarga de comunicar al teclado o al mouse de una computadora cuando estos son accionados por el usuario. Facilitador. El SO facilita la entrada y salida de datos así como el acceso y manejo de los dispositivos de Entrada/Salida de la computadora, por ejemplo observamos la facilidad con que podemos enviar un archivo desde “Mis documentos” hacia una memoria USB instalada en nuestra computadora.

¿Qué hace un Sistema Operativo?

Las funciones básicas de un Sistema Operativo son:

Interpretar los comandos que permiten al usuario

comunicarse con la computadora, a través de la

interfaz.

Coordinar y manipular el hardware de la

computadora, como la memoria RAM, las

impresoras, las unidades de disco, el teclado o el

Mouse.


Organizar los archivos en diversos dispositivos de almacenamiento, como discos

duros, discos compactos o memorias USB.

Gestionar los errores del hardware y la pérdida de datos, es decir, envía mensajes

de error cuando se da una orden que no se puede ejecutar y da opciones de

solución.

Organizar datos para acceso rápido y seguro, es decir, permite generar y

administrar un directorio de carpetas para organizar los archivos, por ejemplo: las

carpetas “mis documentos”, “system”, “Archivos de Programa”, etc.

Permite al usuario manejar las comunicaciones en red con gran facilidad todo lo

referente a la instalación y uso de redes, por ejemplo, en un cibercafé todas las

computadoras comparten el internet y el SO es el encargado de hacer esto posible.

Para saber más:

Los Sistemas Operativos más utilizados son Windows, Linux y

Mac. Algunos SO ya vienen con un navegador integrado, como

Windows que trae el navegador Internet Explorer.

En Linux el navegador es FireFox.

Hasta aquí has aprendido la importancia del SO y que gracias a él se pueden ejecutar

otros programas que ayudan a realizar trabajos en las computadoras, ahora es momento

de que pongas en práctica los conocimientos adquiridos en este apartado.

Actividad de aprendizaje 1. “SO”

El objetivo de esta actividad es que conozcas e identifiques los elementos básicos de los

sistemas operativos.

Instrucciones:

En esta actividad deberás responder con tus palabras un breve cuestionario, mismo que

se te presenta en un documento Word a continuación.

Descarga el archivo “SO Cuestionario” y respóndelo.

Cabe aclarar que si tu asesor detecta que “copiaste y pegaste” la información de una

página de internet, se anulará esta actividad.

Cuida tu ortografía, sintaxis y redacción ya que también se te tomará en cuenta para la

calificación.


Al terminar de responder el cuestionario guárdalo en tu PC y envíalo a tu profesor con tus

datos en el siguiente formato: apellidopaterno_materno_nombre_actividadnumero.

La comparación de los sistemas operativos Microsoft Windows y Linux es un tema muy

común entre los usuarios. Windows es el sistema operativo más utilizado bajo una licencia

propietaria de software, esto quiere decir que tenemos que pagar por el uso de este SO,

mientras que Linux es el sistema operativo más importante bajo una licencia libre de

software, esto quiere decir que el usuario no tiene que pagar por el uso de este SO.

1.1 Análisis comparativo de Sistemas Operativos. Linux y Windows.

¿Qué es Linux?

Linux es un sistema operativo construido por un equipo de

desarrolladores de todo el mundo. Contiene todas las

aplicaciones que necesitas: un navegador web, aplicaciones

ofimáticas, de mensajería y muchas otras más.

Existen muchas distribuciones diferentes de GNU/Linux: Debian, Gentoo, RedHat o

Mandriva son algunos ejemplos.

Por otra parte, casi todos hemos utilizado alguna vez el sistema operativo de Microsoft

Windows en alguna de sus versiones, hemos descubierto y experimentado las

herramientas y aplicaciones que nos brinda este SO, realizamos nuestras tareas,

navegamos por el internet, chateamos, vemos videos, escuchamos música, digitalizamos

e imprimimos nuestros archivos, grabamos música, en fin nos es muy cotidiano el uso de

este SO.

A continuación se muestra una pequeña comparación entre algunas características de

Windows y de Linux

Instalación:

En Linux la instalación no es sencilla, pero te permite personalizar totalmente los

paquetes que quieras instalar.

En Windows la instalación es mínimamente configurable aunque es muy sencilla.

Compatibilidad:

Ninguno de los dos sistemas operativos son totalmente compatibles con la totalidad

del Hardware existente en el mercado.


Linux gracias a su popularidad ofrece una alta compatibilidad ofreciendo, además,

actualizaciones frecuentes.

Windows ofrece una gran cantidad de drivers.

Programas:

Linux posee menos software y en algunos campos, por ejemplo las industrias, tiene

una menor aceptación, aunque gracias a los apoyos de empresas como Sun

Microsystems o IBM ha logrado muchos avances.

Windows al ser el más usado, posee una gran cantidad de software.

Robustez:

En Linux puede pasar mucho tiempo e incluso años sin la necesidad de apagar o

reiniciar el equipo, si una aplicación falla este error no bloquea totalmente al

equipo.

En Windows siempre hay que reiniciar cuando se cambia la configuración del

sistema, y se bloquea fácilmente.

Ya que conoces algunas características importantes de ambos sistemas operativos se te invita a probar lo que millones de personas alrededor del mundo han denominado como “El mejor Sistema Operativo del Mundo”, Linux:

En el siguiente video tutorial se muestran los pasos que necesitas seguir para descargar e

instalar Ubuntu 10.10 MaverickMeerkat en tu computadora, se te recomienda observar la

totalidad del video antes de comenzar.

Nota importante: La instalación de Ubuntu 10.10 se realiza como la instalación de cualquier otro programa bajo Windows, esta instalación no borrará ni dañara tus archivos, tampoco descompondrá tu computadora y puedes trabajar con cualquiera de los dos SO Windows o Linux.

Actividad de aprendizaje 2 “Instalación de Linux (Ubuntu 10.10)”

Ya conoces algunas características tanto de Windows como de Linux, ahora es tiempo de

que realices algunas pruebas con el programa que acabas de instalar en tu PC, el objetivo

de esta actividad es que utilices los elementos básicos del Sistema Operativo Linux

(Ubuntu), de manera analítica y reflexiva para descubrir el uso, características, ventajas y

desventajas de este sistema operativo en su modo gráfico y compararlo con el Sistema

Operativo Windows.


Para realizar la actividad necesitas un cronometro (puedes ocupar tu reloj o tu celular),

lápiz y una hoja de papel

A continuación se te dan las instrucciones para realizar esta actividad, de las cuales en un

primer momento vas a ir registrando los resultados en una hoja de papel y posteriormente

en una tabla que elaborarás con OpenOffice.org Writer, que es un programa de Linux.

Para saber más:

OpenOffice.org Writer es un procesador de texto que forma parte

del conjunto de aplicaciones de la suite ofimática OpenOffice.org.

Además de otros formatos estándares y ampliamente utilizados de

documentos, puede abrir y grabar el formato propietario .doc de

Microsoft Word casi en su totalidad. El formato nativo (por defecto)

para exportar documentos es XML. También puede exportar a

ficheros PDF nativamente sin usar otros programas intermedios

Instrucciones:

1. Dibuja la siguiente tabla en una hoja de papel, en ella vas a ir registrando los

resultados de esta actividad, no la copies, ya que las vas a elaborar

posteriormente.

Características WINDOWS(Especifica tu versión)

LINUX (UBUNTU 10.10)

Tiempo de apagado

Tiempo de Encendido

Respuesta Inmediata

Rapidez al abrir un

programa

2. Estando dentro de Windows apaga el sistema operativo y registra el tiempo que

tarda en hacerlo, mide el tiempo a partir del momento en que des clic sobre el

botón apagar y anótalo en la tabla de tu hoja de papel.

3. Enciende nuevamente tu computadora e inicia en Windows, registra el tiempo que

tarda en cargar todos los programas, hasta el momento en que se muestra el

escritorio por primera vez.

4. Inmediatamente después de que se muestra el escritorio da clic sobre el botón

inicio y ve a la opción “Mi PC” o “Equipo” (dependiendo de la versión de tu SO). y

da clic sobre ella, observa si la respuesta es inmediata, es decir si aparece de


inmediato la ventana de esta opción. tu anotación en la hoja de papel será “si o no”

dependiendo de tu resultado.

Nota: Es importante que sea inmediatamente después de que se muestra por primera vez

el escritorio al encender la computadora.

5. En este momento registrarás en la hoja de papel si el proceso de abrir un

programa, es rápido o lento, ve al menú inicio y abre Microsoft Office Word,

observa la rapidez con que se abre el programa y registra tu observación, tu

respuesta en la hoja de papel será “si” o “no” dependiendo de tu resultado.

6. Ahora cierra todos los programas que se estén ejecutando en Windows y apaga el

equipo.

7. Vuelve a encender tu computadora e inicia en Ubuntu, registra el tiempo que tarda

en cargar todos los programas, hasta el momento en que se muestra el escritorio

por primera vez.

8. Inmediatamente después de que se muestra el escritorio por primera vez da clic

sobre el botón “Lugares” luego da clic sobre “Equipo”, Observa si la respuesta es

inmediata, tu anotación en la hoja de papel será “si” o “no” dependiendo de tu

resultado.

Nota: Es importante que sea inmediatamente después de que se muestra por primera vez

el escritorio al encender la computadora.

9. Ahora registra si el proceso de abrir un programa, es rápido o lento, ve al menú

aplicaciones y abre la pestaña “Oficina”, da clic sobre OpenOffice.org Writer,

procesador de textos, y observa la rapidez con que se abre el programa, registra

tu observación, tu respuesta será “si” o “no”.

10. En el programa OpenOffice.org Writer (procesador de textos) elabora la tabla que

copiaste en la hoja de papel con los resultados que obtuviste, guárdala con

extensión .doc y .XML, (esta aplicación puede guardar los archivos en estas dos

extensiones) el archivo que subirás a la plataforma para tu evaluación será el

archivo con extensión .XML

Al terminar de responder el cuestionario guárdalo en tu PC y envíalo a tu profesor con tus

datos en el siguiente formato: apellidopaterno_materno_nombre_actividadnumero


Conclusión

Hemos terminado el primer tema de la Unidad por lo que haremos una pequeña síntesis

de lo visto.

Un Sistema Operativo es un programa software encargado de administrar y gestionar

todos los recursos que integran a una computadora, tanto de software como de hardware,

para que estos trabajen en conjunto eficientemente, además de proveer de un ambiente

sobre el cual, otros programas pueden instalarse y ejecutarse sin ningún problema;

también se encarga de brindar al usuario una interfaz o medio de comunicación entre el

propio Sistema Operativo y el usuario.

Tanto Windows como Linux poseen ventajas y desventajas, aunque desde un punto de

vista más técnico Linux es mejor. Linux es más rápido y estable, además de ser gratuito,

aunque en comparación con Windows no tiene la misma cantidad de software ni tampoco

el mismo número de usuarios a nivel mundial.

Avancemos al Tema 2


2. Definición de características de los Lenguajes de programación. Visual Basic,

Java y Lenguaje “C”.

Introducción.

En este apartado conocerás lo que son los Lenguajes de Programación, los cuales se

pueden definir como un idioma creado por el hombre, para que éste pueda dar órdenes a

una computadora, sin necesidad de “hablar” el mismo idioma o lenguaje que la máquina

(ceros y unos, Lenguaje Máquina).

¿Qué es un Lenguaje de Programación?

Un lenguaje de programación es un conjunto de símbolos,

reglas sintácticas y semánticas, mismas que definen

concretamente la estructura, la escritura y relación entre los

comandos, de instrucciones, diseñado para expresar

operaciones, mismas que pueden ser ejecutadas por

computadoras.

También puede usarse para crear programas que controlen el comportamiento físico y

lógico de cualquier máquina electrónica, para expresar algoritmos, o para el desarrollo de

un SO.

Para saber más:

Al proceso por el cual se escribe, se depura y se compila el

código fuente (instrucciones escritas) de un programa se le llama

programación.

Cabe aclarar que la palabra programación también se define

como el proceso de creación de un programa de computadora,

mediante la aplicación de procedimientos lógicos.


¿Qué Lenguaje de Programación es el más utilizado?

Actualmente existen varios lenguajes de programación con los que se pueden trabajar,

pero los más utilizados son: Visual Basic, Java y desde luego el Lenguaje C, a

continuación se te describen brevemente cada uno de ellos.

Visual Basic

Visual Basic es un lenguaje de programación desarrollado por el

alemán Alan Cooper para Microsoft. Su primera versión fue

presentada en 1991, con la ventaja principal de simplificar la

programación utilizando un ambiente de desarrollo completamente

gráfico.

Visual Basic constituye un IDE (entorno de

desarrollo integrado, o en inglés, Integrated

Development Enviroment) que ha sido

empaquetado como un programa de aplicación, es

decir, consiste en un editor de código que es un

programa donde se escribe el código fuente, un

depurador que es un programa que encuentra

errores en el código fuente para que pueda ser

compilado correctamente, un compilador que es

un programa que traduce el código fuente a

lenguaje máquina.

Este Lenguaje se emplea comúnmente en el desarrollo de aplicaciones de Internet y de

propósito general como un diccionario, una base de datos para una biblioteca, un editor

de texto, entre otras.

JAVA

Java es un lenguaje de programación orientado a

objetos, desarrollado por la empresa Sun Microsystems

a principios de los años 90.


Este lenguaje toma mucha de la sintaxis propia de los lenguajes C y de C++, pero tiene

un modelo de objetos más simple pero te restringe la manipulación de punteros, que es

característico de los lenguajes de bajo nivel.

Nota importante:

No confundas C++ con C, C++ es un lenguaje, solo que es una mejora de

lenguaje C y el modelo de programacion es orientado a objetos.

Lenguaje de programación C

C es un lenguaje de programación creado en el año de 1972 por Dennis M. Ritchie en los

Laboratorios Bell como evolución del anterior lenguaje B.

Al igual que el lenguaje B, el Lenguaje C es un lenguaje orientado a la implementación de

Sistemas Operativos y C está caracterizado por la eficiencia del código que produce.

El lenguaje C es un lenguaje clasificado como un lenguaje de medio nivel pero con

muchas características de bajo nivel. Dispone de las estructuras típicas de los lenguajes

de alto nivel pero, a su vez, dispone de construcciones del lenguaje que permiten un

control de medio nivel. En otras palabras es un Lenguaje muy completo.

Pero exactamente cuando hablamos de lenguaje de medio nivel, bajo y de alto nivel nos

referimos a lo siguiente.

Lenguaje de bajo nivel

Un lenguaje de programación de bajo nivel es el que proporciona un set de instrucciones

aritméticas sin la capacidad de encapsular dichas instrucciones en funciones que no estén

ya contempladas en la arquitectura del hardware.

Lenguaje de medio nivel

Suelen ser clasificados de alto nivel, pero permiten ciertos manejos de bajo nivel. Son

precisos para ciertas aplicaciones como la creación de sistemas operativos, ya que

permiten un manejo abstracto (independiente de la máquina, a diferencia del lenguaje

ensamblador), pero sin perder mucho del poder y eficiencia que tienen los lenguajes de

bajo nivel.


Lenguaje de alto nivel

Un lenguaje de programación de alto nivel se caracteriza por expresar los algoritmos de

una manera adecuada a la capacidad cognitiva humana, a diferencia de lo que es

comprender el lenguaje máquina para una persona.

Te invito a que redobles esfuerzos en tu afán por aprender a programar en Lenguaje C, ya

que si dominas este “arte” podrás desarrollar cualquier cosa que imagines.

Es momento de aplicar lo aprendido, resuelve la siguiente actividad de aprendizaje.

Actividad de aprendizaje 3. “Lenguajes de programación”.

Ahora que ya sabes lo que es un lenguaje de programación, así como cuáles son los más utilizados, se te invita a realizar la siguiente actividad, la cual tiene por objetivo que conozcas e identifiques los elementos básicos de los lenguajes de programación. Instrucciones:

A continuación se te presenta un cuestionario con 10 preguntas, cada una presenta tres respuestas pero solo una es correcta, elige la que consideras adecuada para cada pregunta.

Lee cada pregunta con atención antes de seleccionar tu respuesta ya que solo tendrás una oportunidad para responder.

Al terminar da clic sobre el botón enviar

Cuestionario:

1.- ¿Qué es un lenguaje de programación?

a) Es un conjunto de símbolos, reglas sintácticas y semánticas que pueden ser ejecutadas por computadoras.

b) Es el software encargado de ejercer el control y coordinar el uso del hardware en

una computadora.

c) Es un IDE ((entorno de desarrollo integrado).

2.- ¿Para qué sirve un Lenguaje de Programación?

a) Para interpretar los comandos que permiten al usuario comunicarse con la

computadora.

b) Para gestionar los errores del hardware y la pérdida de datos.

c) Para crear programas que controlen el comportamiento físico y lógico de cualquier

máquina electrónica, para expresar algoritmos o para el desarrollo de un SO


3.- Al proceso por el cual se escribe, se depura y se compila el código fuente de un

programa ¿se le llama?:

a) Configuración.

b) Programación.

c) Compilación.

4.- ¿Es un lenguaje de programación desarrollado por el alemán Alan Cooper para

Microsoft?

a) Java

b) Linux

c) Visual Basic

5.- ¿Cuál es la principal ventaja de Visual Basic?

a) Rapidez.

b) Simplificar la programación utilizando un ambiente de desarrollo completamente

gráfico.

c) Flexibilidad.

6.- ¿Qué es Java?.

a) Es un lenguaje de programación orientado a objetos.

b) Es un compilador.

c) Es un constructor de interfaz gráfica.

7.- ¿Qué Lenguaje de Programación no permite la manipulación directa de las direcciones

de memoria por medio de punteros?

a) Linux

b) Unix

c) Java

8.- ¿De qué otros Lenguajes toma gran parte de su sintaxis el lenguaje Java?

a) Visual Basic.

b) Microsoft Windows.

c) C y C++.


9.- ¿Es un lenguaje de programación creado en el año de 1972 por Dennis M. Ritchie en

los Laboratorios Bell como evolución del anterior lenguaje B?

a) Lenguaje C.

b) Lenguaje Ensamblador.

c) Lenjuage C++.

10.- ¿El lenguaje de programación C se caracteriza por?:

a) Ser un lenguaje de de alto nivel.

b) Su eficiencia del código que produce.

c) Su capacidad para crear aplicaciones gráficas.

Conclusión.

Como pudiste observar un lenguaje de programación es un conjunto de símbolos, reglas e

instrucciones que es diseñado por el hombre para dar instrucciones a una computadora.

Actualmente existen muchos lenguajes de programación pero los más utilizados son:

Visual Basic, Java y desde luego el Lenguaje C, siendo este ultimo uno de los más

robustos.

¡Muy bien, terminaste el segundo tema! ¡Sigue adelante!


3. Compilador (Dev C++)

Introducción.

El código maquina es muy difícil de entender para una persona, es necesario

implementar una herramienta que se encargue de traducir un Lenguaje de programación

a código máquina, que es el lenguaje que entiende una computadora.

A este trabajo de traducción se le llama compilar un programa, trabajo que realiza un

programa llamado compilador.

¿Qué es un Compilador?

Un compilador es un programa que traduce un lenguaje de programación a lenguaje

máquina.

Es un programa informático que traduce un programa escrito en un lenguaje de

programación a otro lenguaje que generalmente es el lenguaje máquina (ceros y unos),

pero también puede ser simplemente texto. Generando un programa equivalente que la

máquina será capaz de interpretar.

Este proceso de traducción se conoce como compilación.

Existen diferentes compiladores como Turbo C, Turbo Pascal, Borland y GCC, pero en

esta unidad de aprendizaje utilizaremos el compilador que está integrado en el IDE Dev

C++

En el proceso de la programación no se necesita solamente un compilador, sino que

también, es necesario, un programa que nos permita editar el código fuente, un programa

que se encargue de depurarlo y un compilador que se encargue de traducir el código

fuente en código máquina, a este tipo de programas que cuentan con estas tres

herramientas se les conoce como IDE.

¿Qué es un IDE?

Un IDE (Entorno de Desarrollo Integrado, por sus siglas en inglés: Integrated

Development Environment) es un programa compuesto por un conjunto de herramientas

de programación.

IDE Dev C++, (Bloodshed Dev C++ que es su nombre completo), es un entorno de

desarrollo integrado para programar en lenguaje C y C++. Cuenta con un editor de código

que es un programa donde se escribe el código fuente, un depurador (programa que

corrige errores en el código fuente para que pueda ser compilado correctamente) y un

compilador (programa que traduce el código fuente a lenguaje máquina).


Te preguntarás: ¿Dónde lo consigo?, ¿Cómo lo instalo?

Espera, se paciente, estas dos preguntas se responderán en este apartado.

Observa el siguiente video que te mostrará como descargar e instalar el Dev C++.

Nota importante: Es muy importante que descargues este IDE ya que a

lo largo de toda la unidad de aprendizaje se utilizará para realizar los

programas que generarás.

Actividad de aprendizaje 4. “Descarga e instala Dev C++”

Instrucciones:

Después de observar en su totalidad el video tutorial descarga e instala en tu

computadora el IDE Dev C++.

Una vez instalado el programa Dev C++ captura la imagen del escritorio donde se

encuentra el acceso directo a este programa, a continuación se te muestra un ejemplo.

Para obtener esta imagen del escritorio

presiona el siguiente botón Impr Pant/Petsis,

la imagen de toda la pantalla se guardara en

el portapapeles, pégala en un documento en

Word y recórtala de ser

necesario.

Ahora captura la imagen del programa Dev

C++ abierto en tu computadora de la misma forma que la imagen anterior, Aquí hay otro

ejemplo.


Pega estas dos imágenes en un documento en Word, guárdalas y envíalas a tu profesor

con el siguiente formato: apellidopaterno_materno_nombre_actividadnumero.

Conclusión:

En el proceso de elaboración de un programa escrito en Lenguaje C es necesario utilizar

una aplicación que le permita al programador escribir su código fuente, un depurador que

le permitirá encontrar los errores en el mismo y un compilador que traduzca este

programa a un lenguaje máquina dando como resultado un archivo con extensión exe, a

las aplicaciones que cuentan con este tipo de herramientas se les conoce como Entorno

de Desarrollo Integrado (IDE).

¡Excelente! Terminaste la primera unidad.

Fundamentos de Programación Unidad Il. Fundamentos de programación estructurada

19

Unidad Il. Fundamentos de programación estructurada

Mapa de conceptos

Introducción.

A lo largo de este tema conocerás la estructura general de un programa escrito en

Lenguaje C y se te explicará detalladamente el trabajo que realiza cada una de las líneas

de código se te explican los tipos de variables que admite el Lenguaje C así como la

declaración y uso de estas variables y también aprenderás a utilizar los distintos tipos de

datos con que cuenta el Lenguaje C.

Se te invita a redoblar esfuerzos y a poner toda tu atención ya que la información que a

continuación se muestra te será de gran utilidad para la realización de todos los

programas que efectuaras a lo largo de esta unidad de aprendizaje.


1. Estructura general de un programa.

Tu primer programa en lenguaje C: “Hola mundo”

Ahora vas a conocer la estructura de un programa escrito en Lenguaje C, es muy sencillo

ya que muestra en pantalla un mensaje con el texto “Hola mundo” y se te hará la

explicación de cada uno de sus elementos que te permitirá aprender la estructura general

de cualquier programa escrito en Lenguaje C.

Ya que hayas conocido las partes de este programa vas a realizarlo y a probarlo, para lo

cual vas a utilizar el IDE Bloodshed Dev-C++ que instalaste anteriormente.

A continuación se te muestra una imagen del resultado de editar, depurar y compilar el

programa “Hola mundo”

Código fuente del programa “Hola Mundo”

Se le llama código fuente a las instrucciones escritas por un programador en un lenguaje

de programación, estas instrucciones no pueden ser ejecutadas por la computadora, ya

que la computadora solo entiende el Lenguaje maquina (ceros y unos), por lo que es

necesario traducir el código fuente escrito por el programador a código maquina y para

hacer la traducción para que lo ejecute la computadora se necesita un compilador.

Este es el código fuente del programa “Hola mundo”:


A continuación se explica cada una de las líneas de código que lo componen, pon mucha

atención.

#include<stdio.h>

Cuando el compilador se encuentra con esta directiva la sustituye por el contenido del

archivo indicado (En este caso es el archivo stdio.h). En otras palabras esta directiva del

preprocesador abre el archivo stdio.h selecciona todo el contenido de este archivo, lo

copia en el portapapeles y lo pega en lugar la directiva #include<>.

La sintaxis de esta directiva es #include<>, dentro de los operadores< > se escribe el

nombre de una libreria, (en el caso del ejemplo se utilizó studio.h) generalmente es esta

directiva la que se debe incluir porque en ella se encuentran declaradas las funciones

más básicas, por ejemplo: las funciones aritméticas que te permitirán sumar, restar,

multiplicar o dividir números y las funciones necesarias para mostrar datos por la pantalla

o solicitar información por el teclado.

stdio.h Se escribe en medio de los operadores < >, para indicar a la directiva del

preprocesador #include que este es el nombre de la librería que se debe incluir, ya que

se buscan por nombre.

Te preguntarás que es una librería, pues es un conjunto de recursos

(algoritmos) prefabricados que pueden ser utilizados por el

programador para realizar determinadas operaciones.

Por ejemplo: Si creas un programa en el cual necesitas obtener el

coseno de un ángulo (cos α), debes incluir la librería math.h, que es

la librería dentro de la cual está declarada y definida la función cos(

).

intmain( )

Todos los programas escritos en Lenguaje C deben tener una función llamada main( )

para poder ser catalogados como un programa, si el código fuente no tiene declarada y

definida esta función se puede considerar como una librería o simplemente código.

La función principal main( ) es la primera en ejecutarse. El int que tiene al principio indica

que, cuando la función main( ) finalice, esta devolverá un número, mismo que será entero.


Si el valor devuelto es cero indica que el programa termino sin errores, en caso de

devolver un valor distinto de cero, esto indicará que ha ocurrido algún error durante la

ejecución del programa.

Nota importante: La explicación de cómo una función devuelve un tipo

de dato se verá más adelante.

Un ejemplo de que ha ocurrido un error sería este: todas las personas que han utilizado

Windows han observado alguna vez cuadros de dialogo o pantallas de error, estos

cuadros muestran un mensaje al usuario en el que se hace referencia a un número y a un

evento de error asignado al mismo, como muestra la imagen:

El número que se observa está

escrito en notación hexadecimal

Nota: el tema referente a declaración y definición de funciones se te explicara

a detalle posteriormente.

{ Llave de apertura

La llave de apertura delimita las líneas de código que pertenecen a una

función.

En el caso del ejemplo anterior, se comienza a escribir el trabajo que realizará esta

función a partir de la llave.

/* Aquí va el cuerpo del programa */

Esto es un comentario y no se ejecuta, sirve para describir el programa. Se te recomienda

comentar el código fuente, esto te ayudara a recordar más tarde el funcionamiento del

programa, o si alguna otra persona lee tu código fuente lo va a poder entender fácilmente

auxiliándose de estas notas.


Cuando el compilador detecta el operador /* (diagonal asterisco) ignora todo lo que este

después de este, hasta encontrar */ (asterisco diagonal) que le indica al compilador el final

del comentario.

Un comentario puede ocupar más de una línea de código y ser válido. Un ejemplo se te

presenta a continuación:

/* Este es un comentario

que ocupa dos filas */

Recuerda que es necesario colocar el operador /* (diagonal asterisco) para indicar al

compilador donde comienza el comentario y el operador */ (asterisco diagonal) para

indicar dónde termina.

Para saber más:

Los comentarios se pueden poner casi en cualquier parte.

Excepto en medio de una instrucción. Por ejemplo lo siguiente no

es válido:

pri/* Esto es un comentario */ntf( "Hola mundo" );

printf( /* Esto es un comentario */ "Hola mundo" );

Si escribimos estas líneas el depurador del IDE nos mostrara en pantalla un mensaje de

error. Otro ejemplo erróneo de la utilización de mensajes es el siguiente:

printf( "Hola/* Esto es un comentario */ mundo" );

La línea de código anterior no daría ningún error, pero al ejecutar tendríamos en pantalla:

Porque /* Esto es un comentario */ queda dentro de las comillas y C lo interpreta como

texto, no como un comentario.

printf( "Hola mundo\n" );

Esta línea de código realiza una acción que podemos ver al ejecutar el programa, en este

caso el mensaje “Hola mundo”.

Todo lo que se escribe dentro de los paréntesis y entre comillas dobles (“ ”) se interpreta

como una cadena de texto.


Como puedes observar al final del mensaje aparece escrita la sentencia de escape \n esta

hace que después de imprimir en pantalla el mensaje se realice un salto de línea, es

decir, como un enter.

Notas importantes:

El operador\n no se muestra en pantalla, esta sentencia

de escape solamente ejecuta un salto de línea.

Una cadena de texto es una secuencia de caracteres,

que pueden ser visualizados (aunque no

necesariamente) en la pantalla de la computadora, este es su uso más

común, crear mensajes de texto.

El operador ; (punto y coma) del final de la línea de código, se utiliza en el

Lenguaje C para separar una instrucción de otra. Se pueden poner varias

instrucciones en la misma línea siempre que se separen por un punto y

coma.

system ("PAUSE");

Esta función ocasiona que el programa haga una pausa en su ejecución y es la

responsable de que en pantalla se muestre la cadena de texto: “Presione una tecla para

continuar…” sin esta función el programa no realizaría una pausa, y debido a que el

programa se ejecuta a gran velocidad no podríamos observar la ejecución del mismo.

return 0;

Como se ha indicado anteriormente al finalizar la ejecución de la función main( ), esta

devuelve un valor entero, con la instrucción return 0, lo cual indica que no se produjo

ningún error.

} Llave de cierre

La llave de cierre delimita las líneas de código que pertenecen a la función, en este caso a

la función main(), en otras palabras las líneas que se escriban dentro de las llaves de

apertura y de cierre pertenecen a la función main().


Realizando el programa

Ya que se te explicaron los componentes del programa “Hola mundo”, se te presenta un

video en el que se muestra la forma de utilizar el Dev C++, así como editar, deparar y

compilar el mismo. Pon mucha atención ya que en la actividad de aprendizaje siguiente

vas a realizar el programa.

Como abras observado el código fuente de un programa escrito en Lenguaje C está

compuesto por palabras o instrucciones escritas en el idioma inglés, a estas instrucciones

se les conoce como palabras reservadas, ya que estás tienen una función preestablecida

y específica para el compilador. Estas palabras se escriben tal y como se muestran en las

explicaciones que se te dan.

El código fuente además de estar compuesto por palabras reservadas está integrado por

símbolos como “( )” “ ; “ “{ }” si no sabes cómo escribir alguno de estos símbolos

puedes consultar la tabla del código ASCII.

Para saber más:

Un ejemplo de cómo apoyarte en esta tabla es el siguiente, si

tienes que escribir una llave de apertura, ubica en la tabla del

código ASCII el símbolo y observa el número que tiene asignado

en la columna “Dec”. Para escribir el símbolo mantén presionada

la tecla “Alt” y presiona en seguida el número 123 que aparece en

la columna “Dec”, después suelta la tecla Alt y se escribirá el

símbolo {

Ya que se te ha explicado el código fuente del programa “Hola Mundo” ahora se te pide

que realices la siguiente actividad, la cual tiene por objetivo que practiques la sintaxis del

programa, además de lo aprendido.

Actividad de aprendizaje 5. Mi primer programa

Ahora que conoces la estructura general de un programa creado en Lenguaje C, realiza la

siguiente actividad, la cual tiene por objetivo que reconozcas la estructura de un programa

y lo construyas, además de que pondrás en práctica el conocimiento que acabas de

adquirir.


Instrucciones:

1. Edita el código fuente del programa “hola mundo” que acabas de revisar, depúralo y

compílalo en el compilador Dev C++

2. Debes enviar tu archivo hasta que haya sido compilado, es decir que Dev C++ no te

haya marcado error, de lo contrario no se tomará esta actividad como válida. El archivo

que debes subir a la plataforma es el código fuente, es decir el archivo con extensión .c

que se realizó.

Cuando tengas listo tu archivo guárdalo en tu PC y envíalo a tu profesor con tus datos en

el siguiente formato: apellidopaterno_materno_nombre_actividadnumero

Actividad de autoevaluación 1. Buscando errores.

Ya se te han dado las bases para conocer la estructura general de un código fuente y

acabas de realizar tu primer programa, ahora realiza lo que se te pide.

Instrucciones:

1. Analiza el siguiente programa y detecta los errores que tiene.

2. Ya que hayas detectado las inconsistencias del programa, da clic en el botón

“Solución” para que compares el análisis que realizaste con el resultado que se te

muestra.

3. Esta actividad no tiene valor en tu calificación pero es importante que la realices

para reafirmar tus conocimientos.


Solución:

Si se escribe y compila este código fuente se obtendrá un error, el cual indica que la

función printf esta indeclarada. Esto es porque no se incluyó la directiva

#include<stdio.h>.

En la imagen siguiente se muestra el mensaje de error que arroja el depurador del Dev

C++.

El cual indica claramente que el error está en la función intmain(), exactamente en la

línea número 4, y además muestra un mensaje indicando la posible causa del error.

Como podrás darte cuenta gracias a este depurador es cómo se puede corregir el código

fuente que se escribió.

Actividad de aprendizaje 6. Mi nombre en pantalla

Para continuar demostrando tu aprendizaje, realiza la siguiente actividad, en la cual

reconocerás y construirás un programa escrito en Lenguaje C, a través de la

programación estructurada.

Instrucciones:

1. Realiza un código fuente en el que se muestre tu nombre completo en pantalla.

2. Cuando tengas listo tu programa, edítalo, depúralo y compílalo en el compilador Dev

C++

3. El archivo que debes subir a la plataforma es el código fuente, es decir el archivo con

extensión .c que se creó.

4. Recuerda que si tienes alguna duda puedes pedir la ayuda de tu asesor.


el siguiente formato: apellidopaterno_materno_nombre_actividadnumero.


1.1 Tipos de variables

Al utilizar un programa es muy importante manipular datos. En el Lenguaje C se

almacenan los datos en variables, en este apartado conocerás qué son y cuáles son las

más importantes.

Variables

Una variable es el lugar físico en donde se guarda información, esta puede ser de

distintos tipos por ejemplo: cadenas de caracteres (Avilés), caracteres (V), números (777),

números con una parte decimal (5.124). El contenido de una variable se puede leer o

cambiar en cualquier momento.

Este lugar físico se encuentra en la memoria RAM de la

computadora, físicamente éste es el aspecto de una

memoria RAM:

El espacio de almacenamiento de una memoria RAM está estructurado de la siguiente

manera.

Nota: La información dentro de una memoria RAM se guarda en sistema

binario (ceros y unos), cada dirección es de un tamaño de 8 bits, lo que es

igual a 1 byte.

0 0 1 1 0 0 1 1 Dirección

0 0 0 0 0 0 0 0 0x 0000

1 1 1 1 1 1 1 1 0x 0000

1 1 1 0 0 1 0 1 0x 0000


Los nombres de las variables

Para dar nombre a las variables se deben seguir las siguientes reglas:

Se pueden utilizar casi todas las letras del alfabeto, excepto la “ñ”.

Se pueden utilizar los números del 0 al 9.

No se pueden utilizar caracteres especiales (puntos, comas, signos de admiración

o de interrogación, etc.,) el único carácter que es aceptado es el guion bajo ( _ ).

El nombre de una variable se puede formar con números y letras pero no se puede

iniciar con un número.

No se pueden utilizar como nombres de variables las palabras reservadas que usa

el compilador, por ejemplo: for, main, do, while, etc.

El Lenguaje C distingue entre mayúsculas y minúsculas. Por lo tanto: nombre,

Nombre y NOMBRE, son tres variables distintas.

Los nombres de las variables deben ser cadenas de caracteres, es decir, un

carácter después de otro sin espacios entre ellos.

a) Variables de tipo int

En una variable de este tipo se almacenan números enteros (sin decimales).

El rango de valores que admite es -2,147,483,648 a 2,147,483,647. Aunque el rango de

valores de esta variable es amplio, solo se puede almacenar un número a la vez. Para

guardar este tipo de variable en la memoria RAM se necesitan 16 bits, es decir 2 bytes.

Declaración de una variable

Es importante que sepas que para poder usar una variable primero hay que declararla, es

decir, indicarle al compilador que queremos crear una variable para que nos reserve un

espacio de la memoria para almacenar los datos de la misma, también hay que indicarle

el tipo de variable.

Por ejemplo:

int numero; (donde la palabra número es el nombre de la variable)

numero = 4;

La primer línea de código indica la declaración de una variable llamada número que va a

contener un número de tipo entero, en la segunda línea se indica que la variable llamada

número guardará un numero 4.


La siguiente imagen muestra su representación en Lenguaje maquina dentro de la

memoria RAM.

Así es como se representa el número 4 a 16 bits en Lenguaje maquina (sistema binario).

También se puede declarar y definir el valor que guardará esta variable en una sola línea.

int numero = 4;

Nota: Si no se asigna el valor que guardara la variable, el compilador de manera automática guardara un dato aleatorio del mismo tipo del cual la variable ha sido declarada. Por ejemplo si no se define un valor para la variable número esta podría guardar un numero 5 o cualquier otro número de tipo int.

Cómo se pueden declarar las variables

Hay dos posibilidades, una es declararla como global y otra como local.

La variable global es aquella variable que se declara fuera de cualquier función, por

ejemplo la función main() y la variable local se declara dentro de cualquier función.

A continuación se muestra el ejemplo de las dos formas de declarar las variables:

Variable Global Variable Local

#include <stdio.h> int x=0; intmain() { }

#include <stdio.h> int main() { int x=0; }

La diferencia entre ambas declaraciones es que la variable global se puede usar en

cualquier función del programa y la variable local sólo puede usarse en la función en la

cual ha sido declarada.

0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 numero


En seguida se muestra un ejemplo de estas dos variables en un programa:

Nota: en el siguiente código fuente se encuentra una función llamada

“otrafuncion” la cual se está utilizando como apoyo en el ejemplo de las

variables que se están explicando, no trates de comprenderla

Este sería el resultado de editar, depurar y compilar este programa:


Explicación:

Como puedes observar el programa está compuesto por dos funciones, la función llamada

otrafuncion() y la función principal main()

Observa que desde dentro de la función main es posible mostrar por pantalla el valor de la

variable intA=20;, esta variable no la declaraste dentro de la función main(), pero como

está declarada como global es que es posible que main() pueda utilizarla.

De igual manera la variable int a=2; es accesible desde main(), ya que es una variable

local para la función main(), es decir la función main() conoce a la variable a, ya que esta

fue declarada dentro de { } que delimitan a esta función.

Por otro lado, si desde main() quisiéramos mostrar por pantalla a la variable intb= -82,

esto no sería posible ya que aunque int b= -82 es una variable local para la función

llamada otrafuncion(), y no es una variable local para main() esto quiere decir que main()

no conoce a int b= -82 porque no es local de main().

Enseguida se muestra el mensaje de error que mostraría el Dev C++ si en lugar de la

línea de código:

printf("Y el valor de a es %i \n", a);

Escribiéramos:

printf("Y el valor de b es %i \n", b);

El depurador indica que int b= -82 no ha sido declarada dentro de main(). Por lo tanto

main() no conoce a esta variable


Mostrar variables por pantalla:

Imagina que quieres mostrar el contenido de la variable x de tipo int por pantalla, para lo

cual tienes que indicar lo siguiente: Función printf( )

Un ejemplo del uso de esta función es el siguiente:

printf( "%i", x );

Si por ejemplo x vale 1 (x=1) en la pantalla tendríamos: 1

El operador "%i" (tanto por ciento letra i ) es un modificador de formato, no se muestra en

pantalla, se sustituye por el valor de la variable que va después de las comillas dobles y

el operador coma ( , ) y sirve para indicarle a la función printf() que el número que se

mostrará por pantalla es de tipo entero.

Para ver el contenido de dos variables, por ejemplo x e y, podemos realizar lo siguiente:

printf( "%i ", x );

printf( "%i", y );

Si por ejemplo x = 10 e y = 20, entonces el resultado en pantalla será: 1020.

Aunque como sabes, se puede obtener el mismo resultado utilizando una línea de código

en lugar de dos. Con una línea de código se puede mostrar en pantalla el número de

variables que quieras:

printf( "%i %i", x, y );

Como puedes ver por cada variable hay que poner un %i dentro de las comillas dobles.

También se puede combinar texto con el contenido que guardan las variables:

printf( "El valor de x es %i, ¡que bien!\n", x );

Si por ejemplo x = 10 la línea de código anterior mostrara en pantalla el siguiente

resultado:

El valor de x es 10, ¡que bien!

Como ves, el modificador %i al imprimir en pantalla se sustituye por el valor de la variable.

Es tiempo de poner en práctica lo aprendido hasta el momento acerca de variables,

realiza la siguiente actividad para que sigas practicando.


Actividad de aprendizaje 7. “Declarando variables”

Ya sabes que es una variable, como se nombran y como se deben declarar.

Es tiempo de seguir practicando los nuevos conocimientos adquiridos, realiza la siguiente

actividad la cual tiene como finalidad que reconozcas el lugar en dónde debe declararse

una variable de acuerdo a su tipo, (global o local) y construyas la estructura de un

programa escrito en Lenguaje C.

Instrucciones:

1. Edita, depura y compila en el compilador Dev C++, el código fuente que se te

presenta a continuación.

2. El resultado de esta programación tiene que ser igual al mostrado en la siguiente

imagen.

3. Una vez que hayas obtenido el resultado, envía el archivo del código fuente a tu

profesor para que te evalué (recuerda que es el archivo con extensión .c que se creó)

con el siguiente formato: apellidopaterno_materno_nombre_actividadnumero.


b) Variables de tipo char

Las variables de tipo char sirven para almacenar un carácter, estos se almacenan como

números del 0 al 255. Los 128 primeros (0 a 127) corresponden al código ASCII estándar.

Para declarar una variable de tipo char se realiza lo siguiente:

Char letra ;

En una variable char sólo se puede almacenar un carácter, no almacena cadenas de

caracteres (frases ni palabras), esto se te explicará en un apartado posterior.

Ya que está declarada la variable char, para guardar un dato se tienen dos posibilidades,

mismas que se te muestran a continuación:

letra = 'a';

letra = 97;

En ambos casos se está asignando (guardando) la letra 'a' en la variable llamada letra de

tipo char. En el primer renglón es más que obvio, pero en el segundo se tecleo el número

97, esto es porque el código ASCII de la letra a es el número 97.

Observa que para asignar directamente el carácter a se utilizan comillas simples ( '' )

Impresión en pantalla de una variable char

Para imprimir en pantalla una variable de tipo char se utiliza el modificador de formato %c

(c de carácter, carácter en inglés) Enseguida se muestra un ejemplo de esto:

char B = 'A';

printf( "La variable B de tipo char guarda una: %c.", B );

El resultado que se obtendrá en pantalla será el siguiente:

La variable B de tipo char guarda una: A

También se puede imprimir en pantalla el valor en código ASCII, de la variable, usando el

modificador %i en lugar del modificador %c, ejemplo:

char B = 'A';

printf("El número ASCII de la variable %c es: %i.", B, B);


El resultado que obtendrá en pantalla será el siguiente:

El número ASCII de la variable A es: 65

Observa que dentro de la función printf en lugar de utilizar el modificador %c se utilizó el

modificador %i, por lo cual la función printf() interpreta a ala variable B como el número

entero que corresponde a dicho carácter en el código ASCII.

Observa que, aunque la variable de tipo char es llamada B, guarda un carácter A, el

nombre de la variable únicamente sirve para identificarla y no afecta el contenido que

almacena la variable.

Si tienes dudas acerca de los nombres de las variables consulta el apartado “Los nombres

de las variables” visto anteriormente.

Nota: Las variables de tipo char se pueden usar para guardar números

enteros. Si se necesita almacenar un número pequeño (entre -128 y 127)

se puede usar una variable de tipo char que ocupa únicamente 8bits de la

memoria, en lugar de una variable de tipo int que ocupa 16bits de la

memoria, con el consiguiente ahorro de memoria.

Todo lo anteriormente explicado para las variables de tipo int, aplica también para las

variables de tipo char.

Actividad de autoevaluación 2. Explicando resultados

Es momento de que evalúes tu aprendizaje

Realiza la siguiente actividad que tiene como objetivo el reforzar tu aprendizaje adquirido

hasta el momento, aunque no tiene valor en tu calificación, es importante que la realices.

Instrucciones:

1. Revisa y analiza el siguiente código fuente que se te va a presentar. 2. Revisa la imagen del resultado que despliega el código fuente que vas a analizar 3. Explica por qué a partir del código fuente se obtuvo este resultado. 4. Ya que hayas terminado la actividad ve a la “Solución” para que compares el

análisis que realizaste con el resultado que se te muestra.


El resultado de editar, depurar y compilar este programa es el siguiente:

Solución:

Inicialmente se declaró la variable llamada CARACTeR de tipo char, a la cual se le asignó

una carácter A (almacena una letra A), mismo que equivale al código ASCII 65.

Después de mostrar el contenido de la variable CARACTeR por pantalla, se incrementó

en una unidad a la variable CARACTeR, en otras palabras se le sumo 1 a la variable

carácter y el resultado de esta operación aritmética que es 66, se guardó en la misma

variable CARACTeR, por esto al volver a mostrar por pantalla el contenido de la variable

CARACTeR se muestra una letra B que corresponde al código ASCII 66.

c) El modificador unsigned

Este modificador, que significa sin signo, cambia el rango de valores que puede contener una variable y sólo admite valores positivos, es decir, cambia valores de signo negativo a positivo y a partir de esto también se cambia el rango de las variables.


Por ejemplo: El rango de valores que puede aceptar normalmente una variable de tipo char es el siguiente: -128 a 127, pero si se le antepone el modificador unsigned ya no guardará números negativos, con lo cual el nuevo rango de valores que puede almacenar una variable de tipo unsignedchar es: 0 a 256, es importante mencionar que aunque el rango es amplio, solo puede guardar un solo valor de ese rango. Un ejemplo de esto es el siguiente: unsignedcharesime = 256; En esta línea de código la variable llamada esime de tipo unsignedchar guarda el número

256, y ya no se le puede indicar que guarde números negativos.

Nota: Este modificador se puede utilizar para cualquier otro tipo de variables y solo

guarda un número.

d) Variables de tipo float

En este tipo de variables se pueden almacenar números enteros con una parte decimal,

no sólo números enteros como en las variables de tipo int y las de tipo char.

El rango de valores que podemos almacenar en este tipo de variable es del 3,4E-38 al

3,4E37. Al igual que las otras variables almacenan solo un valor.

Para realizar la declaración de una variable de tipo float, se hace lo siguiente:

float numero = 0.0;

Para imprimir en pantalla el contenido de una variable de tipo float se usa el modificador

%f. Ejemplo:

floatnum = 4060.80;

printf( "El valor de num es : %f", num);

El resultado que se observará en pantalla será el siguiente:

El valor de num es: 4060.80


Si se quiere imprimir este valor en pantalla en notación exponencial se usa el modificador

%e, en lugar de %f por ejemplo:

floatnum = 4060.80;

printf( "El valor de num es: %e", num );

El resultado que se observará en pantalla será el siguiente:

El valor de num es: 4.06080e003

e) Variables de tipo double

En las variables de tipo double pueden almacenarse números reales (números enteros

con una parte decimal) en un rango de 1,7E-307 al 1,7E306. Como puedes observar el

rango de valores que puede almacenar una variable de este tipo es mayor al de las

variables de tipo float.

Para declarar una variable de este tipo se hace lo siguiente:

doublenum = 4.85454405655;

Para imprimir en pantalla estas variables se utiliza el modificador %f al igual que en las

variables de tipo float. Ejemplo:

printf( "El valor de num es: %f", num );

El resultado que se observará en pantalla es:

El valor de num es: 4.85454405655

Si se quiere imprimir este valor en pantalla en notación exponencial se usa el modificador

%e, en lugar de %f.

Para saber más:

Si quieres conocer el máximo rango de valores que puede almacenar una variable, debes hacer lo siguiente:

Primero tienes que conocer el tamaño de bytes de la variable, para esto vas a ocupar la función sizeof().

Esta función devuelve el tamaño en bytes de su argumento (el argumento es el nombre de la variable, constante o tipo de datos que se coloca entre paréntesis).


Enseguida se te muestra un ejemplo de cómo utilizar esta función a través del siguiente código fuente:

El resultado de editar, depurar y compilar este programa será el siguiente:

Explicación:

Observa que como argumento de la función sizeof() se colocó el tipo de datos int, con lo

cual la función sizeof() devuelve el tamaño en bytes de este tipo de dato.

De lo explicado anteriormente sabes que el tipo int ocupa 4 bytes. Como sabemos 1byte =

8 bits. Por lo tanto el tipo int ocupa (4x8)=32 bits.

No solamente se puede obtener el tamaño en bytes de las variables de tipo int, sino

también de cualquiera de los tipos de variables vistos, para esto únicamente tendrías que

cambiar el argumento, por ejemplo en lugar de colocar el argumento int se puede colocar

los argumentos char, float y double.

Ahora para calcular el máximo número que puede almacenar una variable de tipo int se

debe elevar la constante 2 (que es el número que hace referencia al sistema binario) al

número de bits obtenidos.

En nuestro ejemplo: (232)=4 294967296. Es decir en una variable de tipo int se podría

almacenar un número entre 0 y 4.294.967.296 si solo almacenáramos números positivos.

Sin embargo lo anterior sólo aplica si se usa el modificador unsigned, aunque

regularmente se almacenan números positivos y negativos.


Así que de los 4294967296 posibles números la mitad serán positivos y la mitad

negativos.

Por lo tanto se tiene que dividir el número anterior entre dos, 4294967296 / 2 =

2147483648. Como el 0 se considera positivo el rango de números posibles que se

pueden almacenar en una variable de tipo int sería: -2147483648 a 2147483647.

Actividad de autoevaluación 3. Buscando más errores.

Es momento de poner a prueba tu capacidad de análisis, realiza la siguiente actividad.

La actividad no tiene valor en tu calificación pero es importante que la realices,

recuerda que la práctica hace al maestro.

Instrucciones:

1. Revisa el siguiente programa y detecta los errores que tiene, esto te va a servir como

práctica y para reafirmar tus conocimientos.

2. Cuando hayas terminado tu análisis y hayas encontrado los errores del código fuente,

ve a la “solución” para que compares tus resultados y veas los aciertos que tuviste.

Solución:

Falta la coma después de "El valor es %i".

Además la segunda vez número está escrito con mayúsculas, esta sería un variable

diferente, la cual no ha sido declarada.

En la función printf() hay otro error, se intenta imprimir en pantalla a la variable Numero,

nota la N al principio del nombre, esta variable no ha sido declara, se declara a la variable

llamada número con minúsculas

Y por último, los nombres de variables no pueden llevar acentos.


1.2 Constantes (uso de #define)

Las constantes son aquellos datos que no pueden cambiar su valor a lo largo de la

ejecución de un programa.

Estas constantes se definen de la siguiente manera:

#define nombre_de_la_constante

valor_de_la_constante

Como puedes observar no es necesario utilizar el operador de asignación (=) para dar un

valor a la constante, únicamente se deja un espacio en blanco entre el nombre de la

constante y el valor que desea asignarse a ella, tampoco es necesario escribir el punto y

coma (;) que llevan al final todas las instrucciones en Lenguaje C.

Por último observa que no se indicó el tipo de datos de la constante (por ejemplo char,

float, etc.) esta puede ser una comodidad al momento de declarar constantes.

La palabra reservada #define indica que los datos que se escriben después en ella no

cambian a lo largo del programa.

Se te muestra un código fuente en el cuál no se utiliza la declaración de constantes

(#define), en el cual si se utilizara varias veces el valor 3.1416, lo que podría ocasionar

que hubiera un error de “dedo” en el cual se escribiera mal algún número por ejemplo:

3.1516.


Explicación:

En este código fuente radio y perímetro son variables, su valor puede cambiar a lo largo

del programa, sin embargo 2 y 3.1416 son constantes, no hay manera de cambiarlas. La

única manera de hacerlo es editando el programa.

Ahora se muestra el mismo ejemplo en el que está declarada la constante PI utilizando la

palabra reservada #define:

Con este código fuente, cada vez que el compilador encuentre el nombre PI lo sustituirá

por el valor 3.1416, lo cual puede ayudar a que no haya errores.

Nota: A una constante no se le puede dar un valor mientras se ejecuta el

programa, es decir, no se puede hacer lo siguiente:

#define PI 3.1416

Pi = 3.20;

Sólo se le puede dar un valor con #define, y una vez.

Actividad de aprendizaje 8 “Practicando las constantes”

Ya sabes lo que son las constantes y como se declaran, ahora vas a practicar la

utilización e implementación de las mismas a través de esta actividad, el objetivo es que

reconozcas y construyas la estructura de un programa.


Instrucciones:

1. Edita, depura y compila el siguiente programa en Dev C++

2. En un archivo en Word explica el funcionamiento del código fuente y guárdalo en tu PC.

3. Ya que hayas terminado tu actividad, envía a tu profesor el archivo del código fuente con extensión .c (siempre y cuando no te haya marcado error el compilador) y el documento en Word en el que explicaste el funcionamiento del mismo, guarda ambos documentos con el siguiente formato: apellidopaterno_materno_nombre_actividadnumero.


1.3 Operadores

Durante el proceso de la programación en Lenguaje C surge la necesidad de manipular

datos, para llevar a cabo esta tarea el Lenguaje proporciona una herramienta sencilla y

eficaz para tal propósito, esta herramienta son los operadores.

Un operador es un símbolo que sirve para manipular datos. Los hay de varios tipos: de

asignación, de relación, lógicos, aritméticos y de manipulación de bits, enseguida se te

explica cada uno.

a) Operador de asignación =

( = ) Es un operador que ya has visto y utilizado en programas pasados, sirve para asignar

un valor a una variable. Este valor puede ser un número u otra variable introducido por el

teclado.

Las formas de utilizar el operador de asignación son las siguientes:

a = 3; /* Se asigna o guarda un 3 en la variable a */

ó

a = b; /* Se asigna el valor de una variable, es decir el valor de b se guarda

en a */

Recuerda que en una misma línea de código se puede dar valores a diferentes variables:

a = b = c = 100; /* Se asigna a las variables a,b,c el valor de 100 */

También se puede asignar el valor de una variable a otras diferentes en la misma línea de código:

a = b = c = d; /* a, b y c toman el valor de d */

Nota: En el Lenguaje C la asignación es asimétrica, un ejemplo de esto es el

siguiente:

A=B;

El valor que está guardado en la variable de la derecha es decir B se copia y se guarda

en la variable de la izquierda en este caso A.


En ningún caso se indica que lo que está guardado en la variable A se copia y se guarda

en la variable B.

Tampoco se indica que la variable A y la variable B son iguales. Para indicar que dos

variables son iguales en el Lenguaje C se utiliza al operador de comparación == que se

verá más adelante.

b) Operadores aritméticos

Los operadores aritméticos son aquellos símbolos que sirven para realizar operaciones

tales como suma, resta, división y multiplicación, a continuación se te explica cada uno de

ellos.

Operador Suma +

Este operador permite sumar entre sí variables y constantes. Un ejemplo de la

implementación de este operador se muestra enseguida:

El resultado de editar, depurar y compilar este código es el siguiente:


Explicación:

En este programa se declaran tres variables a = 2, b = 3 y c = 0.

Se suman las variables a y b y el resultado de esta suma se guarda en la variable c, para

después por medio de la función printf() mostrar el resultado de esta suma en la pantalla.

Observa que el valor guardado previamente en c, en este caso un cero fue borrado y

remplazado por el valor de la suma al momento de realizar la asignación:

c = a+b;

Se pueden sumar muchas variables, o variables y constantes (recuerda que se

consideran constantes porque nunca cambiaran su valor).

Observa el siguiente código fuente en el cual se suman constantes y variables:



Explicación:

En este programa se declararon cuatro variables, a=2, b=3, c=1 y d a esta última no se

asigno ningún valor inicial, (recuerda que cuando no inicias una variable el compilador

asigna un valor aleatoria en forma automática), se sumaron los valores de las variables a,

b y c con el valor de la constante 4, el resultado que en este caso es 10 mismo que se

guardo en la variable llamada d (el valor aleatorio asignado por el compilador inicialmente

fue borrado y en su lugar se guardo un numero 10 al momento de realizar la asignación

d=a+b+c+4; )

También es posible utilizar al operador de suma (+) para incrementar el valor de una

variable, por ejemplo:

int x=0;

x = x + 5; /* se incrementa el valor de x al sumarle 5 y guarda el resultado de la suma en x

*/

Lo que se hace con la línea de código anterior es sumar cinco a la variable llamada x y el

resultado que en este caso es cinco (0+5=5), se guarda en la misma variable llamada x, el

cero que se asigno en la primer línea es sustituido por el nuevo valor que es cinco, ya que

una variable solo puede contener un solo valor.

Este es otro ejemplo:



Explicación:

En este programa escrito en Lenguaje C se declaran dos variables x e y, se asignan los

valores 3 y 5 respectivamente, en la misma línea se incremente el valor que guarda la

variable x en dos, así: x+=2; (esto sería igual que hacer x=x+2;). Para corroborar que esto

es cierto se muestra por pantalla el valor de la variable x.

Después se incrementa nuevamente el valor de la variable x, esta vez se le suma el valor

de la variable llamada y, guardando el resultado de esta operación aritmética en la

variable x. para corroborar que lo explicado es cierto se muestra nuevamente el valor de

la variable x por pantalla.

Operador Incremento:++

La función de este operador es sumar 1 a una variable y guardar el resultado de esta

suma en la misma variable. Ejemplo:



Explicación:

En este programa se declara a la variable llamada x de tipo entero, se le asigna un 5 (x=5)

y se muestra a esta variable por pantalla utilizando la función printf(), esto para mostrar el

contenido de esta variable, que evidentemente es 5.

Enseguida incrementamos a la variable x en una unidad realizando x++; (es lo mismo que

realizar x = x+1;) y enseguida se muestra por pantalla el nuevo valor que guarda la

variable x.

Operador Resta o Negativo -

El operador - permite restar entre sí variables o constantes.

Por ejemplo:

int z =0, x=8;

z = x- 5;


Un ejemplo de la implementación de este operador:


Explicación:

En este programa se realiza la declaración de dos variables de tipo entero llamadas A y

B, a las cuales, se les asigna el valor de las constantes 20 y 5 respectivamente.

Enseguida se realiza la resta de las variables A y B (A-B), guardando el resultado de esta

operación aritmética en la variable llamada A, después de esto se muestra el valor

guardado en la variable A para demostrar lo explicado anteriormente.


Después se realiza la declaración de dos nuevas variables llamadas a y b, a la variable

de tipo entero llamada a se le asigna el valor de la constante 1, enseguida a la variable

del mismo tipo llamada b se le asigna el valor de la variable a pero con signo negativo, es

decir en b se guarda un -1, y se imprime en pantalla el valor de b.

Nota:

Al realizar la línea de código b = -a; el valor de la variable llamada a

asignado previamente, no se ve afectado, es decir a sigue

guardando un 1 positivo.

Aclarando lo anterior, al realizar la línea de código b = -a; se multiplica un -1 por el valor

de la variable a(-1*(a)) y el resultado de esta operación algebraica se guarda en la

variable llamada b.

Después de esto se declaro y definió con 5 otra variable de tipo entero llamada x,

enseguida se mostro por pantalla dicha variable por medio de la función printf(), para

demostrar que es posible en el Lenguaje C decrementar el valor de una variable se realizo

la línea de código x--; con lo que se resto 1 a la variable x guardando el resultado de esta

operación aritmética en la misma variable llamada x.

Para corroborar que se realizó la resta adecuadamente se imprimió en pantalla

nuevamente el valor de x.


Operador Multiplicación y puntero *

El operador * sirve para multiplicar entre si variables o constantes. Por ejemplo:


Explicación:

En este programa se declararon dos variables de tipo float x y y a las cuales se les

asignaron los valores -5.0460 y 2.00987 respectivamente.

Se declaro una tercera variable llamada R del mismo tipo a la cual se le asigno el

resultado de la multiplicación de los valores que guardan las variables x e y en la línea de

código R = x*y; para después por medio de la función printf() mostrar el resultado por

pantalla.

El operador * También sirve para definir y utilizar punteros, pero eso lo verás a detalle

más adelante.


Operador División /

El operador / sirve para dividir entre si variables o constantes. Por ejemplo:


Explicación: En este programa se declararon dos variables de tipo float x y y a las cuales se les asignaron los valores: -5.0460 y 2.00987 respectivamente. Se declaro una tercera variable llamada R del mismo tipo a la cual se le asigno el resultado de la división de los valores que guardan las variables x y y en la línea de código R = x/y; para después por medio de la función printf() mostrar el resultado por pantalla.


Operador Modulo %

El operador % sirve para dividir entre si variables o constantes, pero a diferencia del

operador de división (/) este devuelve el modulo de la división. Por ejemplo:


Explicación:

En este programa se declararon dos variables de tipo entero llamadas a y b a las cuales

se les asigno el valor de las constantes 18 y 5 respectivamente, por medio de la función

printf() se imprime en pantalla el residuo de la división entre a y b.


c) Operadores de comparación

Los operadores de comparación se utilizan para comparar cómo son entre sí variables o

constantes. Cuando se realiza esta comparación se obtiene un resultado, el cual puede

ser 0 si no se cumple la comparación satisfactoriamente o 1 si la comparación se cumple

satisfactoriamente.

Los operadores de comparación son:

Operador Nombre Evaluación

== igual que se cumple si son iguales

!= distinto que se cumple si son diferentes

> mayor que se cumple si el primero es mayor que el segundo

< menor que se cumple si el primero es menor que el segundo

>= mayor o igual que se cumple si el primero es mayor o igual que el segundo

<= menor o igual que se cumple si el primero es menor o igual que el segundo

Por ejemplo:



Explicación:

En este código fuente se compara a las constantes 10 y 5. En la primer línea de la función

main() se compara si 10 es mayor que 5, lo cual devuelve un 1 al cumplirse esta

comparación, enseguida se compara si 10 es menor que 5, dicha comparación devuelve

un 0 al no cumplirse satisfactoriamente, más adelante se compara si 5 es igual que 5, tal

comparación devuelve un 1 y por último se compara si 10 es igual que 5, para tal

comparación devuelve un 0 ya que no se cumple la comparación anterior.

Nota: No sólo se pueden comparar constantes, también se pueden comparar variables.

d) Operadores lógicos

Los operadores lógicos nos permiten unir varias comparaciones, por ejemplo 10>5 y

6==6.

Los operadores lógicos son: AND (&&), OR (||) y NOT(!).

Operador && (AND, en español “Y”): Devuelve un 1 si se cumplen dos

comparaciones.

La tabla de verdad es la siguiente:

Comparación 1 Comparación 2 Resultado que devuelve

AND (&&)

1 1 1

1 0 0

0 1 0

0 0 0


Un ejemplo de lo explicado anteriormente sería el siguiente:

printf( "Resultado: %i", (10==10 && 5>2 );

Lo cual devolvería un 1 ya que ambas condiciones se cumplen, ya que 10 es igual que 10

y 5 es mayor que 2

Operador || (OR, en español O)

El operador || devuelve un 1 si se cumple una de las dos comparaciones.


Comparación 1 Comparación 2 Resultado que devuelve

OR (||)

1 1 1

1 0 1

0 1 1

0 0 0

Un ejemplo de lo explicado anteriormente es el siguiente:

printf( "Resultado: %i", (10==10 || 5<2 );

La línea de código anterior devolvería un 1 ya que se cumple una de las dos condiciones

en este ejemplo se cumple que 10 es igual que 10, de hecho la segunda comparación ya

no se realiza.

Ahora si en este ejemplo se le cambia la primera comparación de la siguiente forma:

printf( "Resultado: %i", (10==0 || 5<2 );

Al realizar este cambio en la línea anterior ésta devolvería un 0, ya que ninguna de las

dos comparaciones se cumple satisfactoriamente 10 no es igual que 0 y tampoco 5 es

menor que dos.

Operador ! (NOT, negación): Este operador lógico realiza el siguiente trabajo, si la

comparación se cumple NOT hace que no se cumpla y viceversa.



Comparación Resultado que

devuelve NOT (!)

1 0

0 1

Un ejemplo de lo explicado sería el siguiente:

printf( "Resultado: %i", ( ! 5>2 );

Esta línea devolvería 0 ya que aunque la comparación se cumple satisfactoriamente el

operador ! invierte esa situación y devuelve lo contrario.

Si cambiamos los operadores de comparación de la siguiente manera:

printf( "Resultado: %i", (! 5<2 );

Este cambio hará que el operador NOT devuelva un 1 ya que aunque la condición se

cumple satisfactoriamente el operador NOT hace que esta no se cumpla.

Operadores a nivel de bits

Ya has visto que un byte está compuesto por ocho bits. Pues bien, con los operadores a

nivel de bits podemos manipular bit a bit los valores que almacenan las variables.

Los diferentes operadores a nivel de bits son:

Operador Descripción

| OR (O)

& AND (Y)

^ XOR (O exclusivo)

~ Complemento a uno o

negación

>> Desplazamiento a la

derecha

<< Desplazamiento a la

izquierda


Operador | (OR a nivel de bits):

Toma los valores y hace con ellos la operación OR a nivel de bits. Ve el siguiente ejemplo:


Explicación:

Esta es la operación a nivel de bits:

235 -> 11101011 143 ->10001111| 239 -> 11101111

La operación OR funciona de la siguiente manera: se toma el bit de menor peso del primer operando y el bit de menor peso del segundo operando, los compara, si alguno de ellos es uno, se obtiene un uno. Si ambos son cero el resultado es cero.

En el ejemplo anterior se compararon los dos primeros bits de derecha a izquierda (el primero de cada uno de los números, 1 y 1 = 1), luego la segunda pareja (1 y 0 = 1) y así sucesivamente hasta terminar con el valor.


Operador & (AND a nivel de bits):

Este operador compara los bits también dos a dos. Si ambos son 1 el resultado es 1. Si no, el resultado es cero. Ve el siguiente ejemplo:


Explicación:


170 -> 10101010 155 ->10011011& 138 -> 10001010

El operador AND funciona de la siguiente manera: Tomamos los bits dos a dos y los

comparamos si ambos son uno, se obtiene un uno.

Si alguno es cero el resultado es cero. Si ambos son cero el resultado es cero. Primero se

compara los dos primeros (el primero de cada uno de los números, 0 y 1 -> 0), luego la

segunda pareja (1 y 1 -> 1) y así sucesivamente.


Operador ^ (XOR a nivel de bits):

El operador ^ Compara los bits y los pone a unos si son distintos. Ve el siguiente ejemplo:


Explicación:


235 -> 11101011 143 ->10001111^ 100 -> 01100100

El operador XOR funciona de la siguiente manera: revisa los bits dos a dos y los compara si ambos son uno, se obtiene un cero. Si ambos son cero se obtiene cero. Si ambos son distintos el resultado es uno.

Primero se compara los dos primeros (el primero de cada uno de los números, 0 y 1 -> 0), luego la segunda pareja (1 y 1 -> 1) y así sucesivamente.

Operador ~ (Complemento a uno):

Este operador acepta un sólo dato (un solo operando) y cambia los ceros por unos y los unos por ceros, es decir los invierte.

Esta operación afecta también al signo del operando (positivo o negativo), mismo que se indica antes del operando.


Ve el siguiente ejemplo:


Explicación:


152 ->10011000~ -153 -> 01100111

El operador complemento a uno, evalúa bit a bit ye invierte el valor del bit evaluado, como

el bit de mayor peso en una variable numérica representa el signo (positivo o negativo)

este bit también es invertido, por tal motivo el signo del nuevo numero obtenido es ahora

negativo.

Operador >> (Desplazamiento a la derecha):

Este operador mueve cada bit a la derecha. El bit de la izquierda se pone a cero, el de la

derecha se pierde. Si realizamos la operación inversa no recuperamos el número original.

El formato es el siguiente:

variable o constante>>número de posiciones a desplazar


El número de posiciones a desplazar indica cuantas veces hay que mover los bits hacia la derecha.

Ve el siguiente ejemplo:

El resultado de editar, depurar y compilar este código fuente es el siguiente:

Explicación:

Esta es la operación a nivel de bits y equivale a hacer dos desplazamientos a la derecha:

152 ->10011000 Número original 76 -> 01001100 Primer desplazamiento. Entra un cero por la izquierda, el cero de la derecha se pierde y los demás se mueven a la derecha. 38 -> 00100110 Segundo desplazamiento. Entra un cero por la izquierda, el cero de la derecha se pierde y los demás se mueven a la derecha.

Nota:

Un desplazamiento a la derecha equivale a dividir entre dos. Esto es un dato muy importante ya que el desplazamiento a la derecha es más rápido que la división. Sólo sirve para dividir entre dos. Si hacemos dos desplazamientos sería dividir entre dos veces, no dividir entre tres.


Operador << (Desplazamiento a la izquierda):

Este operador mueve cada bit a la izquierda. El bit de la derecha se pone a cero, el de la izquierda se pierde. Si realizamos la operación inversa no recuperamos el número original Esta operación equivale a multiplicar por 2.

Vamos a ver un ejemplo:

:


Esta es la operación a nivel de bits y equivale a hacer dos desplazamientos a la izquierda:

50 -> 00110010 Número original 100-> 01100100 Primer desplazamiento. Entra un cero por la derecha, el cero de la izquierda se pierde y los demás se mueven a la izquierda. 200->11001000 Segundo desplazamiento.Entra un cero por la derecha, el cero de la izquierda se pierde y los demás se mueven a la izquierda.

Nota:

Un desplazamiento a la izquierda equivale a multiplicar por dos.


Esto es un dato muy importante ya que el desplazamiento a la izquierda es más rápido que la multiplicación. Sólo sirve para multiplicar por dos. Si hacemos dos desplazamientos sería igual que multiplicar por dos, dos veces, no multiplicar por tres.

Actividad de Aprendizaje 10. Operadores lógicos a nivel de Bits.

Ya conoces todas las operaciones lógicas a nivel de bits que se manejan en Lenguaje C, ahora vas a practicar con ellas en la siguiente actividad, el objetivo es que comprendas el uso y aplicación de los operadores con que cuenta el Lenguaje de programación C.

Instrucciones:

1. Realiza el código fuente escrito en Lenguaje C que te permita realizar las operaciones lógicas a nivel de bits OR, AND y XOR para los siguientes operandos: operando 1 = 100 y operando 2 = 200, también realiza las operaciones de complemento a uno o negación, desplazamiento a la derecha y desplazamiento a la izquierda para los operandos 3 y 125, el >> se hará por 2, es decir, dos desplazamientos a la derecha y el << se hará por uno, es decir un desplazamiento a la izquierda.

2. Todos los resultados de estas operaciones lógicas a nivel de bits se deben mostrar en pantalla.

3. Ya que tengas el código fuente realizado depúralo y compílalo en Dev C++ 4. Debes enviar tu archivo hasta que haya sido compilado, es decir que Dev C++ no te

haya marcado error, de lo contrario no se tomará esta actividad como válida. El archivo que debes enviar es el código fuente, es decir el archivo con extensión .c que se creó.

5. Cuando hayas terminado envía a tu profesor el archivo del código fuente a la plataforma con el siguiente formato: apellidopaterno_materno_nombre_actividadnumero.

Conclusión:

La estructura general de un programa escrito en Lenguaje C es la siguiente:

#include<>

intmain()

{

}

#include<>Es la directiva del preprocesador. Se encarga de incluir el contenido de las librerías en el código fuente del programa, no olvides que en las librerías se encuentran declaradas y definidas las funciones más comunes con que cuenta el Lenguaje C, tales como pritf().


Todo programa escrito en Lenguaje C debe tener una función llamada main(), esta es siempre la primer función en ejecutarse y es por medio de esta que se llaman o invocan a las demás funciones.

Las { } delimitan tanto el comienzo como el final del programa así como las líneas de código que pertenecen a la función main.

Como te abras dado cuenta es imprescindible utilizar variables en un programa en Lenguaje C, así que es necesario que recuerdes que el contenido de las variables se puede ver o cambiar en cualquier momento.

Estas variables pueden ser de distintos “tipos” dependiendo de la clase de información que almacenen.

No es lo mismo guardar un nombre que un número, ya que un nombre puede estar compuesto por letras y números, por ejemplo Rodrigo, Lucy254, etc., y un número es una constante por ejemplo 0,-1,2,10.25, etc.

Hay que recordar también que la memoria RAM de la computadora es limitada, así que cuando guardamos un dato, debemos usar sólo la memoria necesaria, ya que es en la memoria RAM donde se cargaran y ejecutaran nuestros programas.

Recuerda también que los operadores son símbolos que le indicaran al compilador como manipular la información, por ejemplo cuando escribimos a+2, en este caso el operador es el símbolo de + (más) el cual tiene vinculada una función que le dice al compilador exactamente lo que tiene que hacer con los operandos a y 2 (sumarlos), existen operadores para manipular casi todo tipo de información.

¡Excelente, terminaste el primer tema! ¡Sigue adelante con tu trabajo!


2. Funciones de entrada

Introducción

Como recordarás en las librerías (por ejemplo conio.h) se encuentran declaradas y definidas funciones, estas funciones desarrollan un trabajo específico y resuelven la mayoría de necesidades que se suscitan durante el proceso de la programación, por ejemplo estas funciones nos permiten introducir datos por el teclado, mostrar información en pantalla, obtener el coseno de un ángulo, etc.

De manera general, podemos decir, que existen funciones dentro de las librerías casi para cualquier necesidad, pero ¿qué pasa cuando necesitamos realizar una tarea muy especializada o simplemente no existe ninguna función prefabricada?, pues surge entonces la necesidad de generar nuestras propias funciones y que el Lenguaje C nos permita generar nuestras propias funciones es una herramienta muy potente.

2.1 La función scanf()

Esta función permite que el usuario introduzca información a través de la entrada

estándar de la computadora (el teclado).

A continuación un ejemplo:



Explicación:

En el código fuente anterior se declara una variable de tipo char llamada le, por medio de la función printf() se escribe en pantalla el mensaje “Introduce un carácter”, nota que la instrucción es introducir un carácter no dos o más, en la siguiente línea por medio de la implementación de la función scanf() el usuario puede teclear un carácter y este será guardado en la variable llamada le.

Es necesario colocar el modificador %c para indicar explícitamente al compilador que el tipo de datos que se va a introducir por el teclado es de tipo char, así mismo, es necesario escribir el operador &(dirección de ) antes del nombre de la variable donde se desea que se guarde la información introducida por el usuario a través del teclado.

Observa que el usuario tecleo equivocadamente una palabra en lugar de un carácter, debido a que la variable llamada le de tipo char solo puede almacenar un carácter, ya que solamente se guarda el primer carácter, en este caso la E.

La demás información tecleada por el usuario se pierde ya que no existe variable que pueda almacenarla.

Para corroborar que el primer carácter ha sido guardado nuevamente se utiliza la función printf() para mostrar el contenido de la variable llamada le.

Es posible introducir más de un dato por el teclado con una sola función scanf(), es necesario colocar un modificador % por cada variable declarada y escribir explícitamente por medio de el operador dirección de (&) el orden y lugar donde se guardara la información.

Por ejemplo:

El resultado de editar, depurar y compilar las líneas de código anteriores dentro de una función main() será el siguiente:


2.2 Las funciones getch() y getche()

Estas dos funciones permiten al usuario introducir un carácter por el teclado. La diferencia

entre getche() y getch() es que la primera imprime en pantalla la tecla que se ha pulsado y

la segunda no. Ambas funciones se encuentran declaradas y definidas en la librería

llamada conio.h. Enseguida se te da un ejemplo:


Explicación:

Observa que al utilizar a la función getch() se tecleo una R, pero al momento de teclearla no se imprime este carácter en pantalla, se imprime únicamente al mostrarla por medio de la función printf(), en cambio con la función getche() al momento de presionar en el teclado el carácter o este se imprime en la pantalla automáticamente.


Para corroborar que los datos se guardaron correctamente se utiliza a la función printf() para mostrar el contenido de la variable.

Actividad Integradora 1. Introduciendo datos por el teclado

Ya conoces la estructura general de un programa, los tipos de variables con que cuenta el lenguaje C, además sabes cómo implementar las funciones de entrada y de salida estándar con que cuenta este Lenguaje, es momento de poner en práctica todos estos conocimientos.

Instrucciones:

1. Realiza un código fuente escrito en Lenguaje C que te permita introducir el RFC de cualquier persona física.

2. Se debe introducir el RFC carácter por carácter sin espacios en blanco entre ellos.

3. Después de introducir el último carácter, al presionar la tecla Enter, en la pantalla de tu PC se debe desglosar la información correspondiente a cada uno de los elementos que componen el R.F.C. la imagen siguiente muestra el resultado que debes obtener:

4. El Programa debe funcionar correctamente para cualquier RFC que introduzcas. 5. Cuando hayas terminado tú programa, lo hayas depurado, compilado y funcione

correctamente, envía a tu profesor el archivo del código fuente y la imagen del programa en ejecución a la plataforma con el siguiente formato: apellidopaterno_materno_nombre_actividadnumero.


Antes de comenzar lee la siguiente nota informativa en la que te puedes apoyar para realizar tu código fuente, en ellas se te explica qué es el RFC, y como se determina.

¿Qué es el RFC?

El Registro Federal de Contribuyentes (RFC) es una clave que debe tener cualquier persona en México que realice alguna actividad laboral lícita y esté registrada ante Hacienda, El RFC se forma con los datos personales del contribuyente, su nombre y fecha de nacimiento. El registro se debe hacer en las oficinas del Servicio de Administración Tributaria de la Secretaria de Hacienda y Crédito Público, esta instancia otorga una homoclave diferente para cada registro y es obligatorio para todas las personas.

¿Cómo se determina?

Para explicarte como elaborar el RFC se va a tomar como ejemplo los datos de la siguiente persona:

El Sr. José Vélez Cuevas, nació el 26 de marzo de 1986.

Partiendo de estos datos, se toman las dos primeras letras del apellido paterno (VE), la primera letra de apellido materno (C), la primera letra del nombre (J), posteriormente se agrega a la clave la fecha de nacimiento, comenzando con el año, el mes y el día, todo con números (aa, mm, dd): 860326, finalmente, el RFC del Sr. José Vélez es el siguiente: VECJ860326, ya que se tiene el R.F.C., la Secretaría de Hacienda designa una homoclave.

Conclusión.

Las funciones estándar para introducir información por el teclado son: scanf(), getch() y getche()

La primera permite introducir cualquier cantidad de información en una sola línea y de cualquier tipo, siempre y cuando se indique en forma explícita con el operador %i, %c, o %f de acuerdo al tipo de variable que se desea introducir.

En cambio las funciones getch() y getche() únicamente permiten introducir un solo dato, además de que getch() no muestra en pantalla la información tecleada desde la entrada estándar de la computadora (el teclado) y la función getche() si lo hace.

¡Buen trabajo! ¡Continúa con el Tema 3!


3. Funciones matemáticas

Introducción

En ocasiones durante el proceso de la programación en Lenguaje C es necesario realizar cálculos matemáticos, por ejemplo: calcular la raíz cuadrada de un número u obtener el valor absoluto de una variable; debido a estas necesidades los desarrolladores del lenguaje proveen una librería en la cual se encuentran declaradas y definidas las funciones matemáticas más usadas por los programadores, esta librería se llama math.h

Para usar la librería de matemáticas math.h, se debe incluir la directiva del preprocesador #include<math.h>.

Al incluir esta directiva en tu código fuente podrás utilizar las siguientes funciones:

Función Tipo de variable Propósito

acos(d) double Devuelve el arco coseno de d

asin(d) double Devuelve el arco seno de d

atan(d) double Devuelve el arco tangente de d

atan(d1, d2) double Devuelve el arco tangente de d1/d2

ceil(d) double Devuelve el valor redondeado por exceso, al siguiente entero mayor

cos(d) double Devuelve el coseno de d

cosh(d) double Devuelve coseno hiperbólico de d

exp(d) double Eleva a la potencia d

fabs(d) double Devuelve el valor absoluto de d

floor(d) double Devuelve el valor redondeado por defecto al entero menor más cercano

log(d) double Devuelve el logaritmo natural de d

log10(d) double Devuelve el lo. (base10) de d

pow(d1, d2) float Devuelve d1 elevado a la potencia d2

sin(d) Double Devuelve el seno de d

sinh(d) double Seno hiperbólico de d

sqrt(d) float Raíz cuadrada de d

Tan(d) double Devuelve la tangente de d

tanh(d) double Devuelve la tangente hiperbólica de d

Algunos ejemplos de cómo utilizar las funciones mostradas en la tabla anterior se

presentan a continuación.


Se necesita escribir el código fuente de un programa en Lenguaje C, dicho programa será capaz de obtener el valor de la hipotenusa del siguiente triangulo rectángulo:

A= 20.2 cm. C= ¿? cm. C2 = A2 + B2

B= 50.05 cm.

El código fuente que da solución a este problema es el siguiente:



Explicación:

En este código fuente se declararon cuatro variables de tipo float A, B, C y D respectivamente, las cuatro variables se iniciaron con el valor de la constante cero.

Enseguida, gracias a la función printf()se muestra la cadena de caracteres: "Introduce el valor del cateto A: "

Después se colocó la función scanf() la cual permite que el usuario del programa introduzca el valor solicitado por medio del teclado de la computadora, este valor se guarda en la variable A.

Se muestra otra cadena de caracteres que indica al usuario del programa tecle el valor del cateto B, una vez más la función scanf() permite almacenar este valor en la variable de tipo float llamada B.

Posteriormente se eleva el valor de la variable A al cuadrado(pow(A,2)), utilizando a la función pow(), como se pudo observar en la tabla mostrada anteriormente, esta función acepta dos argumentos, el primero (en este caso la variable A) y el segundo (en este caso la constante 2) que se encarga de indicar el exponente al cual ha de elevarse la variable llamada A de tipo float.

Se realiza la misma operación con la variable B. El resultado de estas dos operaciones se guarda en las variables D y E respectivamente.

Inmediatamente después se suman estos dos valores y se guarda en la variable C de tipo float, para enseguida obtener la raíz cuadrada de esta operación aritmética (suma), para ello se utiliza a la función sqrt() que como se muestra en la tabla anterior esta función acepta un solo argumento de tipo float y devuelve la raíz cuadrada de este argumento, en este caso el valor de la variable C que contiene la suma de los cuadrados de las variables A y B.

Por último se muestra el resultado de esta operación por medio de la función printf().


Nota: La implementación de las otras funciones matemáticas es similar a la vista anteriormente.

Actividad de aprendizaje 11. Calculando

Ahora conoces las funciones matemáticas y su aplicación, estás en condiciones de aplicar este conocimiento para la construcción de software que permita dar solución a problemas de ingeniería.

Instrucciones:

1. Escribe un código fuente en Lenguaje C que calcule el volumen de un elipsoide (Zepelín).

2. Las longitudes de los semiejes se deberán introducir por el teclado y el volumen correspondiente a las dimensiones que el usuario teclee se mostrará en pantalla. 3. Para apoyarte en la realización del programa revisa la información que se te presenta, a continuación para calcular el volumen de un dispositivo con esta geometría. Da clic en la palabra Elipsoide para que se te muestre dicha información.

Un elipsoide es una superficie curva cerrada cuyas tres secciones ortogonales principales son elípticas, es decir, son originadas por planos que contienen dos ejes cartesianos.

Volumen:

El volumen de un elipsoide está dado por la ecuación:

Donde a, b y c son las longitudes de los semiejes del elipsoide respecto de los ejes x, y , z; son números reales positivos y determinan la forma del elipsoide. Si dos de estos semiejes son iguales, el elipsoide es un esferoide; si los tres son iguales, se trata de una esfera.

Cuando hayas terminado tu programa, lo hayas depurado, compilado y funcione correctamente, envía a tu profesor el archivo del código fuente y la imagen del programa en ejecución a la plataforma con el siguiente formato: apellidopaterno_materno_nombre_actividadnumero.


Conclusión.

La librería llamada math.h contiene la declaración y definición de las funciones matemáticas más usadas por los programadores de Lenguaje C, en ella se encuentran declaradas las funciones sqrt() para obtener la raíz cuadrada de numero o la función pow() que nos permite elevar un número a una potencia dada, el uso de estas funciones es muy sencillo y para poder utilizarlas dentro de un código fuente de Lenguaje C basta con incluir en la directiva del preprocesador el nombre de esta librería.

¡Muy bien, terminaste! Concluye la unidad trabajando el Tema 4


4. Funciones generadas por el usuario

Introducción

Durante el proceso de la programación en Lenguaje C surgen necesidades muy específicas para las que no existe ninguna función prefabricada, el Lenguaje C brinda una forma sencilla y flexible al programador para que éste pueda declarar y definir sus propias funciones, esta es una herramienta muy potente ya que al declarar y definir las funciones propias se está en posibilidad de dar casi cualquier orden a la computadora.

4.1 Declaración y definición de una función

Una función es un método en el cual se escriben de forma explícita las instrucciones que la computadora deberá ejecutar, para alcanzar un objetivo específico.

Ya has utilizado algunas funciones prefabricadas, por ejemplo la función printf() y la función system(“PAUSE”), cada una realiza una tarea específica y como ya sabes estas están declaradas y definidas dentro de las librerías.

Para poder utilizar una función es necesario declararla, es decir indicarle al compilador en forma explícita cual es el nombre de la función, su tipo y si posee o no argumentos.

También es necesario definirla, es decir, escribir en forma explícita las instrucciones que pertenecen a dicha función (dentro de las llaves de apertura y cierre { }), finalmente estas instrucciones describen el funcionamiento de la función (el ¿Qué hace?).

La declaración y definición de una función debe realizarse de acuerdo a la siguiente sintaxis:

Tipo_de_variablenombre_de_la_funcion( argumentos )

1 3

{

definición de variables;

4

cuerpo de la funcion;

5

return

6

}


1. Cuando una función termina de ejecutarse puede o no devolver un valor, el cual puede ser cualquiera de los tipos de variable vistos anteriormente, (int, char, float, double) o un tipo de dato definido por nosotros. Este valor devuelto suele ser el resultado de las operaciones que se realizan en la función y si han tenido éxito o no. También se puede usar el tipo void. Este tipo de datos no regresa ningún valor al finalizar la función.

2. Para el nombre se pueden utilizar letras, números y el símbolo _. No se pueden utilizar ni acentos ni espacios en blanco. Además el nombre de la función debe comenzar por una letra, no puede comenzar con un número. Tampoco puede ser una palabra reservada. El nombre de la función se usa para llamarla dentro del programa. Por ejemplo, un nombre valido para una función puede ser el siguiente: Rodrigo_Aviles() ó Resta123()

3. Los argumentos son variables de cualquier tipo, sirven para dotar a la función de la “capacidad” de recibir información, debe declararse cada argumento(variable) separado por un operador coma (,), la declaración de estos argumentos no termina con el operador punto y coma (;).

Nota: No en todas las funciones se declaran argumentos, únicamente se declaran cuando es necesario recibir información proveniente de alguna otra función u otro programa.

4. Dentro de la función podemos definir variables (variables locales) que sólo sean conocidas dentro de la función (delimitada por las llaves de apertura y cierre { }). Si declaramos una variable en una función no podemos usarla en otra.

5. Aquí es donde se escriben de forma explícita las instrucciones que describirán la ejecución de la función, es decir que trabajo realizara la función.

6. La sentencia return es la función devuelve un valor, es la encargada de realizar esta tarea, el dato que se pone después de return es el dato que se devuelve, éste puede ser una constante o una variable y debe ser del mismo tipo que el tipo_de_variable.

Aunque la excepción a esta regla es la siguiente: Si se colocó el tipo de variable void, no debe colocarse la instrucción return. Las funciones deben declararse y definirse antes de ser llamadas (utilizadas en un programa).

En los ejemplos que se muestran en los siguientes apartados se llama a la función desde main, así que se tiene que declarar y definir la función antes que se escriba la función principal main().


4.2 Función sin argumentos que no devuelve ningún valor

Observa el siguiente código fuente, en el se muestra la declaración y definición de una función que no devuelve ningún valor, además de no tener argumentos esta función se llama resta y su trabajo consiste en realizar la resta de dos números que se introducirán por el teclado, el resultado se mostrara por pantalla.



Explicación:

En este código fuente se declara y define la función llamada resta(), esta función no devuelve ningún valor por lo tanto se le coloca la palabra reservada void, más adelante se mostrara una función que si regresa valores, así podrás comparar esta característica de las funciones, observa que la declaración y definición de la función resta(), se realizó antes de la función principal main():

void resta()

{ Declaración y definición de la función resta()

}

Intmain()

{ Funciónprincipal main()

}

Dentro de las llaves de apertura y cierre ( { } ) se declararon tres variables locales de tipo int llamadas a, b y c respectivamente.

En la siguiente línea de código se imprime en pantalla el siguiente texto “Esta función restará dos valores:” y enseguida por medio de otra función printf() se indica al usuario que introduzca el valor que almacenará la variable a, por medio de la función scanf()

El valor tecleado por el usuario del programa se guardara en la variable a, para inmediatamente después realizar exactamente el mismo procedimiento pero ahora el valor tecleado por el usuario se guardara en la variable b.

Enseguida de realiza la resta entre a y b guardando el resultado de esta resta en la variable c, de este modo c = a-b; recuerda que en el Lenguaje C la asignación es asimétrica es decir el valor de la variable de la derecha se guarda en la variable de la izquierda, por lo tanto el resultado de la resta se guarda en la variable c que inmediatamente después se muestra por pantalla.

Lo explicado anteriormente es únicamente la declaración y definición de la función resta(), en otras palabras, aquí solo estamos escribiendo (indicándole al compilador) el tipo de variable que devolverá la función, en este caso no devuelve ninguno (void),


El nombre de la función en este caso es resta() y especificamos si esta función tiene argumentos, esto se hace declarando variables dentro de los paréntesis, en este caso no los tiene.

Si no realizaras la invocación de resta() desde la función main() el programa solo ejecutaría la función system(“PAUSE”); y nunca se ejecutara la función resta().

Si se edita, depura y compila el código fuente anterior y se omite la invocación a la función resta, se obtiene el siguiente resultado:

Omisión de la invocación.

4.3 Función con argumentos que no devuelve ningún valor

Observa el siguiente código fuente, en él se muestra la declaración y definición de una función que no devuelve ningún valor, esta función tiene argumentos, se llama suma y su trabajo consiste en realizar la suma de dos números que se introducirán por el teclado, el resultado se mostrara por pantalla. Observa que este código fuente es muy semejante al anterior, pero ahora la función se llama suma y tiene dos argumentos (variables) de tipo int, por tal motivo es necesario que otra función o programa le proporcione los valores de a y de b respectivamente.


Explicación:

En este código fuente escrito en Lenguaje C se declaró y definió una función llamada suma(), con dos argumentos (variables) de tipo int a y b respectivamente, es en estas dos variables en donde la función suma() recibirá los valores que sumara, la ventaja que se obtiene al declararle argumentos a una función es dotarla de la capacidad de recibir información, esta información proviene de otra función u otro programa.

Por lo anterior es necesario “pasarle” estos datos a la función, en este caso la función suma() únicamente puede recibir información de tipo int y solamente puede recibir dos valores ya que solo tiene dos argumentos de este tipo.

Esta función no regresa ningún valor por lo tanto se le antepuso la palabra reservada void. Después se declaró una variable local llamada c de tipo entero, la cual fue iniciada con la constante cero. Enseguida y por medio de la función printf() se imprime en pantalla una cadena de caracteres indicando que la función sumará dos números, después por medio de la instrucción c=a+b;

Se suman los valores de las variables a y b, el resultado se almacena en la variable llamada c, si observas cuando se declararon los argumentos a y b ( suma (int a, int b) ) a ninguno de estos dos argumentos se le asigno valor alguno, es decir estas variables no fueron iniciadas, pero por tratarse de argumentos el compilador se encarga de iniciar estas variables llamadas argumentos con valor cero, en otras palabras el compilador guarda un cero en estas variables.

Te podrás preguntar: ¿sumará 0 + 0? y la respuesta es:

La función suma() realizará la operación de suma de los valores que almacenen los argumentos a y b, recuerda que estos valores debes “pasárselos”.

Observa los comentarios en el código fuente, en el verás el momento en que se le pasan estos datos es en la línea suma(A,B); y por último la funcion suma() muestra el resultado de esta operación aritmética en pantalla.


En la línea siguiente encontrarás la declaración y definición de la función principal del programa es decir main(), dentro de esta se encuentra la declaración de dos variables de tipo int llamadas A y B, (observa que estas variables tienen un nombre diferente que los argumentos) por medio de la función printf() se solicita introducir el valor de la variable A para posteriormente guardar el valor tecleado por el usuario en la variable llamada A por medio de la función scanf(), enseguida se realiza la misma operación pero ahora con la variable llamada B, guardando el valor tecleado en la variable B.

A continuación se observa la invocación a la función suma() de la siguiente manera: suma(A,B); lo que se está haciendo aparte de invocar a esta función es “pasarle” el valor que almacena la variable A al argumento llamado a, de igual forma el valor que almacena B se le “pasa” al argumento b y de esta forma la función suma() recibe los dos valores que ha de sumar.

En este ejemplo la funcion principal main() es la función que se encarga de proveer (pasarle ) información a la funcion suma().

4.4 Función sin argumentos que devuelve un valor

Observa el siguiente código fuente escrito en Lenguaje C, en él se muestra la declaración y definición de una función sin argumentos que devuelve un valor, el trabajo que realizara esta función es multiplicar dos valores y regresar el resultado de esta multiplicación. Te puedes preguntar ¿Y a quién y cómo le regresa este valor ?Respuesta: El valor que regresa la función debe recibirlo una variable del mismo tipo que la información que devuelve la función.


El resultado de editar, depurar y compilar este programa es el siguiente:


Explicación:

En este código fuente escrito en Lenguaje C se declaró y definió la función llamada por() sin argumentos, esta función devuelve un valor y el valor que devolverá será de tipo float, esto se debe a que se le antepuso la palabra reservada float de esta manera: float por()

Dentro de la funciónpor() se declaran e iniciaron tres variables con valor cero de tipo float llamadas a,b y c respectivamente.

Por medio de la función printf() se solicitó introducir el valor de la variable a y b guardando la información tecleada por el usuario por medio de la función scanf() en a y b respectivamente.

En la línea c=a*b; se realiza la multiplicación de estos dos valores. Después se regresa el resultado de esta multiplicación, almacenado en la variable c, con la instrucción return c; la palabra reservada return indica al compilador que deberá devolver el valor de la variable cuyo nombre se coloca enseguida, en este caso la variable local c.

Dentro de la función principal main() se declaró una variable llamada C de tipo float la cual almacenará el valor que regresa la función por(), debido a que la función por() devuelve el contenido de la variable c de tipo float es que la variable C declarada en main() debe ser también de tipo float, esto para poder almacenar correctamente dicho valor devuelto.

Enseguida se invoca a la función por() y el valor que devuelve esta función se almacena en la variable llamada C como ya se explicó anteriormente. Por último se muestra en pantalla a la variable C que ahora contiene el resultado de la multiplicación.

Actividad de aprendizaje 12. “Declarando una función”

Para realizar esta actividad se va a retomar el código fuente y el resultado de la misma, que es el volumen del elipsoide.

El objetivo de esta actividad es que construyas un software que implemente funciones capaces de resolver problemas de ingeniería.

Instrucciones:

Realiza un código fuente escrito en Lenguaje C que te permita calcular la capacidad de ascensión (Peso que puede elevar) de un elipsoide.

Para realizar estos cálculos revisa la información que se te presenta mismo que te va a servir de apoyo para esta actividad.


Helio: El helio es un gas inerte, incoloro e inodoro mucho más ligero que el aire y además es seguro, no tóxico, no inflamable y no explosivo. Recuerda que de acuerdo a sus propiedades el helio (He) es el gas más apropiado para inflar un zepelín.

Cálculo de la capacidad de ascensión El peso específico del helio es, en condiciones ambientales normales, 0,18 kg/m³, el del aire es 1,21 kg/m³. La diferencia entre ambos significa que la capacidad teórica ascensional es de aproximadamente 1 g por litro de helio. En la práctica, dicha capacidad está asegurada si el peso del globo y de los anexos (cordeles, tarjetas) es menor de 0,5 a 0,6 g por litro del volumen del globo. El volumen (V) en litros del globo se calcula en función del diámetro (d) de la siguiente forma: V (litros) = (0,524/1000) × (d (en cm))³. Por lo tanto, un globo esférico con un diámetro de 30 cm tiene un volumen de 14,1 litros y una capacidad ascensión al suficiente para un peso de aproximadamente 7 a 8,5 g. Los globos en forma de pera que cuentan con el mismo diámetro, tienen un volumen levemente más grande. De acuerdo a la información que se te está proporcionando y retomando el código fuente que desarrollaste en la actividad de aprendizaje 12, declara y define una función llamada ACENCION() que te permita calcular la capacidad de ascensión del elipsoide cuyas dimensiones se deben introducir por el teclado.

La función ACENCION() debe ser invocada en main() y recibir el volumen calculado previamente, esta realizará el cálculo de la ascensión y mostrará este resultado en pantalla.

Cuando hayas terminado tú programa, lo hayas depurado, compilado y funcione correctamente, envía a tu profesor el archivo del código fuente y la imagen del programa en ejecución a la plataforma con el siguiente formato: apellidopaterno_materno_nombre_actividadnumero. Nota: Con esto tendrás una idea aun más clara no solo de las dimensiones y cantidad de helio que utilizarías si decidieras realizar un prototipo de esta clase, sino también el peso que podrías elevar con este elipsoide.


Conclusión:

La declaración y definición de una función además de permitir al programador dar

órdenes a una computadora, hace posible solucionar problemas para los que no existe

ninguna función prefabricada en las librerías, existen funciones que posen argumentos y

funciones que no poseen argumentos, así como funciones que egresan valores y

funciones que no regresan nada, lo anterior depende de las necesidades especificas para

las cueles se declara y define una función.

Vas muy bien y estás a la mitad del camino para concluir esta Unidad de aprendizaje,

sigue esforzándote y practicando ya que estas son las bases para lograr el éxito y

aprender a programar.

¡Adelante con la Unidad III!

Fundamentos de Programación Unidad III. Sentencias de control

90

Unidad III. Sentencias de control

Mapa de conceptos

Introducción:

Durante el proceso de la programación pueden surgir algunas necesidades a la hora de

crear un programa, por ejemplo puede ser necesario que alguna o algunas instrucciones

se repitan más de una vez, o un número determinado de veces, o quizá por un número

ilimitado de veces o hasta que se cumpla alguna condición.

Para satisfacer tales necesidades el Lenguaje de programación C brinda al programador

herramientas sencillas y eficaces, estas herramientas se llaman sentencias de control y

sirven para manipular y re direccionar el flujo de ejecución de un programa.

Para poder utilizar cualquiera de las sentencias de control basta con incluir la librería

stdio.h y en esta unidad temática se te van a explicar todas las sentencias del Lenguaje

C.

1. Sentencia de control for

La sentencia de control for, se utiliza para repetir un número determinado de veces, una o

varias instrucciones que se encuentren escritas dentro de las llaves de apertura y cierre ( {

} ) que delimitan el cuerpo de esta sentencia de control, su interpretación en español

puede ser ciclo

Unidad III

Sentencias de control

Sentencias de

control while y do

while

Sentencia de

control for

Sentencia de

control if else

Sentencia de

control break

Sentencia de

control switch

Sentencia de

control goto


.

La sintaxis de esta sentencia de control es la siguiente:

{

Sentencias o bloque de instrucciones;

}

1. sentencia de control for

2. asignación inicial: En esta instrucción se asigna un valor cualquiera (el que se necesite)

a una variable declarada previamente, esta variable puede ser de cualquier tipo.

3. condición: en este lugar se indican los requisitos necesarios para que las instrucciones

escritas dentro de las llaves de apertura y cierre se ejecuten continuamente el número de

veces establecido por esta condición, mientras la condición se cumpla las instrucciones se

ejecutaran, cuando la condición no se cumpla las instrucciones dejarán de realizarse.

Para realizar esta acción puedes auxiliarte de los operadores lógicos aprendidos

anteriormente, por ejemplo, cuando la condición sea verdadera (regrese un 1) el ciclo for

se ejecutará continuamente cuando la condición sea falsa (regrese un 0), se dejará de

ejecutar (puedes agregar más de una condición).

4. Incremento_o_decremento: Aquí se puede realizar tanto un incremento como un

decremento según sea la necesidad, regularmente se incrementa una variable (esta debe

ser declarada previamente) la cual interviene en la condición de esta sentencia de control.

Para realizar los incrementos te puedes apoyar en el operador ++ o para los decrementos

te puedes apoyar en el operador - - .

5. llave de apertura

6. llave de cierre

La ejecución de la sentencia de control for se efectúa de la siguiente manera:

for(asignación inicial ; condición ; incremento_o_decremento )

2 3 4 1

5

6


1. Se realiza la asignación inicial en la variable que se escribe después de la palabra

reservada for y el operador paréntesis de apertura “(”, terminando esta instrucción con

un punto y coma.

2. Se evalúa la condición que se encuentra después de la asignación inicial, obteniéndose

un resultado verdadero o falso (0 ó 1).

3. Si el resultado es falso (cero) la(s) sentencia(s) no se ejecuta(n), y se ejecuta la

siguiente instrucción situada después de la llave de cierre ( }).

4. Si el resultado es verdadero (distinto de cero) se ejecuta(n) la(s) sentencia(s) una vez,

después se realiza la parte de los incrementos o decrementos que se hayan escrito,

después este mismo proceso se repite desde el punto 2.

Notas: El número de veces que se repetirán las instrucciones está en

función del número de veces que se cumpla la(s) condición(es).

Observa que en la sintaxis de la línea de código de for, al final de los

paréntesis, no se escribió punto y coma (;).

A continuación se te mostrará un ejemplo en el que se utiliza la sentencia for en un

programa donde se calcula las coordenadas de un proyectil, el cual realiza un movimiento

parabólico, este programa va a calcular 10 puntos de la trayectoria.

Analízalo y después edítalo, depúralo y compílalo porque lo vas a necesitar para la

siguiente actividad que realices.

Para realizar el programa se ocuparán las siguientes fórmulas, mismas que sirven para

calcular la trayectoria de un móvil en tiro parabólico:

Donde Vi es la velocidad inicial del proyectil,

Ѳ es el ángulo de lanzamiento del proyectil, t

es el tiempo y g es la gravedad.


Este es el código fuente del programa:


Este es el resultado que debes de obtener al editar, depurar y compilar el código fuente anterior:

Foro 1. “¿PoR qUé Lo HaCe?”

Ahora que se te explicó la sentencia de control for y analizaste el código fuente que se te mostro como ejemplo, además de que lo trabajaste, estas en condiciones de participar en el siguiente foro, la cual tiene como objetivo que razones el aprendizaje que has adquirido hasta este momento y realices lo que se te pide a continuación:

Instrucciones:

1. Responde las siguientes preguntas con base al código fuente que trabajaste:

En qué línea de código se encuentran la asignación inicial, la condición y los

incrementos que cumplen la sintaxis de la sentencia de control for:

¿Por qué la sentencia de control for, implementada en el código, calculó 11 posiciones

(coordenadas) y no 10 como se indicó?

¿Cómo solucionarías esta falla en el programa para lograr que calcule únicamente 10

posiciones?

¿Por qué se incluyó la siguiente línea de código antes de la sentencia de control for?

ang = ((ang*PI)/180);

Comenta qué modificaciones realizarías al programa para que éste calculara 359854

posiciones (coordenadas en “x” y “y”) del proyectil en tiro parabólico.

2. Tienes que emitir primero tu participación para poder ver las aportaciones de tus compañeros.

3. Retroalimenta dos participaciones de tus compañeros.

4. Recuerda participar en el foro de manera respetuosa.


Conclusión:

En este tema, se expuso la sentencia for. Esta sentencia se utiliza para ejecutar un número determinado de líneas de código (instrucciones), ya sea una o más veces, y esto ayuda a ahorrar trabajo al realizar un programa.

¡Buen trabajo, sigue adelante con tus temas!


2. Sentencias de control while y do while

Introducción:

Como ya se mencionó anteriormente durante el proceso de programación surgen

necesidades muy específicas, como repetir una o más instrucciones (o líneas de código)

en lo que se cumple una condición, por ejemplo si un programa se encarga de verificar los

sistemas de control de un vehículo (la computadora de un auto), se le puede indicar que

únicamente lo haga cuando el auto este encendido, si el auto está apagado no verificara

nada, en este contexto es conveniente utilizar una sentencia de control while o una

sentencia de control do while, en este tema se te explicará cada una, así como la

diferencia entre ambas.

while

La sentencia de control while, puede ejecutar una o varias instrucciones (líneas de código)

cero o más veces, dependiendo de una condición específica, para realizar esta sentencia

te puedes apoyar en los operadores lógicos. La interpretación que se le puede dar en

español a esta sentencia es “mientras” (mientras se cumple la condición).

Su sintaxis es la siguiente:

while (condición)

{

Sentencia(s);

}

Descripción:

La condición indicada después de la sentencia while puede ser cualquier condición

numérica, relacional o lógica.

Si la condición se cumple se realizan las sentencias que se encuentran entre las

llaves de apertura y cierre hasta que la condición deje de cumplirse.

La ejecución de la sentencia de control while se efectúa de la siguiente manera:

1. Se evalúa la condición que se encuentra después de la sentencia while,

obteniéndose un resultado verdadero o falso (0 ó 1).


2. Si el resultado es falso (cero) la(s) sentencia(s) no se ejecuta(n), y se ejecuta la

siguiente instrucción situada después de la llave de cierre ( }).

3. Si el resultado es verdadero (distinto de cero) se ejecuta(n) la(s) sentencia(s) y el

proceso descrito se repite desde el punto 1.

Nota: observa que en la sintaxis de la línea de código de while al final de

los paréntesis no se escribió punto y coma (;).

A continuación se te mostrará un ejemplo en el que se utiliza la sentencia while en un

programa escrito en Lenguaje C.

Debes editarlo, depurarlo y compilarlo. Este programa te permitirá incrementar una

variable de forma ininterrumpida, el valor inicial de la variable es 3, el incremento debe

realizarse de uno en uno y la variable dejará de incrementarse cuando su valor sea igual a

300, cada incremento debe mostrarse en pantalla a partir del valor inicial hasta llegar al

valor final.

El siguiente es el código fuente que permite realizar la acción descrita anteriormente:


En la imagen siguiente se muestra el resultado de editar, depurar y compilar el código

fuente anterior.

¿No funcionó el programa?

Si editaste, depuraste y compilaste el código fuente anterior pudiste constatar que el

programa no funciono como se requería.

No te preocupes los errores son muy comunes en la programación, se te invita a volver a

leer el código fuente, pero ahora con más atención, busca el posible error y recuerda que

puedes ponerte en contacto con tu asesor, el puede ayudarte y aclarar tus dudas.

Da clic sobre el botón “explicación” para que se te dé a conocer el motivo del error

sucedido:

Explicación:

El error no es de sintaxis ya que se compilo exitosamente el programa, sin embargo,

observa detalladamente las instrucciones en la quinta y sexta líneas de código:

int contador = 301;

while ( contador==300 )

Es en estas líneas en las que se encuentra el problema, como puedes ver, en la quinta

línea de código a la variable de tipo entero llamada contador se le asignó un valor de 301

al momento de declararla, ahora revisa la sexta línea de código, en ella se ordena

ejecutar las instrucciones escritas dentro de las llaves de inicio y cierre ({ } ), siempre y


cuando se cumpla la condición entre paréntesis ( contador==300 ), es decir que la

variable “contador” sea igual al valor 300, como ya observaste la variable “contador” fue

declarada con un valor de 301, por lo que no se cumple la condición ya que al hacer la

comparación el operador (==) devuelve un valor de cero y las instrucciones no se

ejecutan.

Ahora que ya sabes dónde estuvo el error, responde la siguiente pregunta:

¿Qué crees que pasé si en lugar iniciar a la variable contador con valor de 301 se inicia

con valor 0 (cero)?

Prueba esta sugerencia en el código fuente y se vuelve a editar, depurar y compilar el

programa, no continúes con la lectura hasta que realices esto que se te pide.

Si ya realizaste el cambio de la variable “contador” a cero y ya compilaste el programa, da clic en el botón “nuevo resultado” es importante que no revises esta información si no has compilado el programa con el cambio que se te indicó, ya que tu aprendizaje será mejor si experimentas lo que se te indica.

“Nuevo resultado”

El resultado de editar depurar y compilar el código fuente ya corregido es el siguiente:


¡Upss! ¿Aun no funciona?

El programa sigue sin funcionar, lo cual indica que existe otro error en el código fuente, no

te desesperes solo tienes que revisar con mucho detalle tu código fuente, recuerda que a

la computadora se le debe indicar exactamente lo que tiene que hacer, ese es el

problema, alguna instrucción que se le está dando a la computadora está mal.

Observa nuevamente la sexta línea de código: while ( contador==300 ) el operador de

comparación que se está utilizando “compara” si la variable contador es igual que 300

(esto ya lo sabes), pues bien, la condición solamente se cumplirá si contador almacena un

valor igual a 300, entonces no se esta utilizando el operador de comparación adecuado a

las necesidades de este programa, el operador más apropiado para este caso es el

operador < (menor que) , por lo que la corrección al código fuente debe ser de la

siguiente manera:

while ( contador < 300 )

{

contador++;

printf( "La variable contiene un: %i,.\n", contador );

}

De esta forma las instrucciones escritas dentro de las llaves de apertura y cierre se

ejecutarán ininterrumpidamente mientras la variable contador sea menor que 300.

Observa el siguiente ejemplo del resultado de compilar el código fuente ya corregido.


Explicación:

En el código fuente anterior dentro de la función principal main() se declaro una variable

de tipo int llamada contador, la cual fue iniciada con cero, enseguida se implemento la

sentencia de control while, dentro de la cual se escribió la comparación siguiente:

(contador < 300), aquí se le indica a la computadora que las instrucciones escritas dentro

de { y } se ejecutarán de forma ininterrumpida mientras se cumpla que contador sea

menor que trescientos

Dentro de la sentencia while lo primero que realizará la computadora es incrementar el

valor de contador en uno, para enseguida mostrar el contenido de esta variable por

pantalla y después de esto volverá a evaluar si contador es menor que trescientos, ahora

contador ya no guarda un 0 sino un 1 (ya que fue incrementado), pero sigue siendo menor

que 300 entonces las instrucciones dentro de las llaves de apertura y cierre se vuelven a

ejecutar 299 veces más.

Recuerda: cualquier duda que tengas, puedes consultar a tu asesor.

do while

La sentencia de control do while es muy similar a la sentencia de control while, con la

diferencia de que en la sentencia do while las instrucciones escritas dentro de { y } se

ejecutan por lo menos una vez, esto se debe a su sintaxis:

Nota: la interpretación que se le puede dar en español a estas palabras

reservadas es:

Do: hacer

While: mientras

Esta es la sintaxis:

do

{

Sentencia(s);

}

while (condición);


Descripción:

Después de la palabra reservada do se escriben las instrucciones dentro de las llaves de

apertura y cierre que se ejecutarán una vez, para después evaluar la(s) condición(es)

escrita(s) dentro de los paréntesis escritos delante de la palabra reservada while.

Si la(s) condición(es) no se cumplen no se volverán a ejecutar las instrucciones que están

escritas dentro de las llaves de apertura y de cierre, si las condiciones se cumplen, las

instrucciones antes mencionadas se ejecutaran continuamente hasta que la condición

deje de cumplirse, es decir, sea falsa.

La ejecución de la sentencia de control do while se efectúa de la siguiente manera:

1. Se ejecutan una vez las instrucciones escritas dentro de las llaves de apertura y

cierre ( { } )

2. Se evalúa la condición, obteniéndose un resultado verdadero o falso (0 ó 1).

3. Si el resultado es falso (cero) la(s) sentencia(s) no vuelven a ejecutarse, y se

ejecuta la siguiente instrucción situada después del paréntesis final de la sentencia

while.

4. Si el resultado es verdadero (distinto de cero) se vuelven a ejecutar la(s)

sentencia(s) y el proceso descrito se repite desde el punto 1.

Nota: La condición es cualquier condición numérica, relacional o lógica.

Observa que después del paréntesis de cierre de la condición se escribe

punto y coma (;)

Se te presenta el ejemplo de un programa en el que se utiliza la sentencia de control do

while, al revisarlo podrás notar la diferencia entre las sentencias while y do while


El código fuente:

Aparentemente se volvió a cometer el error de iniciar a la variable contador con 301, pero

esta vez las instrucciones escritas dentro de { y } se ejecutaran por lo menos una vez,

debido a la sentencia de control do while. El resultado de editar, depurar y compilar este

programa es el siguiente:


Conclusión:

La sentencia de control while sirve para repetir una o más líneas de código

(instrucciones), mientras se cumpla una condición, existiendo la posibilidad de que no se

ejecuten ni una sola vez si la condición no se cumple.

Mientras tanto en la sentencia de control do while las instrucciones escritas entre { y } se

ejecutan por lo menos una vez aún sin cumplirse la condición.

¡Bien hecho!

Adelante con el tema 3


3. Sentencia de control if else

Introducción:

En ocasiones durante el proceso de la programación es necesario (de acuerdo a las

necesidades y al contexto especifico) re direccionar la ejecución de un programa escrito

en Lenguaje C, es decir, inducir la ejecución del programa por un camino u otro.

En este punto es necesario que la computadora tome una decisión y el programador es el

encargado de darle a la computadora los elementos necesarios para que se lleve a cabo

esta decisión, esto se hace con ayuda de la sentencia if else.

Su traducción aproximada es: If (si) / Else (de lo contrario).

La sentencia de control if else permite re-direccionar la ejecución de un programa, a partir

de un resultado obtenido, es decir, si el programa detecta un resultado verdadero (1) se

ejecutan cierto bloque de instrucciones, pero si detecta un resultado falso (0) se ejecutara

otro bloque de instrucciones distinto, para la realización de esta sentencia el programador

se apoya en los operadores lógicos, estudiados en la unidad temática 2.

La sintaxis de la sentencia de control if else es la siguiente:

if ( condición )

{

bloque que se ejecuta si se cumple la condición

}

else

{

bloque que se ejecuta si no se cumple la condición

}

Descripción:

La condición indicada después de la sentencia if puede ser numérica, relacional o lógica.

Las instrucciones que se escriben dentro de las llaves de apertura y cierre que se

encuentran inmediatamente después de la sentencia if(condicion), son el bloque de

instrucciones que se ejecutarán si la condición escrita dentro de los paréntesis de la

sentencia se cumple.


Las instrucciones que se escriben dentro de las llaves de apertura y cierre ( { } ) que se

encuentran inmediatamente después de la palabra reservada else, son el bloque de

instrucciones que se ejecutaran si la condición escrita dentro de los paréntesis de la

sentencia if no se cumple.

La ejecución de la sentencia de control if else se realiza de la siguiente manera:

1. Se evalúa la condición, obteniéndose un resultado verdadero o falso (0 ó 1).

2. Si el resultado es falso (cero) el bloque de instrucciones que se ejecuta es el que

se encuentra inmediatamente después de la palabra reservada else y dentro de las llaves

de apertura y cierre. Ya que se hayan ejecutado las instrucciones de este bloque, el

programa ejecutará la instrucción que se encuentre inmediatamente después de la llave

de cierre ( } ), de este mismo bloque.

3. Si el resultado es verdadero (distinto de cero) el bloque de instrucciones que se

ejecutara será el que está situado inmediatamente después de la línea de código

if(condicion). y dentro de las llaves de apertura y cierre. Una vez ejecutado este bloque de

instrucciones el programa seguirá ejecutando las instrucciones que se encuentran

después de la llave de cierre ( } ) que se sitúan al final del bloque de instrucciones de la

palabra reservada else

A continuación se te muestra un programa escrito en Lenguaje C en el que se utiliza la

sentencia if else, el cual debes editar depurar y compilar, este programa debe indicar al

usuario que introduzca un número entero cualquiera y después presione la tecla enter, ya

que se haya hecho lo solicitado el programa indicará con un mensaje en pantalla si el

número introducido es par o no par.

El programa escrito en Lenguaje C que ejecuta las instrucciones anteriormente

mencionadas es el siguiente:


El resultado de editar, depurar y compilar este código fuente es el siguiente, en el caso de

que se introduzca un número entero par.

Y en el caso de que se introduzca un número entero no par:


Explicación:

En este programa se incluyó la librería conio.h, ya que dentro de la función principal

main() se utiliza la función scanf().

La primer instrucción en ejecutarse dentro de la función main() declara e inicia una

variable de tipo entero que es indicada con cero, enseguida se muestra en pantalla la

cadena de texto "Introduce un numero entero cualquiera: " para después almacenar el

numero tecleado en la variable número. Esto ya sabes cómo hacerlo.

Enseguida se encuentra la sentencia de control if la cual evalúa la condición (numero%2

== 0) y observa que se está utilizando al operador % (modulo) el cual divide entre dos el

contenido que almacena la variable número y devuelve el residuo de esta división, si en

este caso el usuario introduce un numero 56554 el operador % divide entre dos y

devuelve como resultado de esta división un 0, ya que 56554/2 = 28277.0 y %(modulo)

devuelve únicamente el residuo de la división no la parte entera.

El residuo, en este caso es cero y se compara por medio del operador de comparación

==(igual que) si el residuo es igual que cero esta nueva comparación es verdadera, es

decir se cumple, y entonces se ejecutará la línea de código; printf( "\nEl número es par

\n"); escrita entre { y } esta línea debajo de la sentencia if(numero%2 == 0).

Si por el contrario el usuario del programa introduce un 9 el operador % divide entre dos y

devuelve como resultado de esta división un 5, ya que 9/2 = 4.5 y %(modulo) devuelve

únicamente el residuo de la división no la parte entera.

El residuo, en este caso es cinco se compara por medio del operador de comparación

==(igual que) y debido a que el residuo no es igual que cero esta nueva comparación es

falsa, es decir no se cumple, entonces se ejecutará la línea de código; printf( "\nEl numero

no es par \n"); escrita entre { y } esta línea debajo de la palabra reservada else.

Después de ejecutar cualquiera de los dos bloques de instrucciones se ejecuta la función

system(“PAUSE”); que es la última función en ejecutarse dentro de la función principal

main().

If else if

Es posible anidar, es decir colocar otra sentencia if después de la palabra reservada else,

esto se hace para evaluar más de una condición, por ejemplo si se necesitara el mismo

programa presentado en el ejemplo anterior con algunas variantes, es decir, ahora se

necesita que el usuario introduzca un numero entero cualquiera por el teclado y después

de presionar la tecla enter la computadora debe mostrar en pantalla un mensaje indicando

si el número que se introdujo es mayor que 30 y menor que 60 o es un número mayor que

60.




Explicación:

Después de introducir por el teclado el número solicitado se realiza la siguiente

evaluación:

if(numero < 30)

si el número es menor que el valor 30 se ejecutará la siguiente línea de código:

{printf( "\nEl numero es menor que 30 \n");}


Cuyo resultado en pantalla será el siguiente.

Si esta condición no se cumple es decir, el número es mayor que 30 el programa lee la

línea de código 11 (else) y ejecuta la línea de código 12:

if(numero > 30 && numero < 60) En esta línea de código hay dos condiciones, la primera que numero sea mayor que

treinta y la segunda que numero sea menor que sesenta, estas dos evaluaciones deben

de cumplirse (ser verdaderas) para que se ejecute el siguiente bloque de instrucciones:

{{printf( "\nEl numero es mayor que 30 y menor que 60\n ");}}

Cuyo resultado en pantalla será el siguiente:

Nota: Para “unir” más de una evaluación, como en el caso anterior puede

hacerse uso de los operadores lógicos, en este caso el operador lógico

AND (&&) visto anteriormente.

Si esta otra condición no se cumple (que el número sea mayor que 30 y menor que 60),

es decir que el número sea mayor de 60, se ejecuta la siguiente línea de código:

{printf( "\nEl numero es mayor que 60\n ");}


Cuyo resultado en pantalla será el siguiente.

De esta forma es como puede anidarse más de una sentencia de control if else.

Conclusión:

La sentencia de control if else permite al programador re-direccionar el flujo de ejecución de un programa, permitiendo así ejecutar un bloque de instrucciones u otro distinto de acuerdo al resultado de una condición especificada. Además de ser posible la anidación de sentencias de control if else if.

¡Buen trabajo!

Sigue adelante con el tema 4


4. Sentencia de control break

Introducción

En este apartado se te explicará cómo puedes abortar (“romper”) la ejecución del ciclo for

en algún momento, antes de que este termine de ejecutarse, lo cual se hace con la

sentencia de control break

break

La sentencia de control break (romper en inglés) permite al programador detener la

ejecución de la sentencia de control for, de acuerdo a una condición dada, aún cuando la

condición del ciclo for se cumpla (sea verdadera).

Para ejemplificarte esta sentencia se retomara el programa realizado en el tema 1.

Sentencia de control for, el cual calcula y muestra en pantalla las coordenadas

cartesianas de un proyectil en tiro parabólico. Pero ahora se le agregará una condición

especial, esta es: si la coordenada “y” alcanza un valor igual o superior a 5000 el ciclo for

que calcula las coordenadas del proyectil dejara de ejecutarse, ya que a esta altura no es

necesario monitorear al proyectil.




Explicación:

El código fuente anterior ya se explico en el tema 1 (revísalo), únicamente se detallarán

las líneas de código que se agregaron:

if(y >= 5000)

{break; }

#include <stdio.h>

#include <math.h>

#include <windows.h>

#define grav 9.81

#define PI 3.141592

int main ()

{

int t;

float x=0,y=0,ang,vi;

printf( " Cual es el angulo de lanzamiento: ");

scanf("%f",&ang);

printf( "\n Cual es la velocidad inicial de lanzamiento: ");

scanf("%f",&vi);

ang = ((ang*PI)/180);

for (t=1;t <= 10; t++)

{

x = (vi*cos(ang)*t);

y = ((vi*sin(ang)*t)*(0.5*grav*t*t));

if(y >= 5000) Si se cumple ejecuta break; {break; } else

printf( "\n Coordenada %i en x = %f, coordenada en y %f. ",t,x,y); Si no sigue la ejecución de for }

system ("PAUSE");

}


else

Como se puede observar en la línea de código de la sentencia if(y >= 5000), si la variable

y que corresponde a la coordenada en y en algún momento del cálculo es mayor o igual

a 5000 se ejecutará la sentencia de control break, al ejecutarse esta sentencia se rompe

el ciclo for (ya no se sigue ejecutando), después de esto la siguiente línea de código en

ejecutarse es la que se encuentre inmediatamente después de la llave de cierre (}) del

ciclo for, en esta caso esa línea invoca a la función system(“·PAUSE”);

Si lo anterior ocurre este sería el resultado en pantalla:

En este caso únicamente se mostraron 5 coordenadas ya que debido al ángulo de

lanzamiento “y” alcanzo en la 6ta. ejecución un valor mayor o igual a 5000.

Pero si el ángulo hubiese sido mucho menor, el ciclo for se hubiera ejecutado

normalmente calculando las diez coordenadas para lo cual fue declarado.


Este es el resultado en pantalla de lo explicado:

Conclusión:

La sentencia de control break permite al programador romper (abortar) la ejecución de un

ciclo for aún cuando la propia condición del ciclo for se cumpla.

break también es capaz de abortar la ejecución de la sentencias de control while y Do

while.

¡Muy bien, buen trabajo!

Sigue adelante


5. Sentencia de control switch

Introducción

Ya conoces el funcionamiento y aplicación de la sentencia de control If else, sabes que

ésta permite re-direccionar el flujo de ejecución de un programa por un camino u otro (un

bloque de instrucciones u otro), pero y ¿si son muchos caminos?, podrías pensar que la

solución está en el anidamiento de la sentencia if else if, pero el Lenguaje C brinda una

herramienta aún más sencilla que la sentencia de control if else, esta es la sentencia de

control switch.

switch

La sentencia de control switch permite al programador re-direccionar el flujo de ejecución

de un programa, es decir, ejecutar un bloque de instrucciones u otro, esta decisión se

toma con base en la evaluación de una condición, su funcionamiento es semejante al

anidamiento de la sentencia de control if else, pero su formato es más claro,

regularmente esta sentencia de control se utiliza para elegir una opción de varias

disponibles de acuerdo a un menú mostrado en pantalla.

La sintaxis de la sentencia de control switch es la siguiente:


Descripción:

variable es una variable de cualquier tipo que almacena un valor idéntico a cualquiera de

las etiquetas escritas en los diferentes casos (case).

case opción_1: es una etiqueta (sin incluir la palabra reservada case).

Case es una palabra reservada que se utiliza únicamente con la sentencia de control

switch, la interpretación más adecuada para la misma es “caso”, esta palabra siempre

tiene que estar acompañada por una etiqueta escrita inmediatamente después y separada

por un espacio en blanco.

Una etiqueta es una instrucción que únicamente sirven como referencia para el

compilador, es decir, no se ejecutan, no muestran nada en pantalla y no realizan ninguna

operación, para nombrar una etiqueta se toman las mismas reglas que para nombrar una

variable o una constante, al final de la línea de código de una etiqueta se pone el

operador : (dos puntos), como puedes ver en el código fuente anterior hay dos etiquetas

opción_1: y opción_2:.

Las instrucciones que se escriban dentro de { y } debajo de la línea de código

switch(variable), son los diferentes bloques de instrucciones que se ejecutaran de

acuerdo al valor que contenga variable

La ejecución de la sentencia de control switch sucede así;

1. Se evalúa el contenido de variable.

2. Si el contenido de variable corresponde con alguna de las etiquetas escritas en

alguno de los casos (case), se ejecutará el bloque de instrucciones escrito después de

esta etiqueta, por ejemplo si se tiene la siguiente sentencia de control switch:


Si variable almacena un 1, este valor almacenado corresponde con la etiqueta escrita en

el primer caso.

Entonces se ejecutará la instrucción a = a+b; después de ejecutarse esta instrucción se

realiza la instrucción sentencia de control break; la cual como ya sabes, permite romper la

acción de otra sentencia de control, después de esto la siguiente sentencia en llevarse a

cabo será la que esté escrita inmediatamente después de } de la sentencia de control

switch.

Pero si variable almacena un 2, este valor almacenado corresponde con la etiqueta

escrita en el segundo caso.

Entonces no se ejecutaría el bloque de instrucciones correspondiente a la etiqueta case 1:

sino el bloque correspondiente a la etiqueta case 2: es decir la instrucción a = a-b;

después de ejecutarse esta instrucción se realiza la instrucción sentencia de control

break; y posteriormente la siguiente sentencia en desarrollarse será la que este escrita

inmediatamente después de } de la sentencia de control switch.

Pero si variable almacena un número diferente, es decir que no corresponda con ninguna

etiqueta, se ejecutaría el bloque de instrucciones escrito debajo de la etiqueta default:

ejecutándose igual que los casos anteriores.


Nota: La sentencia de control switch puede tener el número de

casos que desees.

Para ejemplificar lo anteriormente explicado se te mostrará un programa escrito en

Lenguaje C que muestra un menú de opciones en pantalla, de la siguiente forma:

Para mostrar tu nombre en pantalla presiona 1.

Para mostrar tu primer apellido en pantalla presiona 2.

Para mostrar tu segundo apellido en pantalla presiona 3.

El número que el usuario del programa tecle se almacenara en una variable llamada

opción de tipo int, y de acuerdo al valor que almacene la variable opción se ejecutará el

caso que muestre únicamente la información correspondiente.

El programa escrito en Lenguaje C que ejecuta las instrucciones mencionadas es el

siguiente:


#include <stdio.h>

#include <conio.h>


int main()

{

int opcion;

printf( " Para mostrar tu nombre en pantalla presiona 1.\n " );

printf( " Para mostrar tu primer apellido en pantalla presiona 2.\n " );

printf( " Para mostrar tu segundo apellido en pantalla presiona 3.\n " );

scanf( "%i", &opcion );

switch( opcion )

{

case 1:

printf( " RoDrIgO \n" );

break;

case 2:

printf( " AvIlEs \n" );

break;

case 3:

printf( " ViLlArEaL \n" );

break;

default:

printf( " nO ES UN CASO VALIDO\n" );

}

system ("PAUSE");

}



Si el usuario presionó 1:

Si el usuario presiono 2:

Si el usuario presiono 2:

Pero si el usuario se equivoco o a propósito escribió un 10 esto es lo que ejecutaría el

programa:


Explicación:

En este programa escrito en Lenguaje C, de acuerdo a el número que almacene la

variable de tipo entero llamada opción (su valor se solicita por teclado) se ejecutará el

bloque de instrucciones.

En este caso una función printf() que muestra en pantalla el nombre o el primer apellido o

el segundo apellido y si el numero tecleado no corresponde con ninguna etiqueta se

ejecutara el caso llamada default, el cual también muestra una cadena de texto indicando

el error.

Conclusión

La sentencia de control switch permite ejecutar un bloque de instrucciones, de varios

disponibles de acuerdo al contenido de una variable de cualquier tipo, siempre y cuando

corresponda a una etiqueta previamente escrita en alguno de los casos (case) de la

sentencia switch, de no coincidir el valor de dicha variable con ninguna etiqueta se

ejecutar un bloque de instrucciones escrito en un caso llamada default.

Esta sentencia de control puede tener el número de casos que el programador decida.

¡Bien! ¡Sigue con el último tema!


6.Sentencia de control goto

Introducción:

Con este tema, finalizas el estudio de la unidad temática III y con ella el conocimiento de

las sentencias de control.

Ahora conocerás como re-direccionar el flujo de ejecución de un programa saltando

bloques enteros de código, para realizar esto el Lenguaje C brinda al programador la

sentencia de control goto.

goto

La sentencia de control goto permite re-direccionar la ejecución del programa saltando

bloques de código hasta encontrar una etiqueta. La interpretación en español del nombre

de esta sentencia seria: “Ir a”.

A continuación se te muestran dos formas de sintaxis de esta sentencia de control:

Sintaxis 1:

Sintaxis 2:

E: /*líneas de codigo*/ goto E;

goto E; /*líneas de codigo*/ E:

Como puedes ver la etiqueta se puede escribir debajo de la instrucción goto.

Recuerda que: Una etiqueta es una instrucción que únicamente sirven como

referencia para el compilador, es decir, no se ejecutan, no muestran nada en

pantalla y no realizan ninguna operación, para nombrar una etiqueta se toman las

mismas reglas que para nombrar una variable o una constante, al final de la línea

de código de una etiqueta se escribe el operador : (dos puntos).


Descripción:

E: es una etiqueta, que sirve para ayudar a la instrucción goto a “identificar” un bloque de

código.

La sentencia de control goto indica al compilador que debe re-direccionar el flujo de

ejecución del programa, es decir, debe “irse” y ejecutar la siguiente instrucción escrita

después de la etiqueta.

La ejecución de la sentencia de control goto de los ejemplos anteriores sucede así:

En la sintaxis 1:

1. El compilador primero encuentra la etiqueta llamada E: no ejecuta ninguna acción

simplemente “nota” la existencia de esta etiqueta.

2. Ejecuta la(s) siguiente(s) instrucción(es) que se encuentren escritas después de la

etiqueta.

3. Al ejecutarse la sentencia goto el flujo de ejecución del programa será re-

direccionada, es decir se volverá(n) a ejecutar la(s) siguiente(s) instrucción(es) que

se encuentren escritas después de la etiqueta E: de forma indefinida.

En la sintaxis 2:

1. El compilador primero ejecuta la sentencia de control goto el flujo de ejecución del

programa será re-direccionado, es decir, ya no se ejecutarán las instrucciones que

se encuentran escritas en entre la instrucción goto E; y E: sino que se van a

ejecutar la(s) siguiente(s) instrucción(es) que se encuentren escritas después de la

etiqueta.

A continuación se te presenta un código fuente en el que se te explicará el funcionamiento

de esta sentencia:

#include <stdio.h>

int main()

{


goto Aqui;

printf( " AvIlEs \n" ); Re++direccionamiento, salto de la instrucción.


Aqui:

system ("PAUSE");

}

Explicación:

En este código fuente se muestra por pantalla la palabra RoDrIgO por medio de la función

printf(), enseguida se encuentra la sentencia de control goto la cual re-direcciona el flujo

de ejecución del programa y salta la siguiente línea de código: printf( " AvIlEs \n" ); para

ejecutar la instrucción escrita después de la etiqueta Aqui: que es la invocación a la

función system (“PAUSE”);

Para ejemplificar el uso de esta sentencia de control se utilizará el programa realizado en

el tema anterior, se desea que este programa se repita continuamente en forma infinita,

es decir, que se pregunte en pantalla una y otra vez la opción a elegir.




#include <stdio.h>

#include <conio.h>


int main()

{

int opcion;

INICIO: /*etiqueta*/

printf( " Para mostrar tu nombre en pantalla presiona 1.\n " );

printf( " Para mostrar tu primer apellido en pantalla presiona 2.\n " );

printf( " Para mostrar tu segundo apellido en pantalla presiona 3.\n " );

scanf( "%i", &opcion );

switch( opcion )

{

case 1:


break;

case 2:

printf( " AvIlEs \n" );

break;

case 3:

printf( " ViLlArEaL \n" );

break;

default:

printf( " nO ES UN CASO VALIDO\n" );

}

goto INICIO;/*te vas a etiqueta y nunca termina el programa*/


El resultado de editar depurar y compilar este código fuente es el siguiente.

Explicación:

Al colocar la sentencia de control goto INICIO; se le indica a la computadora que debe

volver a ejecutar todas las instrucciones que se encuentran escritas debajo de la etiqueta

llamada INICIO: de esta forma el programa se repetirá en un ciclo infinito, es decir nunca

terminara.

Muy bien, es momento de aplicar tu aprendizaje mediante la realización de una actividad

integradora, cuyo objetivo es que desarrolles software (un programa) eficiente que aplique

las sentencias de control con que cuenta el lenguaje C para dar solución a problemas de

ingeniería.

Actividad integradora 2. “Aplicando las sentencias de control”

Instrucciones:

1. Realiza un programa escrito en Lenguaje C a través de la programación

estructurada capaz de controlar el movimiento de un motor a pasos de tipo

unipolar, este motor debe mover el alerón de un avión en un rango de 90 grados,

(45 grados hacia arriba y 45 grados hacia abajo). El ángulo de giro de este motor a

pasos es de 1.8 grados por paso, este motor proporcionara el impuso necesario

para que se mueva un alerón. En el siguiente video se te muestra como debe ser el

movimiento de los alerones:


2. El usuario del programa debe escoger de un menú de opciones la dirección en que

se moverá el alerón, hacia arriba o hacia abajo. De esta forma:

3. Si se elijen las opciones 1 ó 2, el programa debe preguntar el número de pasos que

se moverá el alerón, recuerda que no deben ser mas de 45 grados (hacia arriba o

hacia abajo) los que se mueva o de lo contrario podría haber alguna avería

mecánica, por lo anterior debes asegurar que el programa no acepte un número de

pasos que sobrepase este rango de movimiento.

El programa también debe mostrar en pantalla el número de paso que se está

ejecutando y el ángulo en el que se encuentra el eje del motor, esto en la práctica

real le ayudaría al piloto para saber la posición exacta del alerón en cuestión.

Observa la siguiente imagen la cual te muestra el resultado que se obtiene.

4. Observa que se eligió la opción 1 y se decidió mover el alerón 7 pasos (esto no

sobrepasa el rango de giro del alerón), el programa únicamente ejecuta 7 pasos, y

en pantalla se muestra el ángulo de giro en el que se encuentra el eje del motor y

el dato enviado al puerto, como puedes observar los datos enviados son 1, 2, 4, 8,

1, 2 y 4 que justamente harán que el motor se mueva 7 pasos y este queda

estático a un ángulo de giro de 12.6 grados.

5. Si se escoge la opción número 2, el programa se comportará de forma similar que

en la opción número 1, con la diferencia de que ahora el alerón se moverá hacia

abajo, por este motivo los datos enviados al puerto deben ser invertidos, observa la

siguiente imagen:


6. Como puedes observar se repitió 3 veces el ciclo de 4 pasos para que el motor

girara exactamente 12 pasos, que fue lo que el usuario tecleo, el rotor del motor

giro exactamente 21.6 grados y se quedo en esta posición (estático).

7. Si después de elegir una opción el usuario desea elegir otra diferente, el programa

debe permitirlo sin tener que volver a ejecutarse, es decir, el programa después de

ejecutar los pasos indicados debe volver a mostrar el menú de opciones y permitir

se vuelva a repetir el proceso de nuevo, hasta que el usuario elija la opción

correspondiente a salir, de esta forma:


8. Como apoyo puedes descargar y probar el archivo ejecutable que da solución a

esta actividad así sabrás exactamente lo que tienes que hacer, es decir el

resultado a donde debes llegar. Da clic en el siguiente título para que se te muestre

el ejecutable.

9. Si no conoces el funcionamiento de un motor a pasos puedes revisar la información

que se te muestra a continuación, la cual te lo explicará, da clic en el siguiente

título para que te aparezca dicha información:

10. Ya que hayas terminado de leer la información referente a los motores a pasos por

favor revisa el siguiente archivo (Material de apoyo), el cual te va a ayudar mucho

para la realización de esta actividad.

Material de apoyo

Para controlar el motor a pasos unipolar es necesario que la computadora envié a la

pantalla de la computadora los datos precisos para moverlo y estos datos son los

siguientes:

1. Para que un motor se mueva un primer paso es decir únicamente se mueva 1.8

grados y se quede estático en esa posición es necesario que el programa envié un

numero 1 a la salida estándar de la computadora (la pantalla).

2. Para que el motor se mueva un segundo paso es decir, se mueva nuevamente 1.8

grados y se quede estático en esa posición (hasta ahora abra girado 3.6 grados) es

necesario que el programa envié un numero 2 a la pantalla de la computadora.


3. Para que el motor se mueva un tercer paso es decir, nuevamente se mueva 1.8

grados y se quede estático en esa posición (hasta ahora abra girado 5.4 grados) es

necesario que el programa envié un numero 4 a la pantalla de la computadora.

4. Para que el motor se mueva un cuarto paso es decir, se mueva nuevamente 1.8

grados y se quede estático en esa posición (hasta ahora abra girado 7.2 grados)

es necesario que el programa envié un numero 8 a la pantalla de la computadora.

5. Para que el motor se siga moviendo es necesario repetir los pasos anteriores,

comenzando por el punto 1, lo que haría un ciclo.

Recuerda que:

Para que un motor a pasos que posee un ángulo de giro de 1.8 grados por paso gire una

vuelta completa, éste tendrá que dar 200 pasos, en otras palabras tendrías que repetir la

siguiente secuencia 50 veces.

Numero de paso

Dato enviado

Paso 1 1

Paso 2 2

Paso 3 4

Paso 4 8

Si deseas que el motor se mueva en sentido contrario se invierte el orden de los datos

enviados, de esta forma:

Numero de paso

Dato enviado

Paso 1 8

Paso 2 4

Paso 3 2

Paso 4 1

11. Ya tengas listo tu programa, edítalo, depúralo y compílalo en el compilador Dev

C++

12. El archivo que debes enviar a tu profesor para que se te evalúe es el código

fuente, es decir el archivo con extensión .c que se creó.

13. Recuerda que si tienes alguna duda puedes pedir la ayuda de tu asesor.

Cuando tengas listo tú archivo guárdalo en tu PC y envíalo a tu profesor con tus datos en



Conclusión:

Muy bien, acabas de terminar la unidad temática III, y con ella has adquirido más

conocimientos que te van a ser útiles al realizar programas en Lenguaje C, hasta el

momento sabes cómo repetir un bloque de instrucciones determinado número de veces

utilizando a la sentencia for.

También sabes cómo repetir de forma indefinida un bloque de instrucciones en función de

una condición gracias a la sentencia while. Aunado a esto aprendiste a re-direccionar el

flujo de la ejecución de un programa con la implementación de las sentencias if else o

switch

Finalmente aprendiste a re-direccionar el flujo de ejecución de un programa saltando

líneas de código con la sentencia goto.

Solo falta una unidad para que concluyas esta unidad de aprendizaje.

¡Sigue adelante con la unidad 4!

Fundamentos de Programación Unidad IV. Estructuras de datos

133

Unidad IV. Estructuras de datos

Mapa de conceptos

Introducción:

Hasta ahora conoces los diferentes tipos de variables con que cuenta el Lenguaje C,

sabes cómo declarar variables y asignar un valor a las mismas. ¿Pero, qué pasa cuando

es necesario declarar una gran cantidad de variables?, por ejemplo si quisieras almacenar

y promediar el valor de la temperatura de cada hora del día, tendrías que declarar

veinticuatro variables, aunque no es difícil declarar una variable quizá pueda ser laborioso

declarar 24 variables y todas con distinto nombre, además de que posiblemente tal

declaración ocupará más de una línea de código.

Si lo que se desea es almacenar y promediar las temperaturas de un día pero

monitoreando esta magnitud cada minuto entonces tendrías que declarar mil

cuatrocientas cuarenta variables, imagina cuanto trabajo representaría esto, además de la

complejidad de leer y entender un código tan extenso a consecuencia de tantas

declaraciones.

El Lenguaje C brinda al programador una herramienta eficaz, flexible y sencilla para hacer

más sencilla la declaración y manejo de una gran cantidad de variables del mismo tipo,

esta herramienta es conocida con el nombre de arreglos (arrays), y esto es lo que

veremos en esta unidad.

1. Arreglos (Arrays) Unidimensionales

Los arreglos unidimensionales son un conjunto de variables de un mismo tipo (tipo de

variable) cuyo nombre se diferencia en el índice (números entre corchetes). Por ejemplo

el arreglo: numero[20] y numero[21]. Estos son dos elementos de un mismo arreglo,

ambos se llaman numero[ ] pero como en un mismo código fuente no puede haber dos

variables (en este caso los elementos del arreglo) con el mismo nombre es por esto que


se diferencian por el índice, es decir el numero entre los corchetes [ y ]. Entonces uno se

llama numero[] con índice veinte y el otro numero[] con índice veintiuno.

Nota: Los arreglos también son conocidos con los nombres de arrays,

matrices o vectores. Sin embargo, en esta unidad de aprendizaje, se va a

usar el término arreglo.

Esta es la sintaxis necesaria para declarar un arreglo: Tipo nombre [

tamaño ];

Descripción:

Tipo: es cualquier tipo de variable, por ejemplo char, int, float o doublé.

nombre: corresponde al nombre del arreglo, este nombre obedece a las mismas reglas

que el nombre de una variable o el de una constante.

[tamaño]: Lo encerrado entre corchetes (índice) es el tamaño del arreglo, es decir el

número de variables que forman al arreglo, este puede estar determinado por el valor que

almacena una variable o una constante y debe de ser un número entero, es posible omitir

en la declaración de un arreglo el tamaño y posteriormente se puede asignar, por ejemplo

en tiempo de ejecución, es decir cuando el programa está funcionando.

Se te muestra un ejemplo en el que se declara un arreglo de números enteros llamado

num con tres elementos, lo cual se hace de la siguiente forma:

int num[3];

Con esta línea de código se están declarando tres variables de tipo entero llamadas

num[0], num[1] y num[2].

Una alternativa para realizar esta misma declaración es la siguiente:

Int r =3;

int num[r];

En este caso también se declaro un arreglo de tres variables de tipo entero llamadas

num[0], num[1] y num[2]. Observa que el tamaño del arreglo está determinado por el valor

de la variable r.

En el Lenguaje C, todos los arreglos usan cero como índice para el primer elemento. Por

tanto, el ejemplo anterior declara un arreglo de enteros con tres elementos desde num[0]

hasta num[2].


Siguiendo con el ejemplo anterior, para asignar un valor a un elemento de un arreglo se

hace lo siguiente:

num[2] = 15; /* Asigna 15 al 3er elemento del arreglo llamado num*/

Con este arreglo se obtendrán dos elementos: num[0] y num[15], como puedes observar

el valor de 15 se le dio al tercer elemento. Recuerda que existe el elemento num[0],

num[1] y num[2], ya que los inician su índice desde cero

Otro ejemplo de cómo asignar valores a los elementos de un arreglo es el siguiente:

int temp[10] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25 };

Ahora el primer elemento que será temp[0] almacenará un 15. El elemento 1 (el segundo)

almacenara un 18 y el último elemento es decir, el decimo almacenara un 25. Como

puedes observar se utilizaron los operadores { } (llaves de apertura y cierre) para realizar

la asignación, además de que los números asignados están separados por el operador

coma (,).

Para acceder al valor almacenado en un elemento de un arreglo y posteriormente

guardarlo en otra variable (que no sea un elemento de un arreglo) se puede realizar lo

siguiente:

int num;

int listA[3];

listA[2] = 3;

num = listA[2]; /* Asigna el contenido del 3er elemento a la variable num es decir un

número 3 se almacena en la variable num*/

Para aclarar lo anteriormente explicado, analiza el siguiente código fuente, el cual vas a

utilizar en la siguiente actividad que realices:



Explicación:

En la primer línea de código, dentro de la función principal main() se declaro una variable

llamada hora de tipo entero de esta forma: int hora; Enseguida se encuentra la siguiente

línea de código:

int temp[24]={15,18,20,23,22,24,22,25,26,25,24,22,21,20,18,17,16,17,15,14,14,14,13,12};

La línea de código anterior declara un arreglo de tipo entero (tipo de variable) llamado

temp[ ], el tamaño de este arreglo es veinticuatro. (Este arreglo declara 24 variables de

tipo int llamadas temp[ ] diferenciadas por el índice) y enseguida por medio del operador

de asignación ( = ) se almacenan 24 constantes (números) a cada uno de los elementos

del arreglo, es decir el primer elemento del arreglo temp[0] almacena un quince, el

segundo elemento temp[1] almacena un dieciocho, el tercer elemento temp[2], almacena

un 20 y así sucesivamente hasta el último elemento del arreglo temp[23] que almacena un

#include <stdio.h>


int main ()

{

int hora;

int

temp[24]={15,18,20,23,22,24,22,25,26,25,24,22,21,20,18,17,16,17,15,14,14,14,1

3,12};

for (hora=0 ; hora<24 ; hora++ )

{

printf( "La temperatura a las %i hrs, era de %i grados.\n", hora, temp[hora] );

}

system ("PAUSE");

}


doce, observa que se utilizaron los operadores { y } para realizar la asignación, además

de que los números asignados están separados por el operador coma ( , ).

Después de asignar un valor a cada uno de los elementos del arreglo se utiliza la

sentencia de control for para mostrar por pantalla el contendido (lo que almacena) de

cada uno de los elementos del arreglo, observa que la sentencia de control for ejecutara

24 veces la función printf() que se encuentra entre { y } de la sentencia for, ya que así lo

indica la condición hora<24; La función printf() muestra la hora y el contenido de cada uno

de los elementos que componen el arreglo, uno por uno es decir primero muestra el

contenido del elemento cero temp[0] (se mostrara un numero quince en pantalla),

después se mostrara en pantalla el contenido del segundo elemento temp[1] (un numero

dieciocho) y así sucesivamente hasta mostrar el contenido del último elemento. Observa

la siguiente línea de código que pertenece al código fuente anterior:

printf( "La temperatura a las %i hrs, era de %i grados.\n", hora, temp[hora] );

¿Por qué el primer elemento en mostrarse en pantalla es el elemento temp[0]?

Respuesta:

Observa el siguiente fragmento de código fuente escrito en la función printf() de este

código fuente:

\n", hora, temp[hora] );

Nota que el número de elemento que se mostrara en pantalla está determinado por el

valor de una variable llamada hora de tipo entero, esta variable fue iniciada con cero; for

(hora=0 ; hora<24 ; hora++ ) por lo tanto la primera vez que se ejecuta printf() el número

de elemento que se mostrara en pantalla será temp[0].

Después de ejecutarse una vez la función printf() se incrementa la variable hora en una

unidad, (si tienes dudas de esto puedes revisar sentencia de control for vista

anteriormente) por lo tanto la siguiente vez que se ejecute printf() el contenido del

elemento del arreglo que se mostrara en pantalla es el que almacena temp[1]. Y así se

irán mostrando uno a uno el contenido de cada uno de los elementos del arreglo, hasta

que deje de cumplirse la condición de la sentencia de control for.

Ya sabes lo que es un arreglo y como funciona, ahora realiza la siguiente actividad en la

que pondrás en práctica la realización de un programa que implemente arreglos a través

de la programación estructurada.


Actividad de aprendizaje 13. “Arreglos unidimensionales”

Instrucciones:

1. Edita, depura y compila el código fuente que se te acaba de explicar, en el cual

agregaras la siguiente característica: el tamaño del arreglo se tiene que ingresar

por el teclado de la computadora en tiempo de ejecución.

2. El valor que almacenará cada uno de los elementos del arreglo también se debe

introducir por el teclado y cuando se haya introducido el último valor del último

elemento, se mostrará en pantalla la información introducida, para corroborar que

se almaceno correctamente en cada uno de los elementos del arreglo.

3. Ya que hayas editado, depurado, compilado y funcione correctamente el programa

sube a la plataforma para su evaluación el archivo del código fuente, es decir el

archivo con extensión .c que se creó.

Recuerda que si te surgen dudas debes consultar a tu asesor.



Muy bien, continúa practicando la implementación de arreglos en un programa realizando

la siguiente actividad:

Actividad de aprendizaje 14. “Mas arreglos”

Instrucciones: Para realizar correctamente el programa es necesario que conozcas que es un altímetro, como funciona y para qué sirve, dá clic sobre el siguiente hipervínculo para que se te despliegue esta información:

En caso de que tengas problemas para descargar el archivo, consulta la siguiente dirección: http://www.manualvuelo.com/INS/INS23.html

1. Imagina que eres el encargado de realizar un programa que monitorea, almacena y realiza la media aritmética del muestreo realizado al altímetro de un avión tipo Cessna 500 Citatio, en vuelo.

2. El programa que vas a realizar debe monitorear las mediciones que realiza el altímetro instalado en el avión, como no cuentas con un altímetro y la interfaz electrónica para conectar este instrumento de medición a la computadora, el usuario del programa simulará estas lecturas introduciendo el valor de la altitud por el teclado.

http://www.manualvuelo.com/INS/INS23.html


3. Además de monitorear, almacenar y obtener la media aritmética de estas lecturas el programa debe mostrar en pantalla si la altitud de vuelo es apropiada o no, (toma como referencia 4500 ft a 5000ft como una altitud apropiada). Si en algún momento la altitud introducida por el usuario es menor que 4500 ft el programa debe mostrar un mensaje en la pantalla de la computadora indicando que la altitud es más baja que lo permitido. Ahora bien si en algún momento la altitud introducida por el usuario del programa es superior a 5000 ft el programa mostrara un mensaje en pantalla indicando que la altitud es más alta que lo permitido.

4. El programa únicamente monitoreara y almacenara 10 lecturas, después de almacenar y mostrar el mensaje correspondiente a la última lectura se desplegarán en pantalla los valores introducidos previamente para corroborar que fueron almacenados correctamente en el arreglo, es decir el contenido de las diez variables que almacenan estos valores, además se debe mostrar en pantalla la media aritmética de dichas mediciones, después de mostrar esta información el programa se repetirá indefinidamente.

Ya que hayas editado, depurado, compilado y funcione correctamente el programa súbelo

a la plataforma para su evaluación el archivo del código fuente, es decir el archivo con

extensión .c que se creó.

Cuando tengas listo tú archivo guárdalo en tu PC y envíalo a tu profesor con tus datos en


Conclusión:

Un arreglo que también es conocido con el nombre de array, matriz o vector es un

conjunto de variables del mismo tipo (tipo de variable) cuyo nombre se diferencia en el

índice.

Su tarea es declarar más de una variable del mismo tipo en una sola línea, para asignar o

acceder a la información que almacena cada uno de los elementos de un arreglo el

programador puede hacer uso de las sentencias de control for, while o Do while.

Una característica muy importante de los arreglos es que al declararlos es posible omitir el

tamaño que tendrá el arreglo para después indicarlo por medio de una variable, incluso en

tiempo de ejecución del programa.

¡Buen trabajo, sigue adelante!


2. Arreglos de caracteres (strings)

Introducción:

Hasta este momento has trabajado con frases o palabras mostradas por pantalla

auxiliándote de la función printf(), pero qué sucede si es necesario introducir y almacenar

una palabra o frase tecleada por el usuario ¿es posible?.

Recuerda que el tipo de variable char permite almacenar un solo carácter por cada

variable, entonces, si por ejemplo, se quisiera almacenar el nombre “Emanuel” sería

necesario declarar siete variables de tipo char para así almacenar cada uno de los siete

caracteres que forman este nombre.

Imagina cuantas variables tendrías que declarar para almacenar el nombre completo de

una persona incluyendo los apellidos o si quisieras almacenar el texto de una carta o un

escrito.

¿Ya sabes cuál es la herramienta que utilizaras para resolver este problema? Por

supuesto, los arreglos.

Los arreglos de caracteres son un conjunto de variables de un mismo tipo (tipo de variable

char) cuyo nombre se diferencia en el índice. Por ejemplo el arreglo: nombre[7] y

nombre[2].

Estos son dos elementos de un mismo arreglo, ambos se llaman nombre[ ] pero como en

un mismo código fuente no puede haber dos variables (en este caso los elementos del

arreglo de caracteres) con el mismo nombre es por esto que se diferencian por el índice,

es decir el numero entre [ y ].

Entonces uno se llama nombre[ ] con índice siete y el otro nombre[ ] con índice dos.

Al declarar más de una variable de tipo char es posible almacenar una palabra o una frase

dentro de un arreglo (cada elemento del arreglo almacena un carácter).

Nota: Los arreglos de caracteres también son conocidos con el nombre de

strings o cadenas de texto. Sin embargo, en esta unidad de aprendizaje,

vamos a usar el término arreglo de caracteres.

Esta es la sintaxis necesaria para declarar un arreglo de caracteres: char nombre [

tamaño ];


Descripción:

char: es el tipo de variable capaz de almacenar un carácter dentro de una variable.

nombre: corresponde al nombre del arreglo de caracteres, este nombre obedece a las

mismas reglas que el nombre de una variable o el de una constante.

[tamaño]: es el tamaño del arreglo de caracteres, es decir, el número de variables que

forman al arreglo.

El tamaño del arreglo de caracteres puede estar determinado por el valor que almacena

una variable o una constante, el tamaño de un arreglo de este tipo debe de ser un número

entero. Es posible omitir en la declaración de un arreglo de caracteres el tamaño, para

posteriormente asignarlo, por ejemplo, en tiempo de ejecución, es decir, cuando el

programa está funcionando.

A continuación se te muestra un ejemplo en el que se declara un arreglo de caracteres

llamado nom con tres elementos, lo cual se hace de la siguiente forma:

char nom[3];

Con esta línea de código se está declarando a tres variables de tipo char llamadas

nom[0], nom[1] y nom[2].


Int r =3;

char nom[r];

En este caso también se declaró un arreglo de tres variables de tipo char llamadas

nom[0], nom[1] y nom[2]. Observa que el tamaño del arreglo está determinado por el valor

de la variable r.

Recuerda que en el Lenguaje C, todos los arreglos usan cero como índice para el primer

elemento. Por tanto, el ejemplo anterior declara un arreglo de caracteres con tres

elementos desde nom[0] hasta nom[2].


Siguiendo con el ejemplo anterior, dos formas de asignar un valor a un elemento de un

arreglo son las siguientes:

nom[2] = ‘A’; /* Asigna el carácter A al 3er elemento del arreglo llamado nom*/

Observa que para realizar la asignación del carácter A se utilizó al operador comilla

simple (‘) en lugar del operador comilla doble (“), esto se debe a que es un solo carácter el

que se está asignando.

nom[2] = 65; /* Asigna el carácter A al 3er elemento del arreglo llamado nom ya

que el código ASCII de la letra A es 65 */

Ahora se te mostrará cómo asignar varios valores a los elementos de un arreglo:

char nom[7] = { 'E','m','A','n','U','e','L' };

En este arreglo el primer elemento que es nom[0] almacenará un carácter E.

El segundo elemento que es nom[1] almacenará un carácter m,

El tercer elemento que es nom[2] almacenará un carácter A

Y así sucesivamente hasta llegar al séptimo elemento que es nom[6] que almacenará un

carácter L.

Para acceder al valor almacenado en un elemento de un arreglo de caracteres y

almacenarlo en otra variable (que no es un elemento de un arreglo) se puede realizar lo

siguiente:

char nom;

char listA[3];

listA[2] = ‘x’;

nom = listA[2]; /* Asigna el contenido del 3er elemento a la variable nom es decir el

carácter x se almacena en la variable nom*/

A continuación se te muestra un código fuente en el cual se utiliza un arreglo, analízalo:



1er sentencia for

2da sentencia for

3er sentencia for


Explicación:

La primer línea de código escrita después de la { de la función principal main() declara

una variable llamada h de tipo entero de esta forma int h; la siguiente línea de código

declara y define un arreglo de caracteres llamado nom[ ] de tamaño siete, de esta forma:

char nom[7] = { 'E','m','A','n','U','e','L' };

Al primer elemento que conforma el arreglo de caracteres, es decir a nom[0] se le asigna

el carácter E, al segundo elemento que es nom[1] se le asigna el carácter m, así hasta

almacenar en el último elemento de el arreglo el carácter L, es decir, en nom[6] se

almacenó el carácter L.

Enseguida se encuentra la primera sentencia de control for de este código fuente, de esta

forma:

for (h=0 ; h<7 ; h++ )

{

printf( "El elemento %i del arreglo, almacena este carcater %c.\n", h, nom[h] );

}

Esta sentencia de control for, mostrará en pantalla el contenido de cada uno de los

elementos del arreglo, uno por uno, desde el elemento cero hasta el elemento seis

mostrando en pantalla el siguiente resultado:

¿Por qué se muestran

estos caracteres en

pantalla?

Respuesta.

Al momento de declarar el arreglo de caracteres éste se inicio almacenando en cada uno

de sus elementos los caracteres que se muestran en pantalla. Observa que dentro de la

función printf() se colocó el modificador %c, el cual indica a esta función que el tipo de

variable que se mostrará en pantalla es de tipo char.


Ahora observa las siguientes líneas de código del programa:

En la primer línea se utilizó a la función printf() para mostrar en pantalla una cadena de

texto que da la siguiente indicación: “Ahora introduce un nombre con menos de 7

caracteres”

Para posteriormente por medio de la función scanf() introducir esta información por la

entrada estándar de la computadora (el teclado), y guardar esta información en el arreglo

llamado nom[ ].

Observa que en esta ocación no se utilizo al operador dirección de (&) ni los operadores [

y ] solamente se coloco el modificador de formato %s que sirve para indicar a la función

scanf() que la información tecleada se almacenará en un arreglo de caracteres.

La segunda sentencia for que observas enseguida es la encargada de mostrar

nuevamente en pantalla el contenido de todos los elementos del arreglo de caracteres:

Cuyo resultado en pantalla es el siguiente:

Como puedes observar, se tecleo la palabra “Josue”, esta palabra tiene cinco caracteres y

la sentencia for mencionada anteriormente muestra la nueva información que almacena el

arreglo (la información se reescribió, perdiéndose la anterior información almacenada, es

decir EmAnUeL).

printf( "\n\n Ahora introduce un nombre con menos de 7 caracteres: ");

scanf( "%s", nom );

for (h=0 ; h<7 ; h++ )

{

printf( "El elemento %i del arreglo, almacena este caracter %c.\n", h, nom[h] );

}


Nota que el quinto elemento muestra un espacio en blanco en la pantalla.

¿Tú crees que se haya tecleado ese espacio en blanco?

Respuesta.

No, después de teclear el ultimo carácter de la palabra Josue se presionó la tecla enter, al

presionar esta tecla se añade un carácter especial al arreglo de caracteres, el carácter de

fin de cadena \0, se lee diagonal invertida cero, que sirve para indicar a la función scanf()

que ya no hay más caracteres que almacenar, este carácter se almacena precisamente

en el elemento número cinco que es nom[4]. Este carácter especial no es imprimible en

pantalla por eso se observa un espacio en blanco.

Observa que también en el último elemento, es decir, el séptimo (nom[6]) se muestra que

aun existe el carácter L, de la palabra EmAnUeL, esto se debe a que la palabra josue

está formada únicamente por cinco caracteres y uno más el carácter de fin da cadena (\0),

que se almacenaron en el arreglo de caracteres solamente ocuparon 6 elementos y no

siete, por lo tanto el último elemento del arreglo nom[6] no fue reescrito ni borrado,

permaneció intacto.

Por último encontrarás las siguientes líneas de código:

Estas líneas de código realizan exactamente el mismo trabajo que las anteriormente

explicadas, con la única diferencia de que ahora el nombre tecleado está compuesto por

más de siete caracteres, el nombre teclado es BENJAMIN, el resultado en pantalla de

estas líneas de código es el siguiente:

printf( "\n\n Ahora introduce un nombre con mas de 7 carcateres: ");

scanf( "%s", nom );

for (h=0 ; h<7 ; h++ )

{

printf( "El elemento %i del arreglo, almacena este caracter %c.\n", h, nom[h] );

}


Como puedes observar no se almaceno el último carácter del nombre BENJAMIN, la N ya

que no hay un elemento (una variable) para poder realizar esta operación, este carácter

se pierde.

Conclusión:

Un arreglo de caracteres que también es conocido con el nombre de array, matriz o vector

es un conjunto de variables del mismo tipo (tipo de variable char) cuyo nombre se

diferencia en el índice.

Su tarea es declarar más de una variable de tipo char en una sola línea, para asignar o

acceder a la información que almacena cada uno de los elementos de un arreglo de

caracteres el programador puede hacer uso de las sentencias de control for, while o Do

while.



tiempo de ejecución del programa.

¡Muy bien hecho, sigue adelante!


3. Arreglos (Arrays) Bidimensionales

Introducción:

Hasta este momento conoces lo sencillo y útil que es utilizar arreglos cuando es

necesario manipular más de una variable del mismo tipo.

Pero qué sucede si se necesitan utilizar un número importante de variables, por ejemplo:

Si fuera necesario almacenar las temperaturas de todo un día, monitoreando esta

magnitud cada hora, los siete días de la semana.

Con lo aprendido hasta el momento la solución a esta situación sería declarar 7 arreglos

con veinticuatro elementos cada uno, aunque esta tarea no es difícil, sí es muy laboriosa,

tales declaraciones ocuparán varias líneas de código restando legibilidad al código fuente.

Para estos casos especiales el Lenguaje de programación C provee al programador la

capacidad de declarar arreglos multidimensionales, en esta unidad de aprendizaje

estudiarás únicamente los arreglos bidimensionales.

Arreglos bidimensionales:

Los arreglos bidimensionales son un conjunto de variables del mismo tipo (tipo de

variable) agrupadas en filas y columnas, cuyo nombre se diferencia en el índice (números

entre corchetes).

Esta es la sintaxis necesaria para declarar un arreglo bidimensional:

Tipo nombre [ filas ][ columnas ];

1 Tipo: es cualquier tipo de variable, por ejemplo char, int, float o doublé.

2 Nombre: corresponde al nombre del arreglo, este nombre obedece a las mismas reglas


3 [filas]: Lo encerrado entre corchetes (índice) es el tamaño de la primera dimensión del

arreglo, es decir el número de filas (variables) que forman la primera dimensión del

arreglo, este puede estar determinado por el valor que almacena una variable o una

constante y debe de ser un número entero, es posible omitir en la declaración de un

1

2

3

4


arreglo el tamaño y posteriormente se puede asignar, por ejemplo en tiempo de

ejecución, es decir, cuando se ejecuta el programa.

4 [columnas]: Lo encerrado entre corchetes (índice) es el tamaño de la segunda

dimensión del arreglo, es decir el número de columnas (variables) que forman la segunda

dimensión del arreglo, este puede estar determinado por el valor que almacena una

variable o una constante y debe de ser un número entero, es posible omitir en la

declaración de un arreglo el tamaño y posteriormente se puede asignar. por ejemplo en

tiempo de ejecución.

Por ejemplo, para declarar un arreglo bidimensional de números enteros llamado num con

tres filas y dos columnas se hace de la siguiente forma:

intnum[3]num[2];

Con esta línea de código se están declarando seis variables de tipo entero llamadas

num[0][0], num[0][1], num[1] [0], num[1][1], num[2][0] y num[2][1].

Nota: En el Lenguaje C, todos los arreglos bidimensionales usan cero

como índice para el primer elemento.


int r =3,m=2;

intnum[r][m];

En este caso también se declaró un arreglo de seis variables de tipo entero.

Observa que el tamaño del arreglo está determinado por el valor de la variable r y la

variable m.

Enseguida se muestra una representación gráfica del conjunto de variables que forman al

arreglo bidimensional.

Columna 0 Columna 1

num[0][0] num[0][1]

num[1][0] num[1][1]

num[2][0] num[2][1]

Fila 0 Fila 1 Fila 2


Como puedes ver, en esta representación se indican tanto filas como columnas del

arreglo bidimensional, la lógica es la siguiente:

En el primer elemento: num[0] [0], el primer índice pertenece a la fila 0 y el segundo índice pertenece a la columna 0. En el segundo elemento: num[0] [1], el primer índice pertenece a la fila 0 y el segundo índice pertenece a la columna 1. En el tercer elemento: num[1] [0], el primer índice pertenece a la fila 1 y el segundo índice pertenece a la columna 0. En el cuarto elemento: num[1] [1], el primer índice pertenece a la fila 1 y el segundo índice pertenece a la columna 1. En el quinto elemento: num[2] [0], el primer índice pertenece a la fila 2 y el segundo índice pertenece a la columna 0. En el sexto elemento: num[2] [1], el primer índice pertenece a la fila 2 y el segundo índice pertenece a la columna 1. Si el tamaño del arreglo bidimensional fuera mayor se seguiría la misma lógica. Un ejemplo de cómo asignar un valor a un elemento de un arreglo bidimensional es el

siguiente:

num[0][0] = 15; /* Asigna 15 al 1er elemento del arreglo bidimensional llamado

num*/

Nota: El elemento llamado num[0] [0] es únicamente una variable con una dirección de memoria, por lo tanto, solamente puede almacenar un valor.

Otro ejemplo de cómo asignar valores a los elementos de un arreglo bidimensional es el

siguiente:

int t[2][2] = { { 15, 17 }, { 18, 20 } };


Ahora el primer elemento que será t[0][0] almacenará un 15.

El segundo elemento t[0][1] almacenará un 17, el tercer elemento t[1][0]almacenará un 18

y el cuarto elemento t[1][1] almacenará un 20.

Como puedes observar se utilizaron los operadores { } para realizar la asignación,

además de que los números asignados están separados por el operador coma (,).

Lo siguiente, es la representación gráfica del arreglo:

num[0][0]=15 num[0][1]=17

num[1][0]=18 num[1][1]=20

Para acceder al valor almacenado en un elemento de un arreglo bidimensional y

almacenarlo en otra variable (que no sea un elemento de un arreglo) se puede realizar lo

siguiente:

Para aclarar lo anteriormente explicado analiza el siguiente código fuente, el cual vas a

retomar posteriormente para realizar una actividad integradora.

Este código fuente declara un arreglo bidimensional de siete filas y veinticuatro columnas

con lo cual se declaran ciento sesenta y ocho variables, para almacenar la temperatura

de las veinticuatro horas de un día por toda una semana, es decir, por siete días.

Después de almacenar esta información el programa calcula el promedio de la

temperatura de toda la semana y lo muestra por pantalla.


Explicación:

En la primer línea de código después de la llave de apertura de la función main() se

declara un arreglo bidimensional llamado temp de ocho filas y veinticuatro columnas, no

se asigno ningún valor a los ciento sesenta y ocho elementos que forman este arreglo

bidimensional, quedando de la siguiente forma:

En las siguientes dos líneas de código se declararon tres variables la primera de tipo float

llamada media a la cual se le asigno un valor de cero, las siguientes dos variables

declaradas son de tipo entero sus nombres son hora y día, estas dos variables no fueron

iniciadas en esta línea sino más abajo dentro de las dos sentencias de control for.

Enseguida encontramos un par de sentencias de control for anidadas, es decir, una

dentro de la otra, la primera es la que a continuación se muestra:

Esta sentencia de control for, se ejecutara siete veces de acuerdo a la condición de que:

dia<8 ;

Por esto se ejecutará únicamente siete veces (los 7 días de una semana) ya que la

variable día se inicio con uno.

Dentro de esta sentencia de control for se encuentra otra sentencia for, la cual se muestra

enseguida:

Como puedes observar esta sentencia repetirá el código escrito entre { y } veinticuatro

veces (las 24 horas que forman un día), entonces esta última sentencia de control (for) se

floattemp[7][24];

for( dia=1 ; dia<8 ; dia++ )


repetirá siete veces, con lo cual se solicitara la temperatura de los siete días de la semana

con sus veinticuatro horas.

El código escrito entre { y } se encarga de solicitar la temperatura del día 1 a las 0 horas,

ya que estos son los valores con que se iniciaron las variables día y hora

respectivamente.

La función scanf( )es la encargada de solicitar por el teclado la temperatura y guardar esta

información en cada uno de los elementos del arreglo bidimensional, el primer elemento

donde se guarda la primera lectura es: temp[1][0], el segundo se guarda en el elemento

temp[1][1], y así sucesivamente hasta el último.

Observa que los índices que establecen el número de elemento están determinados por

las variables día y hora.

Para poder calcular el promedio semanal de la temperatura es necesario sumar cada uno

de los valores introducidos para realizar esta operación se implemento la siguiente línea

de código:

En la variable llamada media de tipo float se van almacenando y sumando el valor

guardado en cada uno de los elementos del arreglo bidimensional.

Por último, después de que se ejecutaron por completo las dos sentencias de control for

encontramos las siguientes líneas:

La primera línea se encarga de calcular el promedio y la segunda de mostrar este

resultado en pantalla.

Conclusión

Los arreglos bidimensionales son un conjunto de variables del mismo tipo, agrupadas en

filas y columnas, cuyo nombre se diferencia en el índice.

La implementación de un arreglo bidimensional permite al programador manejar una gran

cantidad de variables del mismo tipo, con mayor claridad que los arreglos

unidimensionales.

¡Buen trabajo, cada vez falta menos para terminar! ¡Sigue adelante!

media = media +temp[dia][hora];

media = media/168;

printf( "El promedio de la temperatura en toda la semana es: %f\n ", media );


4. Apuntadores (Punteros) Concepto

Introducción:

En el momento en el cual se declara una variable, el Sistema Operativo reserva un

espacio de la memoria RAM de la computadora para almacenar información, el tamaño de

este espacio depende del tipo de variable que se esté declarando, ya que, como se vio

anteriormente, los distintos tipos de variable con que cuenta el Lenguaje C tienen

diferentes tamaños.

En ocasiones el programador necesitará además de saber la dirección de memoria (es

decir en que parte de la memoria RAM se encuentra almacenada la variable declarada),

guardar la dirección de memoria de una variable.

Las direcciones de memoria de una variable deben almacenarse en otras variables

llamadas punteros o apuntadores.

Apuntadores:

Antes de explicarte lo que es un apuntador es necesario que sepas qué es la dirección de

memoria de una variable, ya que es indispensable para comprender el funcionamiento de

un apundador.

Dirección de memoria de una variable:

La dirección de memoria de una variable es el lugar exacto en donde se encuentra

almacenada (guardada) la información de una variable en la memoria RAM de la

computadora. Esta dirección es un número escrito en el sistema de numeración

hexadecimal, por ejemplo, los números: 0022FF74 y 0011FA12 son direcciones de

memoria de dos variables.

Al momento de declarar una variable, el preprocesador y el SO son los encargados de

asignar el lugar en la memoria RAM de la computadora para almacenar la información de

la variable, el lugar asignado depende del espacio disponible.

Se te muestra un ejemplo de la representación de la memoria RAM.

Cada casilla representa una dirección de memoria compuesta por un byte (8 bits) y cada

número de la izquierda es su dirección de memoria.

La primera casilla es la posición 00001 de la memoria.

La segunda casilla la posición 00002 y así sucesivamente.


Ejemplo:

Supón que ahora se declara una variable de tipo char: llamada numero, a la cual se le

asigna un valor de cuarenta y tres, de esta forma:

Int numero =43;

El contenido de esta variable se guardara en la posición 00003 de la memoria RAM y ya

no puede ser asignada a otra variable porque queda reservada.

Observa la siguiente imagen, en ella se representa esto que se te acaba de explicar:

Para saber cuál es la dirección de memoria de una variable puedes utilizar el operador

dirección de (&), el cual devuelve la dirección de memoria de su operando (es decir la

variable de la que se desea obtener la dirección).

Para aclarar esto enseguida se te muestra un ejemplo del código fuente necesario para

obtener la dirección de memoria de una variable y mostrarla en pantalla.

#include <stdio.h>


int main()

{

int numero = 43;

printf( "Dirección de numero = %p, valor de numero = %i\n", &numero, numero );

system ("PAUSE");

}



Explicación:

La primera línea de código escrita después de la declaración y definición de la función

principal del programa, declara una variable de tipo entero llamada numero, a la cual se le

asigna el valor de cuarenta y tres.

Enseguida se encuentra escrita la siguiente línea de código:

La función printf() se encarga de mostrar en pantalla tanto la dirección como el contenido

de la variable llamada numero, recuerda que no es lo mismo la dirección de la variable,

que en este caso es: 0022FF44 y el contenido de la variable (la información que

almacena), que en este caso es el numero 43.

Observa el siguiente fragmento de la línea de código anterior:

En él puedes observar la implementación del operador dirección de (&), al colocar delante

de este operador el nombre de la variable número, éste operador devolverá la dirección

de memoria de esta variable, la función printf() recibe el valor devuelto por el operador

dirección de (& y posteriormente )se encarga de mostrar en pantalla esta dirección.

Después muestra el contenido de la variable llamada número.

Observa que dentro de la función printf() se colocó el modificador de formato %p, el cual

sirve para mostrar direcciones de memoria por pantalla.

Ahora que sabes lo que es una dirección de memoria, se te explicara lo que son los

apuntadores:

Un apuntador es una variable capaz de almacenar la dirección de memoria de una

variable.

Nota: El apuntador almacena la dirección de memoria de una variable, no

el contenido de la variable.


&numero, numero );


La sintaxis para declarar un apuntador es la siguiente:

tipo *nombre;

Tipo: es cualquier tipo de variable, por ejemplo char, int, float o doublé. Depende del tipo

de datos de la variable de la cual se pretenda almacenar su dirección de memoria. Por

ejemplo si se desea almacenar la dirección de una variable de tipo char, el apuntador que

almacene la dirección de esta variable debe ser también de tipo char.

*: El operador asterisco indica la declaración de un apuntador, se escribe antes del

nombre del apuntador sin espacios en blanco.

Nombre: corresponde al nombre del apuntador, este nombre obedece a las mismas reglas


Los apuntadores tienen otras utilidades, por ejemplo:

Nos permiten pasar argumentos (o parámetros) a una función y modificarlos.

También permiten el manejo de cadenas de caracteres y de arreglos.

Otro uso importante es que permiten acceder directamente a la pantalla, al

teclado y a todo el hardware de la computadora,

Permiten también la posibilidad de acceder (leer o modificar) a esas

posiciones de memoria.

Nota: Para acceder a la información almacenada en una dirección de

memoria a través de un apuntador, se usa el operador asterisco (*), debe

escribirse antes del nombre del apuntador sin espacios en blanco, este

operador no se debe confundir con el operador de la multiplicación.

A continuación se te muestra un código fuente en el que se utilizan apuntadores,

analízalo:



Explicación:

En la primer línea de código, después de la declaración y definición de la función de este

programa (la función main()) se declaró una variable llamada numero de tipo entero a la

cual se le asigna el valor de cuarenta y tres.

Enseguida se encuentra la línea de código siguiente:

int *punt;

Con esta línea de código se declara un apuntador llamado punt capaz de almacenar la

dirección de memoria de una variable de tipo entero.

#include <stdio.h>


int main()

{

int numero = 43;

int *punt; /*Declaración del apuntador*/

punt = &numero; /*Almacenamos la dirección en el puntero*/


*punt = 30; /*Guardamos 30 en la dirección de memoria que guarda el apuntador*/

printf( "Direccion de numero = %p, valor de numero = %i\n", &numero, numero );

system ("PAUSE");

}



punt = &numero;

El operador dirección de (&) devuelve la dirección de memoria de la variable llamada

número, este valor devuelto se asigna (guarda) en el apuntador llamado punt.

Observa que en esta asignación no se utilizó al operador asterisco ( * ).

En este momento se dice que punt “apunta” a la variable número ya que almacena su

dirección de memoria.

Enseguida la función printf( ) se encarga de mostrar en pantalla, tanto la dirección de

memoria de la variable número como su contenido, que en este caso son: 0022FF74 y 43

respectivamente.

Después está escrita la siguiente línea de código:

*punt = 30;

Con esta línea de código se guarda el valor de treinta dentro de la dirección de memoria

que almacena el apuntador punt, es decir, dentro de número, se está accediendo a la

variable número sin “tocarla”, es decir, sin realizar una asignación directa, por ejemplo:

numero =30; gracias al apuntador punt se está modificando el contenido de una variable

sin utilizar su nombre directamente.

El cuarenta y tres que se había guardado previamente en esta misma variable fue

reemplazado y en su lugar se guardó un treinta.

Para corroborar que las líneas de la explicación anterior son ciertas por medio de la

función printf() se volvió a mostrar por pantalla tanto la dirección de memoria de numero

como su nuevo contenido.

Puedes observar que la dirección de memoria no cambio, esto es porque se trata de la

misma variable, pero el contenido que almacenaba número si cambio (por medio del

apuntador).


Conclusión.

Un apuntador es una variable capaz de almacenar la dirección de memoria de otra variable, cuando un apuntador almacena una dirección de memoria se dice que éste apunta a la variable de la cual almacena su dirección, por medio de un apuntador es posible acceder a los datos almacenados en una dirección de memoria (leerlos o modificarlos).

¡Muy bien, continua con tus temas!


5. Operadores con apuntadores

Introducción.

Como ya se mencionó anteriormente los apuntadores permiten acceder a la información

que se almacena en otra variable por medio de su dirección de memoria, para

potencializar esta tarea los apuntadores pueden utilizarse en conjunto con los operadores

con los que cuenta el Lenguaje de programación C a continuación se muestra cómo

hacerlo.

Ejemplo. Una comparación con apuntadores

El Lenguaje de programación C permite utilizar en conjunto a los distintos operadores

(Operadores de relación, de comparación, a nivel de bits, lógicos, etc.), con los

apuntadores.

Observa y analiza el siguiente código fuente, en el se implementan tanto operadores de

relación como apuntadores junto con una sentencia de control.



A primera vista pareciera que la condición escrita dentro de los paréntesis de la sentencia

de control if se cumple ya que las variables a y b son iguales, pero la imagen anterior que

muestra la ejecución del código fuente indica lo contrario.

Explicación:

Después de la llave de apertura de la función main() se declararon dos variables llamadas

a y b respectivamente, ambas de tipo entero, estas fueron iniciadas con el valor de cinco,

enseguida se declararon dos punteros llamados punt1 y punt2, ambos son capaces de

almacenar la dirección de memoria de una variable de tipo entero.


Con esta línea se guarda tanto la dirección de memoria de la variable a como de la

variable b, gracias al operador llamado dirección de (&), en los punteros punt1 y punt2

respectivamente.

Enseguida se encuentran escritas las siguientes tres líneas de código:

Al evaluar la condición escrita dentro de los paréntesis por medio del operador de

comparación igual que (==) se obtiene un resultado falso (no verdadero) y por lo tanto la

siguiente línea de código que es:

Por lo tanto el programa finaliza después de ejecutarse la función system(“PAUSE”);

La condición escrita entre los paréntesis de la sentencia de control if no se cumple ya que

se están evaluando los contenidos de los apuntadores punt1 y punt2, los cuales

almacenan una dirección de memoria diferente, punt1 almacena la dirección de a y punt2

almacena la dirección de b.

Esto sucedió así debido a que no se coloco el operador asterisco (*) antes del nombre de

los apuntadores.

punt1 = &a; punt2 = &b;

if ( punt1 == punt2 )

printf( "Son iguales\n" );

system ("PAUSE");


Para poder comparar la información que esta almacenada en las direcciones de memoria

a donde apuntan los apuntadores, es decir para comparar el contenido de las variables a

y b es necesario colocar el operador asterisco (*) antes del nombre de los apuntadores.

El siguiente código fuente incluye el cambio mencionado anteriormente, analízalo

detalladamente:

Como puedes observar el único cambio hecho a este código, es el siguiente: se le agregó

el operador asterisco (*) antes del nombre de los apuntadores, de esta forma:

Con este cambio se evalúan los contenidos de las variables a donde apuntan los

apuntadores punt1 y punt2, es decir a y b respectivamente.

Como a y b almacenan un cinco entonces el operador de comparación igual que (=)

devuelve un resultado verdadero (un uno), por lo cual se ejecuta la siguiente línea de

código::

if ( *punt1 == *punt2 )

printf( "Son iguales\n" );


Mostrando el mensaje correspondiente en pantalla:

Conclusión.

Es posible utilizar a los distintos operadores con que cuenta el Lenguaje de programación C para realizar operaciones de cualquier tipo conjuntamente con los apuntadores para acceder a las direcciones de memoria guardadas en dichos apuntadores. Multiplicando con esto las posibilidades que nos brindan los apuntadores, de acceder a cualquier variable o hardware de la computadora a través de las direcciones de memoria.

¡Muy bien, continua así!


6. Relación de apuntadores con arreglos

Introducción.

Ya conoces el gran potencial que ofrecen los apuntadores, el acceder a la información

almacenada en cualquier variable o hardware de una computadora, también has

experimentado la sencillez con que puedes declarar y manejar una gran cantidad de

variables a través de los arreglos, pero ¿será posible acceder a la información

almacenada en los elementos que forman a un arreglo a través de apuntadores?

La respuesta es sí, el Lenguaje de programación C permite almacenar la dirección de

memoria de un elemento del arreglo en un apuntador, pero qué pasa si el arreglo tiene mil

elementos ¿debe el programador declarar mil apuntadores?, o como alternativa ¿debe

declarar el programador un arreglo de apuntadores?

Estas preguntas se responderán a lo largo del tema.

Si tuvieras un arreglo de 30 elementos (ya sabes que cada uno de estos elementos tiene

su propia dirección en la memoria RAM), ¿sabes cuál de estas 30 direcciones es la que

se tendría que almacenar en un apuntador? (recuerda que un apuntador solo puede

almacenar una dirección en memoria).

Continúa leyendo para conocer la respuesta.

Como ya se menciono anteriormente un arreglo permite al programador declarar más de

una variable en una sola línea de código, por ejemplo al declarar el siguiente arreglo:

char a[2];

Sabes que esto declara tres variables de tipo char, a[0], a[1], a las cuales el

preprocesador y el SO asignan una dirección de memoria (a cada una), contigua de esta

forma:

Elemento del arreglo Dirección asignada a[0] 0022FF40

a[1] 0022FF41

Nota: La información de la tabla anterior únicamente es para ejemplificar la

asignación de las direcciones.

Como puedes observar las direcciones son consecutivas (una después de la otra), así son

asignadas por tratarse de variables que integran un arreglo.


También sabes que un apuntador almacena una dirección de memoria, entonces es

correcto preguntar ¿Qué dirección debe almacenar el apuntador?

Respuesta:

Para que un apuntador contenga la dirección de memoria de un arreglo, es necesario que

el apuntador que guarde la dirección de memoria del primer elemento del arreglo es decir

al elemento con índice [0].

Enseguida se muestra un fragmento de código que contiene lo explicado anteriormente:

El apuntador almacena la dirección del primer elemento, en este caso es temperaturas[0].

Para corroborar que las direcciones asignadas a los elementos que forman a un arreglo

son diferentes y consecutivas, se presenta el siguiente código fuente el cual muestra en

pantalla las direcciones de cada uno de los elementos del arreglo.

Analízalo cuidadosamente.

int *puntero;

int temperaturas[24];

puntero = &temperaturas[0];



Explicación:

En la primer línea de código de este programa, después de la llave de apertura { de la

función main(), se declaró una variable de tipo int llamada i, la cual no fue iniciada con

ningún valor (esta variable se utilizará después dentro de la sentencia de control for),

enseguida se declara un arreglo de tipo int de 7 elementos, de esta forma:

Nota: recuerda que los elementos un arreglo comienzan con el índice [0].

Posteriormente gracias a la sentencia de control for, que se ejecutará hasta que deje de

cumplirse la condición: i<7.

Dentro de { y } de esta sentencia de control se encuentra escrita la siguiente línea de

código:

Esta línea de código muestra en pantalla la dirección de memoria de cada uno de los

elementos que forman el arreglo.

Como ya se vio anteriormente el Lenguaje C permite al programador acceder a la

información almacenada en una variable a través de un apuntador.

Esta característica también es permitida para los elementos de un arreglo ya que también

son variables.

A continuación se muestra un código fuente escrito en Lenguaje C el cual permite acceder

a la información almacenada en los elementos que forman a un arreglo y mostrarla por

pantalla.

int temp[7];

printf( "La dirección del elemento %i es %p.\n", i, &temp[i] );


Analízalo:



Explicación:

Después de la llave de apertura de la función main() se encuentra escrita la siguiente

línea de código:

Esta línea declara un arreglo llamado temperaturas de índice siete, lo cual genera siete

elementos, a los cuales se les asignan los siguientes valores: 15, 18, 20, 23, 22, 24 y 5

respectivamente a cada uno de los elementos que forman este arreglo.

Posteriormente se declaró un arreglo llamado punt, capaz de almacenar la dirección de

memoria de una variable de tipo int, el mismo tipo que los elementos del arreglo.

Inmediatamente después se declaro una variable de tipo entero llamada i, la cual no fue

iniciada con ningún valor, esta variable se utilizara más abajo dentro de los paréntesis de

la sentencia de control for.


Esta línea de código, asigna la dirección de memoria del elemento cero del arreglo

llamado temperaturas[ ] al puntero punt, esto por medio del operador dirección de (&).

Enseguida se encuentra escrita la sentencia de control for, misma que se ejecutara

mientras la variable i sea menor que siete. Dentro de { y } está escrita la siguiente línea de

código:

Esta línea de código se encarga de mostrar en pantalla el contenido que está guardado

en cada uno de los elementos del arreglo por medio del apuntador llamado punt y el

operador asterisco (*) escrito antes del nombre del apuntador.

int temperaturas[7] = { 15, 18, 20, 23, 22, 24,5};

punt = &temperaturas[0];

printf( "Elemento %i: almacena un: %i\n", i, *punt );


Es momento de poner en práctica todo tu conocimiento, realiza la actividad que se te

presenta a continuación la cual tiene por objetivo que compruebes el funcionamiento de

los apuntadores y que reconozcas el funcionamiento de los arreglos bidimensionales a

través de la programación estructurada.

Actividad Integradora 3. “Arreglos y apuntadores”

1. Para realizar esta actividad vas a retomar el código fuente que se te explicó en el

tema 3 de esta unidad temática “arreglos bidimensionales”, a este programa le vas

a agregar las siguientes variantes: para mostrar en pantalla el promedio de la

temperatura de toda la semana se utilizará la sentencia de control while y se debe

de acceder a la información almacenada en los elementos del arreglo

bidimensional a través de un apuntador.

2. Recuerda que si te surgen dudas debes consultar a tu asesor.

3. Ya que hayas editado, depurado, compilado y funcione correctamente el programa

sube a la plataforma para su evaluación el archivo del código fuente, es decir el

archivo con extensión .c que se creo

4. Cuando tengas listo tú archivo guárdalo en tu PC y envíalo a tu profesor con tus

datos en el siguiente formato: apellidopaterno_materno_nombre_actividadnumero

Conclusión:

A lo largo de esta unidad de aprendizaje te formaste un conocimiento de que un arreglo

también es conocido con el nombre de array, matriz o vector, un arreglo es un conjunto

de variables del mismo tipo cuyo nombre se diferencia en el índice. Su tarea es declarar

más de una variable del mismo tipo en una sola línea, para asignar o acceder a la

información que almacena cada uno de los elementos de un arreglo, el programador

puede hacer uso de las sentencias de control for, while o Do while.



tiempo de ejecución del programa. Las características mencionadas anteriormente son

validas tanto para los arreglos unidimensionales, como arreglos bidimensionales y de

caracteres.


También aprendiste que un apuntador es una variable capaz de almacenar la dirección

de memoria de otra variable, cuando un apuntador almacena una dirección de memoria

se dice que éste apunta a la variable de la cual almacena su dirección, por medio de un

apuntador es posible acceder a los datos almacenados en una dirección de memoria

(leerlos o modificarlos). Es posible utilizar a los distintos operadores con que cuenta el

Lenguaje de programación C para realizar operaciones de cualquier tipo conjuntamente

con los apuntadores para acceder a las direcciones de memoria guardadas en dichos

apuntadores.

Por último debes recordar que es posible que los apuntadores permitan acceder a la

información almacenada en los elementos de un arreglo, ya sea únicamente para leerla o

para modificar esta información.

Acabas de terminar la Unidad de aprendizaje, en hora buena, diste un paso más en la

adquisición de tus conocimientos académicos y lograste una más de tus metas, no resta

más que felicitarte.

El éxito no es para los que piensan que pueden hacer algo sino para quienes lo hacen. Anónimo.

¡Felicidades concluiste la Unidad de aprendizaje!

FUNDAMENTOS DE PROGRAMACIÓN · Unidad Il. Fundamentos de programación estructurada ... Gestionar...

Documents

Transcript of FUNDAMENTOS DE PROGRAMACIÓN · Unidad Il. Fundamentos de programación estructurada ... Gestionar...