You are on page 1of 176

ESIME TICOMÁN

FUNDAMENTOS DE
PROGRAMACIÓN
RODRIGO AVILÉS VILLAREAL

2013

INSTITUTO POLITÉCNICO NACIONAL

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

.

Definición. 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. por lo tanto es necesario conocer el ambiente sobre el cual se trabaja. El Sistema Operativo es un programa que proporciona el ambiente sobre el cual los demás programas funcionarán. características y función de un Sistema Operativo Mapa de conceptos Unidad I Introducción a la Programación Definición. Java y Lenguaje “C”. Comentamos en líneas anteriores. características y función de un Sistema Operativo Definición de características de los Lenguajes de programación. se ejecutarán dentro de un sistema operativo. además de brindar una interfaz entre el usuario y la computadora. Cuando se enciende una computadora comienza a trabajar en ella un conjunto de programas de aplicación. 1 . Visual Basic. acerca de un Sistema Operativo. Introducción a la Programación 1. Introducción a la Programación Unidad I. Compilador (Dev C++) Análisis comparativo de Sistemas Operativos. Para que este conjunto de programas trabajen ordenadamente se requiere de un Sistema Operativo.Fundamentos de Programación Unidad I. Para todo programador es necesario identificar el concepto. Linux y Windows Introducción. pero veamos exactamente a que nos referimos.

. para dar órdenes e instrucciones a la computadora. Un SO hace más sencillo el uso de una computadora cuando el sistema operativo brinda una interfaz gráfica. etc. por ejemplo pensar que Microsoft Office. Por ejemplo: el escritorio de una computadora cuando la encendemos. entre otras funciones. adobe Reader. esto es un error ya que solamente Microsoft Windows es el sistema operativo y los otros mencionados son aplicaciones de propósito específico. etc. Internet Explorer. o utilizar un teclado. ¿Cuáles son las características más importantes de un Sistema Operativo? En general. 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. que el procesador le brinde un poco de “tiempo” ya sea a las funciones que realizan el monitor..Fundamentos de Programación Unidad I.). El SO brinda a los usuarios los medios necesarios para que pueda establecerse una comunicación con él. WinRAR. descargar un archivo. Por ejemplo Windows es el SO en el cuál se pueden correr programas como Microsoft Oficiey Adobe Reader. AutoCad. son parte del SO. Nótese que un error común es denominar al conjunto completo de herramientas y programas sistema operativo. 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. Introducción a la Programación ¿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.Windows se encarga de gestionar y brindar los recursos y herramientas que estos programas requieren para su funcionamiento. En otras palabras un SO es el software (Windows. Linux) sobre el cual se instalan y ejecutan otros programas (office. es decir. un Sistema Operativo tiene las siguientes características: Conveniente.

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

Introducción a la Programación  Organizar los archivos en diversos dispositivos de almacenamiento. se anulará esta actividad. Instrucciones: En esta actividad deberás responder con tus palabras un breve cuestionario. es decir. . Cuida tu ortografía. por ejemplo: las carpetas “mis documentos”. discos compactos o memorias USB. Algunos SO ya vienen con un navegador integrado. 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. envía mensajes de error cuando se da una orden que no se puede ejecutar y da opciones de solución. “system”.  Permite al usuario manejar las comunicaciones en red con gran facilidad todo lo referente a la instalación y uso de redes. como Windows que trae el navegador Internet Explorer. sintaxis y redacción ya que también se te tomará en cuenta para la calificación. permite generar y administrar un directorio de carpetas para organizar los archivos. etc.Fundamentos de Programación Unidad I. en un cibercafé todas las computadoras comparten el internet y el SO es el encargado de hacer esto posible. “Archivos de Programa”. mismo que se te presenta en un documento Word a continuación. Actividad de aprendizaje 1. ahora es momento de que pongas en práctica los conocimientos adquiridos en este apartado. “SO” El objetivo de esta actividad es que conozcas e identifiques los elementos básicos de los sistemas operativos. Linux y Mac. por ejemplo. En Linux el navegador es FireFox.  Gestionar los errores del hardware y la pérdida de datos.  Organizar datos para acceso rápido y seguro. es decir. como discos duros. Para saber más: Los Sistemas Operativos más utilizados son Windows. 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.

pero te permite personalizar totalmente los paquetes que quieras instalar. Linux y Windows. Gentoo. en fin nos es muy cotidiano el uso de este SO. digitalizamos e imprimimos nuestros archivos. En Windows la instalación es mínimamente configurable aunque es muy sencilla. hemos descubierto y experimentado las herramientas y aplicaciones que nos brinda este SO. RedHat o Mandriva son algunos ejemplos. Windows es el sistema operativo más utilizado bajo una licencia propietaria de software. mientras que Linux es el sistema operativo más importante bajo una licencia libre de software. Por otra parte. 1. 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. . chateamos. esto quiere decir que tenemos que pagar por el uso de este SO. aplicaciones ofimáticas. Existen muchas distribuciones diferentes de GNU/Linux: Debian. grabamos música. casi todos hemos utilizado alguna vez el sistema operativo de Microsoft Windows en alguna de sus versiones. Contiene todas las aplicaciones que necesitas: un navegador web. La comparación de los sistemas operativos Microsoft Windows y Linux es un tema muy común entre los usuarios.Fundamentos de Programación Unidad I. realizamos nuestras tareas.1 Análisis comparativo de Sistemas Operativos. ¿Qué es Linux? Linux es un sistema operativo construido por un equipo de desarrolladores de todo el mundo. vemos videos. Introducción a la Programació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. navegamos por el internet. Compatibilidad:  Ninguno de los dos sistemas operativos son totalmente compatibles con la totalidad del Hardware existente en el mercado. esto quiere decir que el usuario no tiene que pagar por el uso de este SO. de mensajería y muchas otras más. escuchamos música.

si una aplicación falla este error no bloquea totalmente al equipo.10 se realiza como la instalación de cualquier otro programa bajo Windows. y se bloquea fácilmente. esta instalación no borrará ni dañara tus archivos. ahora es tiempo de que realices algunas pruebas con el programa que acabas de instalar en tu PC.10)” Ya conoces algunas características tanto de Windows como de Linux. Linux: En el siguiente video tutorial se muestran los pasos que necesitas seguir para descargar e instalar Ubuntu 10. se te recomienda observar la totalidad del video antes de comenzar. Windows ofrece una gran cantidad de drivers. tampoco descompondrá tu computadora y puedes trabajar con cualquiera de los dos SO Windows o Linux. tiene una menor aceptación.10 MaverickMeerkat en tu computadora. Robustez:   En Linux puede pasar mucho tiempo e incluso años sin la necesidad de apagar o reiniciar el equipo. posee una gran cantidad de software. . Windows al ser el más usado. características. aunque gracias a los apoyos de empresas como Sun Microsystems o IBM ha logrado muchos avances. Actividad de aprendizaje 2 “Instalación de Linux (Ubuntu 10. Introducción a la Programación   Linux gracias a su popularidad ofrece una alta compatibilidad ofreciendo. por ejemplo las industrias. Nota importante: La instalación de Ubuntu 10. además. 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”. el objetivo de esta actividad es que utilices los elementos básicos del Sistema Operativo Linux (Ubuntu). actualizaciones frecuentes. ventajas y desventajas de este sistema operativo en su modo gráfico y compararlo con el Sistema Operativo Windows. de manera analítica y reflexiva para descubrir el uso. En Windows siempre hay que reiniciar cuando se cambia la configuración del sistema. Programas:   Linux posee menos software y en algunos campos.Fundamentos de Programación Unidad I.

3.doc de Microsoft Word casi en su totalidad. Para saber más: OpenOffice. y da clic sobre ella. Enciende nuevamente tu computadora e inicia en Windows. Introducción a la Programación Para realizar la actividad necesitas un cronometro (puedes ocupar tu reloj o tu celular). en ella vas a ir registrando los resultados de esta actividad. También puede exportar a ficheros PDF nativamente sin usar otros programas intermedios Instrucciones: 1. El formato nativo (por defecto) para exportar documentos es XML. que es un programa de Linux. no la copies. hasta el momento en que se muestra el escritorio por primera vez. ya que las vas a elaborar posteriormente. Dibuja la siguiente tabla en una hoja de papel. 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).org Writer es un procesador de texto que forma parte del conjunto de aplicaciones de la suite ofimática OpenOffice. Estando dentro de Windows apaga el sistema operativo y registra el tiempo que tarda en hacerlo.10) Tiempo de apagado Tiempo de Encendido Respuesta Inmediata Rapidez al abrir un programa 2.Fundamentos de Programación Unidad I. observa si la respuesta es inmediata. puede abrir y grabar el formato propietario . lápiz y una hoja de papel A continuación se te dan las instrucciones para realizar esta actividad.org.org Writer. 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. Además de otros formatos estándares y ampliamente utilizados de documentos. Características WINDOWS(Especifica tu versión) LINUX (UBUNTU 10. registra el tiempo que tarda en cargar todos los programas. 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. es decir si aparece de .

observa la rapidez con que se abre el programa y registra tu observación. 9. tu respuesta en la hoja de papel será “si” o “no” dependiendo de tu resultado.XML. Nota: Es importante que sea inmediatamente después de que se muestra por primera vez el escritorio al encender la computadora.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 . tu anotación en la hoja de papel será “si” o “no” dependiendo de tu resultado. procesador de textos. En el programa OpenOffice. Introducción a la Programación inmediato la ventana de esta opción. 7. 6. (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 .org Writer (procesador de textos) elabora la tabla que copiaste en la hoja de papel con los resultados que obtuviste. hasta el momento en que se muestra el escritorio por primera vez. Vuelve a encender tu computadora e inicia en Ubuntu. registra tu observación.Fundamentos de Programación Unidad I. tu anotación en la hoja de papel será “si o no” dependiendo de tu resultado. da clic sobre OpenOffice. En este momento registrarás en la hoja de papel si el proceso de abrir un programa. 8. ve al menú inicio y abre Microsoft Office Word. registra el tiempo que tarda en cargar todos los programas. Observa si la respuesta es inmediata. tu respuesta será “si” o “no”.org Writer.doc y . 10. es rápido o lento. guárdala con extensión . 5. Ahora cierra todos los programas que se estén ejecutando en Windows y apaga el equipo. Inmediatamente después de que se muestra el escritorio por primera vez da clic sobre el botón “Lugares” luego da clic sobre “Equipo”. es rápido o lento. y observa la rapidez con que se abre el programa. Nota: Es importante que sea inmediatamente después de que se muestra por primera vez el escritorio al encender la computadora. Ahora registra si el proceso de abrir un programa. ve al menú aplicaciones y abre la pestaña “Oficina”.

Introducción a la Programación Conclusión Hemos terminado el primer tema de la Unidad por lo que haremos una pequeña síntesis de lo visto. además de ser gratuito. para que estos trabajen en conjunto eficientemente. otros programas pueden instalarse y ejecutarse sin ningún problema. Tanto Windows como Linux poseen ventajas y desventajas. tanto de software como de hardware.Fundamentos de Programación Unidad I. también se encarga de brindar al usuario una interfaz o medio de comunicación entre el propio Sistema Operativo y el usuario. Avancemos al Tema 2 . aunque en comparación con Windows no tiene la misma cantidad de software ni tampoco el mismo número de usuarios a nivel mundial. Linux es más rápido y estable. aunque desde un punto de vista más técnico Linux es mejor. Un Sistema Operativo es un programa software encargado de administrar y gestionar todos los recursos que integran a una computadora. además de proveer de un ambiente sobre el cual.

sin necesidad de “hablar” el mismo idioma o lenguaje que la máquina (ceros y unos. diseñado para expresar operaciones. En este apartado conocerás lo que son los Lenguajes de Programación. Para saber más: Al proceso por el cual se escribe. Introducción a la Programación 2. mismas que definen concretamente la estructura. ¿Qué es un Lenguaje de Programación? Un lenguaje de programación es un conjunto de símbolos. se depura y se compila el código fuente (instrucciones escritas) de un programa se le llama programación. los cuales se pueden definir como un idioma creado por el hombre. Cabe aclarar que la palabra programación también se define como el proceso de creación de un programa de computadora. Lenguaje Máquina). También puede usarse para crear programas que controlen el comportamiento físico y lógico de cualquier máquina electrónica. . mismas que pueden ser ejecutadas por computadoras. o para el desarrollo de un SO. Visual Basic. Java y Lenguaje “C”. para que éste pueda dar órdenes a una computadora. para expresar algoritmos. reglas sintácticas y semánticas. Definición de características de los Lenguajes de programación. mediante la aplicación de procedimientos lógicos. la escritura y relación entre los comandos. de instrucciones. Introducción.Fundamentos de Programación Unidad I.

entre otras. . una base de datos para una biblioteca. con la ventaja principal de simplificar la programación utilizando un ambiente de desarrollo completamente gráfico. un compilador que es un programa que traduce el código fuente a lenguaje máquina. Su primera versión fue presentada en 1991. Java y desde luego el Lenguaje C. es decir.Fundamentos de Programación Unidad I. 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 se emplea comúnmente en el desarrollo de aplicaciones de Internet y de propósito general como un diccionario. pero los más utilizados son: Visual Basic. un editor de texto. Introducción a la Programación ¿Qué Lenguaje de Programación es el más utilizado? Actualmente existen varios lenguajes de programación con los que se pueden trabajar. a continuación se te describen brevemente cada uno de ellos. o en inglés. Visual Basic constituye un IDE (entorno de desarrollo integrado. Integrated Development Enviroment) que ha sido empaquetado como un programa de aplicación. un depurador que es un programa que encuentra errores en el código fuente para que pueda ser compilado correctamente. Visual Basic Visual Basic es un lenguaje de programación desarrollado por el alemán Alan Cooper para Microsoft. consiste en un editor de código que es un programa donde se escribe el código fuente.

pero permiten ciertos manejos de bajo nivel. 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. pero tiene un modelo de objetos más simple pero te restringe la manipulación de punteros.Fundamentos de Programación Unidad I. Ritchie en los Laboratorios Bell como evolución del anterior lenguaje B. ya que permiten un manejo abstracto (independiente de la máquina. Al igual que el lenguaje B. bajo y de alto nivel nos referimos a lo siguiente. dispone de construcciones del lenguaje que permiten un control de medio nivel. El lenguaje C es un lenguaje clasificado como un lenguaje de medio nivel pero con muchas características de bajo nivel. a diferencia del lenguaje ensamblador). Nota importante: No confundas C++ con C. solo que es una mejora de lenguaje C y el modelo de programacion es orientado a objetos. Lenguaje de medio nivel Suelen ser clasificados de alto nivel. Introducción a la Programación Este lenguaje toma mucha de la sintaxis propia de los lenguajes C y de C++. . pero sin perder mucho del poder y eficiencia que tienen los lenguajes de bajo nivel. Pero exactamente cuando hablamos de lenguaje de medio nivel. Son precisos para ciertas aplicaciones como la creación de sistemas operativos. que es característico de los lenguajes de bajo nivel. 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 programación C C es un lenguaje de programación creado en el año de 1972 por Dennis M. Dispone de las estructuras típicas de los lenguajes de alto nivel pero. a su vez. C++ es un lenguaje. En otras palabras es un Lenguaje muy completo.

c) Para crear programas que controlen el comportamiento físico y lógico de cualquier máquina electrónica.¿Para qué sirve un Lenguaje de Programación? a) Para interpretar los comandos que permiten al usuario comunicarse con la computadora. Al terminar da clic sobre el botón enviar Cuestionario: 1. “Lenguajes de programación”. Introducción a la Programación 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. se te invita a realizar la siguiente actividad. Es momento de aplicar lo aprendido. cada una presenta tres respuestas pero solo una es correcta.. así como cuáles son los más utilizados.. elige la que consideras adecuada para cada pregunta. reglas sintácticas y semánticas que pueden ser ejecutadas por computadoras. a diferencia de lo que es comprender el lenguaje máquina para una persona. Instrucciones:    A continuación se te presenta un cuestionario con 10 preguntas. 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). Lee cada pregunta con atención antes de seleccionar tu respuesta ya que solo tendrás una oportunidad para responder. resuelve la siguiente actividad de aprendizaje. b) Para gestionar los errores del hardware y la pérdida de datos. Actividad de aprendizaje 3. ya que si dominas este “arte” podrás desarrollar cualquier cosa que imagines. Te invito a que redobles esfuerzos en tu afán por aprender a programar en Lenguaje C.¿Qué es un lenguaje de programación? a) Es un conjunto de símbolos.Fundamentos de Programación Unidad I. para expresar algoritmos o para el desarrollo de un SO . la cual tiene por objetivo que conozcas e identifiques los elementos básicos de los lenguajes de programación. Ahora que ya sabes lo que es un lenguaje de programación. 2.

¿Qué es Java?. a) Es un lenguaje de programación orientado a objetos. se depura y se compila el código fuente de un programa ¿se le llama?: a) Configuración. b) Es un compilador..¿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. b) Simplificar la programación utilizando un ambiente de desarrollo completamente gráfico.. 7. b) Microsoft Windows. 4.Al proceso por el cual se escribe. c) Es un constructor de interfaz gráfica.Fundamentos de Programación Unidad I...¿Cuál es la principal ventaja de Visual Basic? a) Rapidez. b) Programación. Introducción a la Programación 3. c) Compilación. .¿Es un lenguaje de programación desarrollado por el alemán Alan Cooper para Microsoft? a) Java b) Linux c) Visual Basic 5.¿De qué otros Lenguajes toma gran parte de su sintaxis el lenguaje Java? a) Visual Basic... c) Flexibilidad. c) C y C++. 6.

Conclusión.¿Es un lenguaje de programación creado en el año de 1972 por Dennis M. terminaste el segundo tema! ¡Sigue adelante! ..¿El lenguaje de programación C se caracteriza por?: a) Ser un lenguaje de de alto nivel. c) Lenjuage C++. Actualmente existen muchos lenguajes de programación pero los más utilizados son: Visual Basic. c) Su capacidad para crear aplicaciones gráficas. 10. b) Su eficiencia del código que produce. Java y desde luego el Lenguaje C. siendo este ultimo uno de los más robustos. ¡Muy bien.Fundamentos de Programación Unidad I. Como pudiste observar un lenguaje de programación es un conjunto de símbolos. b) Lenguaje Ensamblador. reglas e instrucciones que es diseñado por el hombre para dar instrucciones a una computadora. Introducción a la Programación 9. Ritchie en los Laboratorios Bell como evolución del anterior lenguaje B? a) Lenguaje C..

Introducción a la Programación 3. 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 trabajo de traducción se le llama compilar un programa. 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. es necesario implementar una herramienta que se encargue de traducir un Lenguaje de programación a código máquina. (Bloodshed Dev C++ que es su nombre completo). . es necesario. 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). Compilador (Dev C++) Introducción.Fundamentos de Programación Unidad I. ¿Qué es un Compilador? Un compilador es un programa que traduce un lenguaje de programación a lenguaje máquina. pero también puede ser simplemente texto. ¿Qué es un IDE? Un IDE (Entorno de Desarrollo Integrado. que es el lenguaje que entiende una computadora. por sus siglas en inglés: Integrated Development Environment) es un programa compuesto por un conjunto de herramientas de programación. Este proceso de traducción se conoce como compilación. Existen diferentes compiladores como Turbo C. Turbo Pascal. Borland y GCC. El código maquina es muy difícil de entender para una persona. trabajo que realiza un programa llamado compilador. sino que también. un programa que nos permita editar el código fuente. es un entorno de desarrollo integrado para programar en lenguaje C y C++. IDE Dev C++. a este tipo de programas que cuentan con estas tres herramientas se les conoce como IDE. 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). Cuenta con un editor de código que es un programa donde se escribe el código fuente. Generando un programa equivalente que la máquina será capaz de interpretar.

¿Cómo lo instalo? Espera. “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++. Actividad de aprendizaje 4. Para obtener esta imagen del escritorio presiona el siguiente botón Impr Pant/Petsis. Aquí hay otro ejemplo. se paciente. pégala en un documento en Word y recórtala de ser necesario. a continuación se te muestra un ejemplo. Introducción a la Programación Te preguntarás: ¿Dónde lo consigo?. estas dos preguntas se responderán en este apartado.Fundamentos de Programación Unidad I. Ahora captura la imagen del programa Dev C++ abierto en tu computadora de la misma forma que la imagen anterior. 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. Observa el siguiente video que te mostrará como descargar e instalar el Dev C++. . la imagen de toda la pantalla se guardara en el portapapeles. Una vez instalado el programa Dev C++ captura la imagen del escritorio donde se encuentra el acceso directo a este programa.

¡Excelente! Terminaste la primera unidad.Fundamentos de Programación Unidad I. . guárdalas y envíalas a tu profesor con el siguiente formato: apellidopaterno_materno_nombre_actividadnumero. Introducción a la Programación Pega estas dos imágenes en un documento en Word. 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). 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.

Fundamentos de programación estructurada Unidad Il. 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.Fundamentos de Programación Unidad Il. 19 . 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. Fundamentos de programación estructurada Mapa de conceptos Introducción.

Ya que hayas conocido las partes de este programa vas a realizarlo y a probarlo. 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. ya que la computadora solo entiende el Lenguaje maquina (ceros y unos). Tu primer programa en lenguaje C: “Hola mundo” Ahora vas a conocer la estructura de un programa escrito en Lenguaje C. para lo cual vas a utilizar el IDE Bloodshed Dev-C++ que instalaste anteriormente. 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. Estructura general de un programa.Fundamentos de Programación Unidad Il. Este es el código fuente del programa “Hola mundo”: . 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. estas instrucciones no pueden ser ejecutadas por la computadora. Fundamentos de programación estructurada 1.

cuando la función main( ) finalice. (en el caso del ejemplo se utilizó studio. lo copia en el portapapeles y lo pega en lugar la directiva #include<>. intmain( ) Todos los programas escritos en Lenguaje C deben tener una función llamada main( ) para poder ser catalogados como un programa. pon mucha atención.Fundamentos de Programación Unidad Il.h. para indicar a la directiva del preprocesador #include que este es el nombre de la librería que se debe incluir. La función principal main( ) es la primera en ejecutarse. Te preguntarás que es una librería. que es la librería dentro de la cual está declarada y definida la función cos( ).h selecciona todo el contenido de este archivo. . multiplicar o dividir números y las funciones necesarias para mostrar datos por la pantalla o solicitar información por el teclado. En otras palabras esta directiva del preprocesador abre el archivo stdio. esta devolverá un número. debes incluir la librería math. restar.h) generalmente es esta directiva la que se debe incluir porque en ella se encuentran declaradas las funciones más básicas. El int que tiene al principio indica que. dentro de los operadores< > se escribe el nombre de una libreria. si el código fuente no tiene declarada y definida esta función se puede considerar como una librería o simplemente código. stdio. La sintaxis de esta directiva es #include<>. Fundamentos de programación estructurada A continuación se explica cada una de las líneas de código que lo componen. ya que se buscan por nombre.h). pues es un conjunto de recursos (algoritmos) prefabricados que pueden ser utilizados por el programador para realizar determinadas operaciones. por ejemplo: las funciones aritméticas que te permitirán sumar. #include<stdio. Por ejemplo: Si creas un programa en el cual necesitas obtener el coseno de un ángulo (cos α).h Se escribe en medio de los operadores < >. mismo que será entero.h> Cuando el compilador se encuentra con esta directiva la sustituye por el contenido del archivo indicado (En este caso es el archivo stdio.

{ Llave de apertura La llave de apertura delimita las líneas de código que pertenecen a una función. 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. Se te recomienda comentar el código fuente.Fundamentos de Programación Unidad Il. esto indicará que ha ocurrido algún error durante la ejecución del programa. /* Aquí va el cuerpo del programa */ Esto es un comentario y no se ejecuta. 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. Nota importante: La explicación de cómo una función devuelve un tipo de dato se verá más adelante. en caso de devolver un valor distinto de cero. esto te ayudara a recordar más tarde el funcionamiento del programa. En el caso del ejemplo anterior. o si alguna otra persona lee tu código fuente lo va a poder entender fácilmente auxiliándose de estas notas. 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. . se comienza a escribir el trabajo que realizará esta función a partir de la llave. Fundamentos de programación estructurada Si el valor devuelto es cero indica que el programa termino sin errores. sirve para describir el programa.

printf( "Hola mundo\n" ). . 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. Todo lo que se escribe dentro de los paréntesis y entre comillas dobles (“ ”) se interpreta como una cadena de texto. no como un comentario. Esta línea de código realiza una acción que podemos ver al ejecutar el programa. Si escribimos estas líneas el depurador del IDE nos mostrara en pantalla un mensaje de error. Por ejemplo lo siguiente no es válido: pri/* Esto es un comentario */ntf( "Hola mundo" ). pero al ejecutar tendríamos en pantalla: Porque /* Esto es un comentario */ queda dentro de las comillas y C lo interpreta como texto. Un comentario puede ocupar más de una línea de código y ser válido.Fundamentos de Programación Unidad Il. en este caso el mensaje “Hola mundo”. hasta encontrar */ (asterisco diagonal) que le indica al compilador el final del comentario. La línea de código anterior no daría ningún error. Excepto en medio de una instrucción. Para saber más: Los comentarios se pueden poner casi en cualquier parte. printf( /* Esto es un comentario */ "Hola mundo" ). Fundamentos de programación estructurada Cuando el compilador detecta el operador /* (diagonal asterisco) ignora todo lo que este después de este. Otro ejemplo erróneo de la utilización de mensajes es el siguiente: printf( "Hola/* Esto es un comentario */ mundo" ).

que pueden ser visualizados (aunque no necesariamente) en la pantalla de la computadora. } Llave de cierre La llave de cierre delimita las líneas de código que pertenecen a la función. system ("PAUSE"). Fundamentos de programación estructurada 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. en otras palabras las líneas que se escriban dentro de las llaves de apertura y de cierre pertenecen a la función main(). como un enter. este es su uso más común. con la instrucción return 0. Como se ha indicado anteriormente al finalizar la ejecución de la función main( ). esta sentencia de escape solamente ejecuta un salto de línea. se utiliza en el Lenguaje C para separar una instrucción de otra. Una cadena de texto es una secuencia de caracteres. return 0. es decir.Fundamentos de Programación Unidad Il. . (punto y coma) del final de la línea de código. en este caso a la función main(). Se pueden poner varias instrucciones en la misma línea siempre que se separen por un punto y coma. El operador . lo cual indica que no se produjo ningún error. y debido a que el programa se ejecuta a gran velocidad no podríamos observar la ejecución del mismo. esta devuelve un valor entero. 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. crear mensajes de texto. Notas importantes:    El operador\n no se muestra en pantalla.

la cual tiene por objetivo que reconozcas la estructura de un programa y lo construyas. Fundamentos de programación estructurada  Realizando el programa Ya que se te explicaron los componentes del programa “Hola mundo”. además de lo aprendido. 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”. si tienes que escribir una llave de apertura. realiza la siguiente actividad. Mi primer programa Ahora que conoces la estructura general de un programa creado en Lenguaje C. “ “{ }” si no sabes cómo escribir alguno de estos símbolos puedes consultar la tabla del código ASCII. se te presenta un video en el que se muestra la forma de utilizar el Dev C++. Estas palabras se escriben tal y como se muestran en las explicaciones que se te dan. ubica en la tabla del código ASCII el símbolo y observa el número que tiene asignado en la columna “Dec”. Para saber más: Un ejemplo de cómo apoyarte en esta tabla es el siguiente. así como editar.Fundamentos de Programación Unidad Il. la cual tiene por objetivo que practiques la sintaxis del programa. a estas instrucciones se les conoce como palabras reservadas. . 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. El código fuente además de estar compuesto por palabras reservadas está integrado por símbolos como “( )” “ . Actividad de aprendizaje 5. ya que estás tienen una función preestablecida y específica para el compilador. además de que pondrás en práctica el conocimiento que acabas de adquirir. 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. Pon mucha atención ya que en la actividad de aprendizaje siguiente vas a realizar el programa. deparar y compilar el mismo.

es decir el archivo con extensión . Edita el código fuente del programa “hola mundo” que acabas de revisar. 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. depúralo y compílalo en el compilador Dev C++ 2. da clic en el botón “Solución” para que compares el análisis que realizaste con el resultado que se te muestra.Fundamentos de Programación Unidad Il. . es decir que Dev C++ no te haya marcado error. 2. 3. Analiza el siguiente programa y detecta los errores que tiene. Ya se te han dado las bases para conocer la estructura general de un código fuente y acabas de realizar tu primer programa.c que se realizó. Ya que hayas detectado las inconsistencias del programa. El archivo que debes subir a la plataforma es el código fuente. Fundamentos de programación estructurada Instrucciones: 1. ahora realiza lo que se te pide. Esta actividad no tiene valor en tu calificación pero es importante que la realices para reafirmar tus conocimientos. Instrucciones: 1. Debes enviar tu archivo hasta que haya sido compilado. de lo contrario no se tomará esta actividad como válida. Buscando errores.

c que se creó. El archivo que debes subir a la plataforma es el código fuente. Recuerda que si tienes alguna duda puedes pedir la ayuda de tu asesor. y además muestra un mensaje indicando la posible causa del error. Cuando tengas listo tu programa. El cual indica claramente que el error está en la función intmain(). En la imagen siguiente se muestra el mensaje de error que arroja el depurador del Dev C++. . en la cual reconocerás y construirás un programa escrito en Lenguaje C. 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. Mi nombre en pantalla Para continuar demostrando tu aprendizaje. el cual indica que la función printf esta indeclarada. Esto es porque no se incluyó la directiva #include<stdio.Fundamentos de Programación Unidad Il.h>. Fundamentos de programación estructurada Solución: Si se escribe y compila este código fuente se obtendrá un error. edítalo. a través de la programación estructurada. Realiza un código fuente en el que se muestre tu nombre completo en pantalla. depúralo y compílalo en el compilador Dev C++ 3. exactamente en la línea número 4. 4. Instrucciones: 1. es decir el archivo con extensión . 2. realiza la siguiente actividad. 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.

números con una parte decimal (5. esta puede ser de distintos tipos por ejemplo: cadenas de caracteres (Avilés). cada dirección es de un tamaño de 8 bits. El contenido de una variable se puede leer o cambiar en cualquier momento. Fundamentos de programación estructurada 1. en este apartado conocerás qué son y cuáles son las más importantes.124). caracteres (V). Variables Una variable es el lugar físico en donde se guarda información. . 0 0 1 1 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 0 0 0 1 1 1 0 1 0 1 0 1 1 Dirección 0x 0000 0x 0000 0x 0000 Nota: La información dentro de una memoria RAM se guarda en sistema binario (ceros y unos). En el Lenguaje C se almacenan los datos en variables. números (777). físicamente éste es el aspecto de una memoria RAM: El espacio de almacenamiento de una memoria RAM está estructurado de la siguiente manera. lo que es igual a 1 byte.1 Tipos de variables Al utilizar un programa es muy importante manipular datos. Este lugar físico se encuentra en la memoria RAM de la computadora.Fundamentos de Programación Unidad Il.

647. No se pueden utilizar como nombres de variables las palabras reservadas que usa el compilador. etc.Fundamentos de Programación Unidad Il. El Lenguaje C distingue entre mayúsculas y minúsculas. es decir. Nombre y NOMBRE. es decir 2 bytes. El nombre de una variable se puede formar con números y letras pero no se puede iniciar con un número. indicarle al compilador que queremos crear una variable para que nos reserve un espacio de la memoria para almacenar los datos de la misma. do.483. Para guardar este tipo de variable en la memoria RAM se necesitan 16 bits. también hay que indicarle el tipo de variable. main. No se pueden utilizar caracteres especiales (puntos. en la segunda línea se indica que la variable llamada número guardará un numero 4. son tres variables distintas. excepto la “ñ”.648 a 2.) el único carácter que es aceptado es el guion bajo ( _ ). Los nombres de las variables deben ser cadenas de caracteres. Aunque el rango de valores de esta variable es amplio. Por lo tanto: nombre. (donde la palabra número es el nombre de la variable) numero = 4. Se pueden utilizar los números del 0 al 9. .147. Por ejemplo: int numero.. etc. solo se puede almacenar un número a la vez. 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. por ejemplo: for. El rango de valores que admite es -2. while. a) Variables de tipo int En una variable de este tipo se almacenan números enteros (sin decimales). es decir.  Declaración de una variable Es importante que sepas que para poder usar una variable primero hay que declararla.147. un carácter después de otro sin espacios entre ellos.483. comas. Fundamentos de programación estructurada 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. signos de admiración o de interrogación.

} intmain() { } 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.Fundamentos de Programación Unidad Il. Variable Local #include <stdio.h> int x=0. 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. 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 la numero Así es como se representa el número 4 a 16 bits en Lenguaje maquina (sistema binario). Nota: Si no se asigna el valor que guardara la variable.  Cómo se pueden declarar las variables Hay dos posibilidades.h> int main() { int x=0. int numero = 4. . por ejemplo la función main() y la variable local se declara dentro de cualquier función. Fundamentos de programación estructurada La siguiente imagen muestra su representación en Lenguaje maquina dentro de memoria RAM. A continuación se muestra el ejemplo de las dos formas de declarar las variables: Variable Global #include <stdio. el compilador de manera automática guardara un dato aleatorio del mismo tipo del cual la variable ha sido declarada. La variable global es aquella variable que se declara fuera de cualquier función. una es declararla como global y otra como local. También se puede declarar y definir el valor que guardará esta variable en una sola línea.

no trates de comprenderla Este sería el resultado de editar.Fundamentos de Programación Unidad Il. Fundamentos de programación estructurada 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. depurar y compilar este programa: .

esta variable no la declaraste dentro de la función main(). El depurador indica que int b= -82 no ha sido declarada dentro de main(). pero como está declarada como global es que es posible que main() pueda utilizarla. es decir la función main() conoce a la variable a. 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. 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(). Por lo tanto main() no conoce a esta variable . esto no sería posible ya que aunque int b= -82 es una variable local para la función llamada otrafuncion(). Por otro lado..Fundamentos de Programación Unidad Il. es accesible desde main(). si desde main() quisiéramos mostrar por pantalla a la variable intb= -82. 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". De igual manera la variable int a=2. b). Escribiéramos: printf("Y el valor de b es %i \n". ya que es una variable local para la función main(). Fundamentos de programación estructurada Explicación: Como puedes observar el programa está compuesto por dos funciones. a). ya que esta fue declarada dentro de { } que delimitan a esta función.

x ). Es tiempo de poner en práctica lo aprendido hasta el momento acerca de variables. ¡que bien!\n". . x ). por ejemplo x e y. se puede obtener el mismo resultado utilizando una línea de código en lugar de dos. Para ver el contenido de dos variables. printf( "%i". ) y sirve para indicarle a la función printf() que el número que se mostrará por pantalla es de tipo entero. para lo cual tienes que indicar lo siguiente: Función printf( ) Un ejemplo del uso de esta función es el siguiente: printf( "%i". Si por ejemplo x = 10 e y = 20. Aunque como sabes. podemos realizar lo siguiente: printf( "%i ". También se puede combinar texto con el contenido que guardan las variables: printf( "El valor de x es %i.Fundamentos de Programación Unidad Il. ¡que bien! Como ves. el modificador %i al imprimir en pantalla se sustituye por el valor de la variable. Con una línea de código se puede mostrar en pantalla el número de variables que quieras: printf( "%i %i". Fundamentos de programación estructurada  Mostrar variables por pantalla: Imagina que quieres mostrar el contenido de la variable x de tipo int por pantalla. no se muestra en pantalla. y ). 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. x ). Como puedes ver por cada variable hay que poner un %i dentro de las comillas dobles. y ). realiza la siguiente actividad para que sigas practicando. se sustituye por el valor de la variable que va después de las comillas dobles y el operador coma ( . entonces el resultado en pantalla será: 1020. Si por ejemplo x = 10 la resultado: línea de código anterior mostrara en pantalla el siguiente El valor de x es 10.

c que se creó) con el siguiente formato: apellidopaterno_materno_nombre_actividadnumero. 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. como se nombran y como se deben declarar. Es tiempo de seguir practicando los nuevos conocimientos adquiridos.Fundamentos de Programación Unidad Il. envía el archivo del código fuente a tu profesor para que te evalué (recuerda que es el archivo con extensión . 2. el código fuente que se te presenta a continuación. Instrucciones: 1. Edita. “Declarando variables” Ya sabes que es una variable. 3. El resultado de esta programación tiene que ser igual al mostrado en la siguiente imagen. Fundamentos de programación estructurada Actividad de aprendizaje 7. . (global o local) y construyas la estructura de un programa escrito en Lenguaje C. depura y compila en el compilador Dev C++. Una vez que hayas obtenido el resultado.

B ). ejemplo: char B = 'A'. Ya que está declarada la variable char. B. printf("El número ASCII de la variable %c es: %i. letra = 97.Fundamentos de Programación Unidad Il. . usando el modificador %i en lugar del modificador %c. Los 128 primeros (0 a 127) corresponden al código ASCII estándar. de la variable. mismas que se te muestran a continuación: letra = 'a'. esto es porque el código ASCII de la letra a es el número 97. En una variable char sólo se puede almacenar un carácter. Para declarar una variable de tipo char se realiza lo siguiente: Char letra . 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. esto se te explicará en un apartado posterior.". En el primer renglón es más que obvio.". 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. En ambos casos se está asignando (guardando) la letra 'a' en la variable llamada letra de tipo char. printf( "La variable B de tipo char guarda una: %c. Fundamentos de programación estructurada b) Variables de tipo char Las variables de tipo char sirven para almacenar un carácter. para guardar un dato se tienen dos posibilidades. B). pero en el segundo se tecleo el número 97. no almacena cadenas de caracteres (frases ni palabras). estos se almacenan como números del 0 al 255. carácter en inglés) Enseguida se muestra un ejemplo de esto: char B = 'A'.

Fundamentos de Programación Unidad Il. es importante que la realices. 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. Observa que. Revisa y analiza el siguiente código fuente que se te va a presentar. Instrucciones: 1. Nota: Las variables de tipo char se pueden usar para guardar números enteros. 2. con el consiguiente ahorro de memoria. 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. aunque no tiene valor en tu calificación. en lugar de una variable de tipo int que ocupa 16bits de la memoria. Todo lo anteriormente explicado para las variables de tipo int. el nombre de la variable únicamente sirve para identificarla y no afecta el contenido que almacena la variable. Revisa la imagen del resultado que despliega el código fuente que vas a analizar Explica por qué a partir del código fuente se obtuvo este resultado. 3. 4. 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. Actividad de autoevaluación 2. aplica también para las variables de tipo char. aunque la variable de tipo char es llamada B. Si tienes dudas acerca de los nombres de las variables consulta el apartado “Los nombres de las variables” visto anteriormente. guarda un carácter A. . Fundamentos de programación estructurada 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. 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.

Fundamentos de programación estructurada El resultado de editar. . depurar y compilar este programa es el siguiente: Solución: Inicialmente se declaró la variable llamada CARACTeR de tipo char. mismo que equivale al código ASCII 65. cambia el rango de valores que puede contener una variable y sólo admite valores positivos. que significa sin signo.Fundamentos de Programación Unidad Il. es decir. en otras palabras se le sumo 1 a la variable carácter y el resultado de esta operación aritmética que es 66. Después de mostrar el contenido de la variable CARACTeR por pantalla. cambia valores de signo negativo a positivo y a partir de esto también se cambia el rango de las variables. se guardó en la misma variable CARACTeR. a la cual se le asignó una carácter A (almacena una letra A). se incrementó en una unidad a la variable CARACTeR. c) El modificador unsigned Este modificador. 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.

Un ejemplo de esto es el siguiente: unsignedcharesime = 256.Fundamentos de Programación Unidad Il. se hace lo siguiente: float numero = 0. printf( "El valor de num es : %f". solo puede guardar un solo valor de ese rango.4E37. es importante mencionar que aunque el rango es amplio. Fundamentos de programación estructurada Por ejemplo: El rango de valores que puede aceptar normalmente una variable de tipo char es el siguiente: -128 a 127. Al igual que las otras variables almacenan solo un valor. El rango de valores que podemos almacenar en este tipo de variable es del 3. Para imprimir en pantalla el contenido de una variable de tipo float se usa el modificador %f. Para realizar la declaración de una variable de tipo float. El resultado que se observará en pantalla será el siguiente: El valor de num es: 4060.80 . no sólo números enteros como en las variables de tipo int y las de tipo char. con lo cual el nuevo rango de valores que puede almacenar una variable de tipo unsignedchar es: 0 a 256. y solo d) Variables de tipo float En este tipo de variables se pueden almacenar números enteros con una parte decimal. num). En esta línea de código la variable llamada esime de tipo unsignedchar guarda el número 256. pero si se le antepone el modificador unsigned ya no guardará números negativos. Ejemplo: floatnum = 4060.80. Nota: Este modificador se puede utilizar para cualquier otro tipo de variables guarda un número. y ya no se le puede indicar que guarde números negativos.0.4E-38 al 3.

80. en lugar de %f por ejemplo: floatnum = 4060. Ejemplo: printf( "El valor de num es: %f".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. Fundamentos de programación estructurada Si se quiere imprimir este valor en pantalla en notación exponencial se usa el modificador %e. Para declarar una variable de este tipo se hace lo siguiente: doublenum = 4.7E-307 al 1.85454405655 Si se quiere imprimir este valor en pantalla en notación exponencial se usa el modificador %e. El resultado que se observará en pantalla será el siguiente: El valor de num es: 4. en lugar de %f. constante o tipo de datos que se coloca entre paréntesis). El resultado que se observará en pantalla es: El valor de num es: 4. debes hacer lo siguiente: Primero tienes que conocer el tamaño de bytes de la variable.7E306. . Esta función devuelve el tamaño en bytes de su argumento (el argumento es el nombre de la variable. Como puedes observar el rango de valores que puede almacenar una variable de este tipo es mayor al de las variables de tipo float. printf( "El valor de num es: %e". Para imprimir en pantalla estas variables se utiliza el modificador %f al igual que en las variables de tipo float. Para saber más: Si quieres conocer el máximo rango de valores que puede almacenar una variable. para esto vas a ocupar la función sizeof().85454405655. num ). num ).Fundamentos de Programación Unidad Il.

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. para esto únicamente tendrías que cambiar el argumento. En nuestro ejemplo: (232)=4 294967296.296 si solo almacenáramos números positivos. 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.967. Es decir en una variable de tipo int se podría almacenar un número entre 0 y 4. Sin embargo lo anterior sólo aplica si se usa el modificador unsigned. con lo cual la función sizeof() devuelve el tamaño en bytes de este tipo de dato. Como sabemos 1byte = 8 bits. De lo explicado anteriormente sabes que el tipo int ocupa 4 bytes. por ejemplo en lugar de colocar el argumento int se puede colocar los argumentos char.294. 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. . aunque regularmente se almacenan números positivos y negativos. Por lo tanto el tipo int ocupa (4x8)=32 bits. Fundamentos de programación estructurada 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. float y double.Fundamentos de Programación Unidad Il.

se intenta imprimir en pantalla a la variable Numero. Instrucciones: 1. se declara a la variable llamada número con minúsculas Y por último. Es momento de poner a prueba tu capacidad de análisis. Fundamentos de programación estructurada Así que de los 4294967296 posibles números la mitad serán positivos y la mitad negativos. En la función printf() hay otro error. la cual no ha sido declarada.Fundamentos de Programación Unidad Il. esta sería un variable diferente. esta variable no ha sido declara. 2. . ve a la “solución” para que compares tus resultados y veas los aciertos que tuviste. 4294967296 / 2 = 2147483648. La actividad no tiene valor en tu calificación pero es importante que la realices. Buscando más errores. Actividad de autoevaluación 3. 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. esto te va a servir como práctica y para reafirmar tus conocimientos. Por lo tanto se tiene que dividir el número anterior entre dos. recuerda que la práctica hace al maestro. realiza la siguiente actividad. los nombres de variables no pueden llevar acentos. Solución: Falta la coma después de "El valor es %i". Además la segunda vez número está escrito con mayúsculas. Cuando hayas terminado tu análisis y hayas encontrado los errores del código fuente. Revisa el siguiente programa y detecta los errores que tiene. nota la N al principio del nombre.

1416. únicamente se deja un espacio en blanco entre el nombre de la constante y el valor que desea asignarse a ella. etc. lo que podría ocasionar que hubiera un error de “dedo” en el cual se escribiera mal algún número por ejemplo: 3. La palabra reservada #define indica que los datos que se escriben después en ella no cambian a lo largo del 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. tampoco es necesario escribir el punto y coma (. Se te muestra un código fuente en el cuál no se utiliza la declaración de constantes (#define).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. float. Por último observa que no se indicó el tipo de datos de la constante (por ejemplo char.) esta puede ser una comodidad al momento de declarar constantes. en el cual si se utilizara varias veces el valor 3.1516.) que llevan al final todas las instrucciones en Lenguaje C. Fundamentos de programación estructurada 1.Fundamentos de Programación Unidad Il.

La única manera de hacerlo es editando el programa. sin embargo 2 y 3.1416 Pi = 3. su valor puede cambiar a lo largo del programa.20. cada vez que el compilador encuentre el nombre PI lo sustituirá por el valor 3. el objetivo es que reconozcas y construyas la estructura de un programa. no se puede hacer lo siguiente: #define PI 3. ahora vas a practicar la utilización e implementación de las mismas a través de esta actividad. Sólo se le puede dar un valor con #define.Fundamentos de Programación Unidad Il. es decir. lo cual puede ayudar a que no haya errores. Actividad de aprendizaje 8 “Practicando las constantes” Ya sabes lo que son las constantes y como se declaran. y una vez. . Ahora se muestra el mismo ejemplo en el que está declarada la constante PI utilizando la palabra reservada #define: Con este código fuente.1416. Fundamentos de programación estructurada Explicación: En este código fuente radio y perímetro son variables. Nota: A una constante no se le puede dar un valor mientras se ejecuta el programa.1416 son constantes. no hay manera de cambiarlas.

Ya que hayas terminado tu actividad. envía a tu profesor el archivo del código fuente con extensión . Edita. En un archivo en Word explica el funcionamiento del código fuente y guárdalo en tu PC. 3. . Fundamentos de programación estructurada Instrucciones: 1.c (siempre y cuando no te haya marcado error el compilador) y el documento en Word en el que explicaste el funcionamiento del mismo.Fundamentos de Programación Unidad Il. depura y compila el siguiente programa en Dev C++ 2. guarda ambos documentos con el siguiente formato: apellidopaterno_materno_nombre_actividadnumero.

b y c toman el valor de d */ Nota: En el Lenguaje C la asignación es asimétrica. Un operador es un símbolo que sirve para manipular datos. Los hay de varios tipos: de asignación. de relación. . 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.3 Operadores Durante el proceso de la programación en Lenguaje C surge la necesidad de manipular datos. /* a. enseguida se te explica cada uno. 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. Este valor puede ser un número u otra variable introducido por el teclado. para llevar a cabo esta tarea el Lenguaje proporciona una herramienta sencilla y eficaz para tal propósito. Las formas de utilizar el operador de asignación son las siguientes:  a = 3.b. Fundamentos de programación estructurada 1. en a */ /* Se asigna el valor de una variable. /* Se asigna o guarda un 3 en la variable a */ ó  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. es decir el valor de b se guarda Recuerda que en una misma línea de código se puede dar valores a diferentes variables: a = b = c = 100. lógicos.Fundamentos de Programación Unidad Il. aritméticos y de manipulación de bits. un ejemplo de esto es el siguiente: A=B. /* Se asigna a las variables a. esta herramienta son los operadores.

a continuación se te explica cada uno de ellos. resta. Un ejemplo de la implementación de este operador se muestra enseguida: El resultado de editar.  Operador Suma + Este operador permite sumar entre sí variables y constantes. Fundamentos de programación estructurada En ningún caso se indica que lo que está guardado en la variable A se copia y se guarda en la variable B.Fundamentos de Programación Unidad Il. depurar y compilar este código es el siguiente: . 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. Tampoco se indica que la variable A y la variable B son iguales. división y multiplicación.

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. Fundamentos de programación estructurada Explicación: En este programa se declaran tres variables a = 2. depurar y compilar este código es el siguiente: . Observa el siguiente código fuente en el cual se suman constantes y variables: El resultado de editar. o variables y constantes (recuerda que se consideran constantes porque nunca cambiaran su valor). b = 3 y c = 0. 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.Fundamentos de Programación Unidad Il. Se suman las variables a y b y el resultado de esta suma se guarda en la variable c.

Fundamentos de Programación Unidad Il. a=2. el cero que se asigno en la primer línea es sustituido por el nuevo valor que es cinco. se guarda en la misma variable llamada x. por ejemplo: int x=0. se sumaron los valores de las variables a. Este es otro ejemplo: . ya que una variable solo puede contener un solo valor. c=1 y d a esta última no se asigno ningún valor inicial. b y c con el valor de la constante 4. Fundamentos de programación estructurada Explicación: En este programa se declararon cuatro variables. (recuerda que cuando no inicias una variable el compilador asigna un valor aleatoria en forma automática). /* 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). 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. x = x + 5. ) También es posible utilizar al operador de suma (+) para incrementar el valor de una variable. b=3.

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. Fundamentos de programación estructurada El resultado de editar. para corroborar que lo explicado es cierto se muestra nuevamente el valor de la variable x por pantalla. se asignan los valores 3 y 5 respectivamente. Ejemplo: . guardando el resultado de esta operación aritmética en la variable x. en la misma línea se incremente el valor que guarda la variable x en dos. depurar y compilar este código es el siguiente: Explicación: En este programa escrito en Lenguaje C se declaran dos variables x e y. así: x+=2.  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. (esto sería igual que hacer x=x+2.Fundamentos de Programación Unidad Il.

Enseguida incrementamos a la variable x en una unidad realizando x++.Fundamentos de Programación Unidad Il. se le asigna un 5 (x=5) y se muestra a esta variable por pantalla utilizando la función printf(). Fundamentos de programación estructurada El resultado de editar. . depurar y compilar este código es el siguiente: Explicación: En este programa se declara a la variable llamada x de tipo entero.  Operador Resta o Negativo El operador - . Por ejemplo: int z =0.permite restar entre sí variables o constantes. (es lo mismo que realizar x = x+1.) y enseguida se muestra por pantalla el nuevo valor que guarda la variable x. x=8. que evidentemente es 5. esto para mostrar el contenido de esta variable. z = x.5.

se les asigna el valor de las constantes 20 y 5 respectivamente. guardando el resultado de esta operación aritmética en la variable llamada A. a las cuales.Fundamentos de Programación Unidad Il. después de esto se muestra el valor guardado en la variable A para demostrar lo explicado anteriormente. Enseguida se realiza la resta de las variables A y B (A-B). . depurar y compilar este código es el siguiente: Explicación: En este programa se realiza la declaración de dos variables de tipo entero llamadas A y B. Fundamentos de programación estructurada Un ejemplo de la implementación de este operador: El resultado de editar.

Fundamentos de programación estructurada Después se realiza la declaración de dos nuevas variables llamadas a y b. enseguida a la variable del mismo tipo llamada b se le asigna el valor de la variable a pero con signo negativo. el valor de la variable llamada a asignado previamente. y se imprime en pantalla el valor de b. es decir en b se guarda un -1. Después de esto se declaro y definió con 5 otra variable de tipo entero llamada x.Fundamentos de Programación Unidad Il. a la variable de tipo entero llamada a se le asigna el valor de la constante 1. Aclarando lo anterior. Para corroborar que se realizó la resta adecuadamente se imprimió en pantalla nuevamente el valor de x. es decir a sigue guardando un 1 positivo. al realizar la línea de código b = -a. 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. 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. para demostrar que es posible en el Lenguaje C decrementar el valor de una variable se realizo la línea de código x--. Nota: Al realizar la línea de código b = -a. enseguida se mostro por pantalla dicha variable por medio de la función printf(). . no se ve afectado.

0460 y 2. 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. El operador * También sirve para definir y utilizar punteros. depurar y compilar este código es el siguiente: Explicación: En este programa se declararon dos variables de tipo float x y y a las cuales se les asignaron los valores -5. Fundamentos de programación estructurada  Operador Multiplicación y puntero El operador * * sirve para multiplicar entre si variables o constantes.00987 respectivamente. . pero eso lo verás a detalle más adelante.Fundamentos de Programación Unidad Il. para después por medio de la función printf() mostrar el resultado por pantalla. Por ejemplo: El resultado de editar.

Fundamentos de programación estructurada  Operador División El operador / / sirve para dividir entre si variables o constantes. Por ejemplo: El resultado de editar. depurar y compilar este código es el siguiente: 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. 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.Fundamentos de Programación Unidad Il. . para después por medio de la función printf() mostrar el resultado por pantalla.00987 respectivamente.

por medio de la función printf() se imprime en pantalla el residuo de la división entre a y b. . pero a diferencia del operador de división (/) este devuelve el modulo de la división. Fundamentos de programación estructurada  Operador Modulo % El operador % sirve para dividir entre si variables o constantes. depurar y compilar este código es el siguiente: 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.Fundamentos de Programación Unidad Il. Por ejemplo: El resultado de editar.

Cuando se realiza esta comparación se obtiene un resultado.Fundamentos de Programación Unidad Il. Fundamentos de programación estructurada c) Operadores de comparación Los operadores de comparación se utilizan para comparar cómo son entre sí variables o constantes. depurar y compilar este código es el siguiente: . 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: El resultado de editar. el cual puede ser 0 si no se cumple la comparación satisfactoriamente o 1 si la comparación se cumple satisfactoriamente.

 Operador && (AND. más adelante se compara si 5 es igual que 5. Nota: No sólo se pueden comparar constantes. Fundamentos de programación estructurada Explicación: En este código fuente se compara a las constantes 10 y 5. por ejemplo 10>5 y 6==6. En la primer línea de la función main() se compara si 10 es mayor que 5. en español “Y”): Devuelve un 1 si se cumplen dos comparaciones. dicha comparación devuelve un 0 al no cumplirse satisfactoriamente. OR (||) y NOT(!). tal comparación devuelve un 1 y por último se compara si 10 es igual que 5. enseguida se compara si 10 es menor que 5. también se pueden comparar variables.Fundamentos de Programación Unidad Il. Los operadores lógicos son: AND (&&). para tal comparación devuelve un 0 ya que no se cumple la comparación anterior. 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 . d) Operadores lógicos Los operadores lógicos nos permiten unir varias comparaciones. lo cual devuelve un 1 al cumplirse esta comparación.

(10==10 && 5>2 ). de hecho la segunda comparación ya no se realiza. en español O) El operador || devuelve un 1 si se cumple una de las dos comparaciones. ya que ninguna de las dos comparaciones se cumple satisfactoriamente 10 no es igual que 0 y tampoco 5 es menor que dos. negación): Este operador lógico realiza el siguiente trabajo. . 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.  Operador ! (NOT. si la comparación se cumple NOT hace que no se cumpla y viceversa. Ahora si en este ejemplo se le cambia la primera comparación de la siguiente forma: printf( "Resultado: %i". Lo cual devolvería un 1 ya que ambas condiciones se cumplen.Fundamentos de Programación Unidad Il. La tabla de verdad es la siguiente: 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". Al realizar este cambio en la línea anterior ésta devolvería un 0. ya que 10 es igual que 10 y 5 es mayor que 2  Operador || (OR. (10==10 || 5<2 ). Fundamentos de programación estructurada Un ejemplo de lo explicado anteriormente sería el siguiente: printf( "Resultado: %i". (10==0 || 5<2 ).

(! 5<2 ).  Operadores a nivel de bits Ya has visto que un byte está compuesto por ocho bits. 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 derecha a la << Desplazamiento izquierda a la . Fundamentos de programación estructurada La tabla de verdad es la siguiente: Comparación Resultado que devuelve NOT (!) 1 0 0 1 Un ejemplo de lo explicado sería el siguiente: printf( "Resultado: %i". 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. con los operadores a nivel de bits podemos manipular bit a bit los valores que almacenan las variables. 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. Pues bien.Fundamentos de Programación Unidad Il. Si cambiamos los operadores de comparación de la siguiente manera: printf( "Resultado: %i". ( ! 5>2 ).

Fundamentos de programación estructurada  Operador | (OR a nivel de bits): Toma los valores y hace con ellos la operación OR a nivel de bits. depurar y compilar este código es el siguiente: 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.Fundamentos de Programación Unidad Il. si alguno de ellos es uno. luego la segunda pareja (1 y 0 = 1) y así sucesivamente hasta terminar con el valor. Ve el siguiente ejemplo: El resultado de editar. En el ejemplo anterior se compararon los dos primeros bits de derecha a izquierda (el primero de cada uno de los números. Si ambos son cero el resultado es cero. 1 y 1 = 1). se obtiene un uno.

Primero se compara los dos primeros (el primero de cada uno de los números. Si ambos son 1 el resultado es 1. .Fundamentos de Programación Unidad Il. depurar y compilar este código es el siguiente: Explicación: Esta es la operación a nivel de bits: 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. Si no. 0 y 1 -> 0). el resultado es cero. Si ambos son cero el resultado es cero. se obtiene un uno. Ve el siguiente ejemplo: El resultado de editar. Si alguno es cero el resultado es cero. Fundamentos de programación estructurada  Operador & (AND a nivel de bits): Este operador compara los bits también dos a dos. luego la segunda pareja (1 y 1 -> 1) y así sucesivamente.

. 0 y 1 -> 0). se obtiene un cero. Esta operación afecta también al signo del operando (positivo o negativo). Si ambos son cero se obtiene cero. depurar y compilar este código es el siguiente: Explicación: Esta es la operación a nivel de bits: 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. Si ambos son distintos el resultado es uno.  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. Ve el siguiente ejemplo: El resultado de editar. luego la segunda pareja (1 y 1 -> 1) y así sucesivamente. es decir los invierte. mismo que se indica antes del operando.Fundamentos de Programación Unidad Il. Primero se compara los dos primeros (el primero de cada uno de los números. Fundamentos de programación estructurada  Operador ^ (XOR a nivel de bits): El operador ^ Compara los bits y los pone a unos si son distintos.

Si realizamos la operación inversa no recuperamos el número original. el de la derecha se pierde. Fundamentos de programación estructurada Ve el siguiente ejemplo: El resultado de editar.  Operador >> (Desplazamiento a la derecha): Este operador mueve cada bit a la derecha. como el bit de mayor peso en una variable numérica representa el signo (positivo o negativo) este bit también es invertido. El bit de la izquierda se pone a cero. evalúa bit a bit ye invierte el valor del bit evaluado. por tal motivo el signo del nuevo numero obtenido es ahora negativo. depurar y compilar este código es el siguiente: Explicación: Esta es la operación a nivel de bits: 152 ->10011000~ -153 -> 01100111 El operador complemento a uno.Fundamentos de Programación Unidad Il. El formato es el siguiente: variable o constante>>número de posiciones a desplazar .

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

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.

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

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:
:

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

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

operación a

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.

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

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().

terminaste el primer tema! ¡Sigue adelante con tu trabajo! .. etc. Lucy254. 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). y un número es una constante por ejemplo 0. ya que es en la memoria RAM donde se cargaran y ejecutaran nuestros programas.25. existen operadores para manipular casi todo tipo de información. etc.2. por ejemplo Rodrigo. Hay que recordar también que la memoria RAM de la computadora es limitada.Fundamentos de Programación Unidad Il. debemos usar sólo la memoria necesaria.10. así que cuando guardamos un dato. No es lo mismo guardar un nombre que un número. Estas variables pueden ser de distintos “tipos” dependiendo de la clase de información que almacenen. por ejemplo cuando escribimos a+2. Fundamentos de programación estructurada Todo programa escrito en Lenguaje C debe tener una función llamada main(). así que es necesario que recuerdes que el contenido de las variables se puede ver o cambiar en cualquier momento. 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. Como te abras dado cuenta es imprescindible utilizar variables en un programa en Lenguaje C. ¡Excelente. ya que un nombre puede estar compuesto por letras y números.-1. 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. Recuerda también que los operadores son símbolos que le indicaran al compilador como manipular la información.

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

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:

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

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

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:

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

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:

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

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.

Fundamentos de Programación Unidad Il. además sabes cómo implementar las funciones de entrada y de salida estándar con que cuenta este Lenguaje. 2. al presionar la tecla Enter. Instrucciones: 1. Cuando hayas terminado tú programa. Fundamentos de programación estructurada Para corroborar que los datos se guardaron correctamente se utiliza a la función printf() para mostrar el contenido de la variable. 5. en la pantalla de tu PC se debe desglosar la información correspondiente a cada uno de los elementos que componen el R. la imagen siguiente muestra el resultado que debes obtener: 4. Realiza un código fuente escrito en Lenguaje C que te permita introducir el RFC de cualquier persona física. los tipos de variables con que cuenta el lenguaje C. . 3. Introduciendo datos por el teclado Ya conoces la estructura general de un programa. Después de introducir el último carácter. compilado y funcione correctamente.F. Se debe introducir el RFC carácter por carácter sin espacios en blanco entre ellos. lo hayas depurado. es momento de poner en práctica todos estos conocimientos. 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.C. Actividad Integradora 1. El Programa debe funcionar correctamente para cualquier RFC que introduzcas.

finalmente. mm. el RFC del Sr.C. Las funciones estándar para introducir información por el teclado son: scanf(). En cambio las funciones getch() y getche() únicamente permiten introducir un solo dato.F. José Vélez es el siguiente: VECJ860326. %c. nació el 26 de marzo de 1986. el mes y el día.Fundamentos de Programación Unidad Il. ¡Buen trabajo! ¡Continúa con el Tema 3! . siempre y cuando se indique en forma explícita con el operador %i. comenzando con el año. José Vélez Cuevas. dd): 860326. El registro se debe hacer en las oficinas del Servicio de Administración Tributaria de la Secretaria de Hacienda y Crédito Público. Conclusión.. posteriormente se agrega a la clave la fecha de nacimiento. en ellas se te explica qué es el RFC. esta instancia otorga una homoclave diferente para cada registro y es obligatorio para todas las personas. ya que se tiene el R. todo con números (aa. Partiendo de estos datos. o %f de acuerdo al tipo de variable que se desea introducir. la primera letra del nombre (J). Fundamentos de programación estructurada Antes de comenzar lee la siguiente nota informativa en la que te puedes apoyar para realizar tu código fuente. la Secretaría de Hacienda designa una homoclave. getch() y getche() La primera permite introducir cualquier cantidad de información en una sola línea y de cualquier tipo. ¿Cómo se determina? Para explicarte como elaborar el RFC se va a tomar como ejemplo los datos de la siguiente persona: El Sr. El RFC se forma con los datos personales del contribuyente. se toman las dos primeras letras del apellido paterno (VE). ¿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. su nombre y fecha de nacimiento. 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. y como se determina. la primera letra de apellido materno (C).

. Fundamentos de programación estructurada 3. 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. por ejemplo: calcular la raíz cuadrada de un número u obtener el valor absoluto de una variable. esta librería se llama math.Fundamentos de Programación Unidad Il. d2) double Devuelve el arco tangente de d1/d2 ceil(d) double Devuelve el valor redondeado por exceso. se debe incluir la directiva del preprocesador #include<math. Funciones matemáticas Introducción En ocasiones durante el proceso de la programación en Lenguaje C es necesario realizar cálculos matemáticos.h. (base10) de d pow(d1.h Para usar la librería de matemáticas math.h>. d2) float sin(d) Double Devuelve el seno de d sinh(d) double Seno hiperbólico de d sqrt(d) float Tan(d) double Devuelve la tangente de d tanh(d) double Devuelve la tangente hiperbólica de d Devuelve d1 elevado a la potencia d2 Raíz cuadrada de d Algunos ejemplos de cómo utilizar las funciones mostradas en la tabla anterior se presentan a continuación. 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. 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.

Fundamentos de programación estructurada Se necesita escribir el código fuente de un programa en Lenguaje C. C= ¿? cm. C2 = A2 + B2 B= 50.2 cm.Fundamentos de Programación Unidad Il. dicho programa será capaz de obtener el valor de la hipotenusa del siguiente triangulo rectángulo: A= 20. El código fuente que da solución a este problema es el siguiente: .05 cm.

utilizando a la función pow(). 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.2)). una vez más la función scanf() permite almacenar este valor en la variable de tipo float llamada B. como se pudo observar en la tabla mostrada anteriormente. B. El resultado de estas dos operaciones se guarda en las variables D y E respectivamente. Por último se muestra el resultado de esta operación por medio de la función printf(). Fundamentos de programación estructurada El resultado de editar. . para enseguida obtener la raíz cuadrada de esta operación aritmética (suma). Posteriormente se eleva el valor de la variable A al cuadrado(pow(A. 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. depurar y compilar este código fuente es el siguiente: Explicación: En este código fuente se declararon cuatro variables de tipo float A. Se muestra otra cadena de caracteres que indica al usuario del programa tecle el valor del cateto B. C y respectivamente. 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. D Enseguida. Se realiza la misma operación con la variable B. Inmediatamente después se suman estos dos valores y se guarda en la variable C de tipo float. este valor se guarda en la variable A.Fundamentos de Programación Unidad Il. en este caso el valor de la variable C que contiene la suma de los cuadrados de las variables A y B. las cuatro variables se iniciaron con el valor de la constante cero.

Da clic en la palabra Elipsoide para que se te muestre dicha información. Cuando hayas terminado tu programa. 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. el elipsoide es un esferoide. a continuación para calcular el volumen de un dispositivo con esta geometría. si los tres son iguales. Actividad de aprendizaje 11. Si dos de estos semiejes son iguales. b y c son las longitudes de los semiejes del elipsoide respecto de los ejes x. es decir. y . se trata de una esfera. Fundamentos de programación estructurada Nota: La implementación de las otras funciones matemáticas es similar a la vista anteriormente. Calculando Ahora conoces las funciones matemáticas y su aplicación. Un elipsoide es una superficie curva cerrada cuyas tres secciones ortogonales principales son elípticas. 2. Volumen: El volumen de un elipsoide está dado por la ecuación: Donde a. 3. 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.Fundamentos de Programación Unidad Il. estás en condiciones de aplicar este conocimiento para la construcción de software que permita dar solución a problemas de ingeniería. . son números reales positivos y determinan la forma del elipsoide. Para apoyarte en la realización del programa revisa la información que se te presenta. compilado y funcione correctamente. z. Instrucciones: 1. lo hayas depurado. son originadas por planos que contienen dos ejes cartesianos. Escribe un código fuente en Lenguaje C que calcule el volumen de un elipsoide (Zepelín).

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.h contiene la declaración y definición de las funciones matemáticas más usadas por los programadores de Lenguaje C. La librería llamada math. terminaste! Concluye la unidad trabajando el Tema 4 .Fundamentos de Programación Unidad Il. ¡Muy bien. Fundamentos de programación estructurada Conclusión. 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.

Ya has utilizado algunas funciones prefabricadas. 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. por ejemplo la función printf() y la función system(“PAUSE”). Para poder utilizar una función es necesario declararla. 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. También es necesario definirla. es decir. 4.Fundamentos de Programación Unidad Il. escribir en forma explícita las instrucciones que pertenecen a dicha función (dentro de las llaves de apertura y cierre { }). cada una realiza una tarea específica y como ya sabes estas están declaradas y definidas dentro de las librerías. Fundamentos de programación estructurada 4. 5 4 cuerpo de la funcion. 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.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. finalmente estas instrucciones describen el funcionamiento de la función (el ¿Qué hace?). es decir indicarle al compilador en forma explícita cual es el nombre de la función. return } 6 . su tipo y si posee o no argumentos. para alcanzar un objetivo específico. el Lenguaje C brinda una forma sencilla y flexible al programador para que éste pueda declarar y definir sus propias funciones.

Además el nombre de la función debe comenzar por una letra. La sentencia return es la función devuelve un valor. éste puede ser una constante o una variable y debe ser del mismo tipo que el tipo_de_variable. únicamente se declaran cuando es necesario recibir información proveniente de alguna otra función u otro programa.). la declaración de estos argumentos no termina con el operador punto y coma (. Cuando una función termina de ejecutarse puede o no devolver un valor. es la encargada de realizar esta tarea.). Si declaramos una variable en una función no podemos usarla en otra. no puede comenzar con un número. Nota: No en todas las funciones se declaran argumentos. así que se tiene que declarar y definir la función antes que se escriba la función principal main(). es decir que trabajo realizara la función. debe declararse cada argumento(variable) separado por un operador coma (. double) o un tipo de dato definido por nosotros. números y el símbolo _. Este tipo de datos no regresa ningún valor al finalizar la función. También se puede usar el tipo void. 6. Los argumentos son variables de cualquier tipo. Por ejemplo. El nombre de la función se usa para llamarla dentro del programa. (int. Las funciones deben declararse y definirse antes de ser llamadas (utilizadas en un programa). Este valor devuelto suele ser el resultado de las operaciones que se realizan en la función y si han tenido éxito o no. 2. Aunque la excepción a esta regla es la siguiente: Si se colocó el tipo de variable void. 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 { }). Para el nombre se pueden utilizar letras.Fundamentos de Programación Unidad Il. 4. un nombre valido para una función puede ser el siguiente: Rodrigo_Aviles() ó Resta123() 3. En los ejemplos que se muestran en los siguientes apartados se llama a la función desde main. el cual puede ser cualquiera de los tipos de variable vistos anteriormente. Aquí es donde se escriben de forma explícita las instrucciones que describirán la ejecución de la función. char. No se pueden utilizar ni acentos ni espacios en blanco. el dato que se pone después de return es el dato que se devuelve. 5. float. sirven para dotar a la función de la “capacidad” de recibir información. . Tampoco puede ser una palabra reservada. Fundamentos de programación estructurada 1. no debe colocarse la instrucción return.

El resultado de editar. 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. Fundamentos de programación estructurada 4. en el se muestra la declaración y definición de una función que no devuelve ningún valor. depurar y compilar este código fuente es el siguiente: .Fundamentos de Programación Unidad Il.2 Función sin argumentos que no devuelve ningún valor Observa el siguiente código fuente.

Enseguida de realiza la resta entre a y b guardando el resultado de esta resta en la variable c. por medio de la función scanf() El valor tecleado por el usuario del programa se guardara en la variable a. . b y c respectivamente. aquí solo estamos escribiendo (indicándole al compilador) el tipo de variable que devolverá la función. más adelante se mostrara una función que si regresa valores. esta función no devuelve ningún valor por lo tanto se le coloca la palabra reservada void. 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. en este caso no devuelve ninguno (void). para inmediatamente después realizar exactamente el mismo procedimiento pero ahora el valor tecleado por el usuario se guardara en la variable 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. en otras palabras. por lo tanto el resultado de la resta se guarda en la variable c que inmediatamente después se muestra por pantalla. 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.Fundamentos de Programación Unidad Il. Lo explicado anteriormente es únicamente la declaración y definición de la función resta(). así podrás comparar esta característica de las funciones. de este modo c = a-b. observa que la declaración y definición de la función resta(). Fundamentos de programación estructurada Explicación: En este código fuente se declara y define la función llamada resta().

Fundamentos de programación estructurada El nombre de la función en este caso es resta() y especificamos si esta función tiene argumentos. y nunca se ejecutara la función resta(). se llama suma y su trabajo consiste en realizar la suma de dos números que se introducirán por el teclado.Fundamentos de Programación Unidad Il. el resultado se mostrara por pantalla. esta función tiene argumentos. . Si no realizaras la invocación de resta() desde la función main() el programa solo ejecutaría la función system(“PAUSE”). en él se muestra la declaración y definición de una función que no devuelve ningún valor. Si se edita. Observa que este código fuente es muy semejante al anterior.3 Función con argumentos que no devuelve ningún valor Observa el siguiente código fuente. en este caso no los tiene. se obtiene el siguiente resultado: Omisión de la invocación. depura y compila el código fuente anterior y se omite la invocación a la función resta. 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. 4. esto se hace declarando variables dentro de los paréntesis.

Fundamentos de programación estructurada El resultado de editar. depurar y compilar este código fuente es el siguiente: .Fundamentos de Programación Unidad Il.

la ventaja que se obtiene al declararle argumentos a una función es dotarla de la capacidad de recibir información. y por último la funcion suma() muestra el resultado de esta operación aritmética en pantalla. pero por tratarse de argumentos el compilador se encarga de iniciar estas variables llamadas argumentos con valor cero. Fundamentos de programación estructurada Explicación: En este código fuente escrito en Lenguaje C se declaró y definió una función llamada suma(). Se suman los valores de las variables a y b. 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.B). esta información proviene de otra función u otro programa. es decir estas variables no fueron iniciadas. la cual fue iniciada con la constante cero. 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. Después se declaró una variable local llamada c de tipo entero. recuerda que estos valores debes “pasárselos”.Fundamentos de Programación Unidad Il. el resultado se almacena en la variable llamada c. int b) ) a ninguno de estos dos argumentos se le asigno valor alguno. si observas cuando se declararon los argumentos a y b ( suma (int a. después por medio de la instrucción c=a+b. es en estas dos variables en donde la función suma() recibirá los valores que sumara. con dos argumentos (variables) de tipo int a y b respectivamente. 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. en otras palabras el compilador guarda un cero en estas variables. . 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. Por lo anterior es necesario “pasarle” estos datos a la función. Esta función no regresa ningún valor por lo tanto se le antepuso la palabra reservada void.

. en él se muestra la declaración y definición de una función sin argumentos que devuelve un valor.4 Función sin argumentos que devuelve un valor Observa el siguiente código fuente escrito en Lenguaje C. dentro de esta se encuentra la declaración de dos variables de tipo int llamadas A y B. el trabajo que realizara esta función es multiplicar dos valores y regresar el resultado de esta multiplicación. 4.Fundamentos de Programación Unidad Il. (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(). 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. 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. guardando el valor tecleado en la variable B.B). En este ejemplo la funcion principal main() es la función que se encarga de proveer (pasarle ) información a la funcion suma(). A continuación se observa la invocación a la función suma() de la siguiente manera: suma(A. enseguida se realiza la misma operación pero ahora con la variable llamada B. 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. Fundamentos de programación estructurada En la línea siguiente encontrarás la declaración y definición de la función principal del programa es decir main().

depurar y compilar este programa es el siguiente: . Fundamentos de programación estructurada El resultado de editar.Fundamentos de Programación Unidad Il.

esta función devuelve un valor y el valor que devolverá será de tipo float. almacenado en la variable c. esto para poder almacenar correctamente dicho valor devuelto. 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. 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. 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. El objetivo de esta actividad es que construyas un software que implemente funciones capaces de resolver problemas de ingeniería. Por último se muestra en pantalla a la variable C que ahora contiene el resultado de la multiplicación. Después se regresa el resultado de esta multiplicación. Actividad de aprendizaje 12. 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. en este caso la variable local c. 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. que es el volumen del elipsoide.b y c respectivamente. En la línea c=a*b. 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(). se realiza la multiplicación de estos dos valores.Fundamentos de Programación Unidad Il. “Declarando una función” Para realizar esta actividad se va a retomar el código fuente y el resultado de la misma. con la instrucción return c. . Para realizar estos cálculos revisa la información que se te presenta mismo que te va a servir de apoyo para esta actividad. Fundamentos de programación estructurada Explicación: En este código fuente escrito en Lenguaje C se declaró y definió la función llamada por() sin argumentos. la palabra reservada return indica al compilador que deberá devolver el valor de la variable cuyo nombre se coloca enseguida.

La función ACENCION() debe ser invocada en main() y recibir el volumen calculado previamente. compilado y funcione correctamente. Cálculo de la capacidad de ascensión El peso específico del helio es. Por lo tanto. no tóxico.21 kg/m³.524/1000) × (d (en cm))³. Fundamentos de programación estructurada Helio: El helio es un gas inerte. dicha capacidad está asegurada si el peso del globo y de los anexos (cordeles. lo hayas depurado. Cuando hayas terminado tú programa. 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.18 kg/m³. tarjetas) es menor de 0. en condiciones ambientales normales. sino también el peso que podrías elevar con este elipsoide. El volumen (V) en litros del globo se calcula en función del diámetro (d) de la siguiente forma: V (litros) = (0.5 g. 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. 0. un globo esférico con un diámetro de 30 cm tiene un volumen de 14. 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. Recuerda que de acuerdo a sus propiedades el helio (He) es el gas más apropiado para inflar un zepelín. incoloro e inodoro mucho más ligero que el aire y además es seguro. .Fundamentos de Programación Unidad Il.1 litros y una capacidad ascensión al suficiente para un peso de aproximadamente 7 a 8. esta realizará el cálculo de la ascensión y mostrará este resultado en pantalla. 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.5 a 0. no inflamable y no explosivo. En la práctica.6 g por litro del volumen del globo. Los globos en forma de pera que cuentan con el mismo diámetro. tienen un volumen levemente más grande. La diferencia entre ambos significa que la capacidad teórica ascensional es de aproximadamente 1 g por litro de helio. el del aire es 1.

¡Adelante con la Unidad III! . sigue esforzándote y practicando ya que estas son las bases para lograr el éxito y aprender a programar. hace posible solucionar problemas para los que no existe ninguna función prefabricada en las librerías.Fundamentos de Programación Unidad Il. 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. Fundamentos de programación estructurada Conclusión: La declaración y definición de una función además de permitir al programador dar órdenes a una computadora. existen funciones que posen argumentos y funciones que no poseen argumentos. Vas muy bien y estás a la mitad del camino para concluir esta Unidad de aprendizaje.

se utiliza para repetir un número determinado de veces. estas herramientas se llaman sentencias de control y sirven para manipular y re direccionar el flujo de ejecución de un programa. 1. Para poder utilizar cualquiera de las sentencias de control basta con incluir la librería stdio. 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. o un número determinado de veces.h y en esta unidad temática se te van a explicar todas las sentencias del Lenguaje C. Sentencia de control for La sentencia de control for. su interpretación en español puede ser ciclo 90 . o quizá por un número ilimitado de veces o hasta que se cumpla alguna condición. Sentencias de control Mapa de conceptos Unidad III Sentencias de control Sentencia de control for Sentencias de control while y do while Sentencia de control if else Sentencia de control break Sentencia de control switch Sentencia de control goto 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.Fundamentos de Programación Unidad III. Para satisfacer tales necesidades el Lenguaje de programación C brinda al programador herramientas sencillas y eficaces. Sentencias de control Unidad III.

incremento_o_decremento ) { 5 Sentencias o bloque de instrucciones. Para realizar esta acción puedes auxiliarte de los operadores lógicos aprendidos anteriormente. cuando la condición sea verdadera (regrese un 1) el ciclo for se ejecutará continuamente cuando la condición sea falsa (regrese un 0). asignación inicial: En esta instrucción se asigna un valor cualquiera (el que se necesite) a una variable declarada previamente. sentencia de control for 2. por ejemplo. 3. regularmente se incrementa una variable (esta debe ser declarada previamente) la cual interviene en la condición de esta sentencia de control. Incremento_o_decremento: Aquí se puede realizar tanto un incremento como un decremento según sea la necesidad. Sentencias de control . } 6 1. se dejará de ejecutar (puedes agregar más de una condición). esta variable puede ser de cualquier tipo. La sintaxis de esta sentencia de control es la siguiente: 1 2 3 4 for(asignación inicial . cuando la condición no se cumpla las instrucciones dejarán de realizarse. 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. llave de apertura 6... llave de cierre La ejecución de la sentencia de control for se efectúa de la siguiente manera: . 5. Para realizar los incrementos te puedes apoyar en el operador ++ o para los decrementos te puedes apoyar en el operador . 4. condición .Fundamentos de Programación Unidad III. mientras la condición se cumpla las instrucciones se ejecutaran.

Se evalúa la condición que se encuentra después de la asignación inicial. este programa va a calcular 10 puntos de la trayectoria. 3. después se realiza la parte de los incrementos o decrementos que se hayan escrito. y se ejecuta la siguiente instrucción situada después de la llave de cierre ( }). Para realizar el programa se ocuparán las siguientes fórmulas. 4. 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. después este mismo proceso se repite desde el punto 2. no se escribió punto y coma (. depúralo y compílalo porque lo vas a necesitar para la siguiente actividad que realices. Sentencias de control 1.Fundamentos de Programación Unidad III. el cual realiza un movimiento parabólico. Si el resultado es falso (cero) la(s) sentencia(s) no se ejecuta(n).). Ѳ es el ángulo de lanzamiento del proyectil. al final de los paréntesis. mismas que sirven para calcular la trayectoria de un móvil en tiro parabólico: Donde Vi es la velocidad inicial del proyectil. obteniéndose un resultado verdadero o falso (0 ó 1). 2. terminando esta instrucción con un punto y coma. Si el resultado es verdadero (distinto de cero) se ejecuta(n) la(s) sentencia(s) una vez. Observa que en la sintaxis de la línea de código de for. t es el tiempo y g es la gravedad. 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 “(”. Analízalo y después edítalo. 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). .

Fundamentos de Programación Unidad III. Sentencias de control Este es el código fuente del programa: .

Fundamentos de Programación Unidad III. 2. 3. Recuerda participar en el foro de manera respetuosa. Sentencias de control Este es el resultado que debes de obtener al editar. implementada en el código. “¿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. 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. Retroalimenta dos participaciones de tus compañeros. estas en condiciones de participar en el siguiente foro. depurar y compilar el código fuente anterior: Foro 1. además de que lo trabajaste.  Comenta qué modificaciones realizarías al programa para que éste calculara 359854 posiciones (coordenadas en “x” y “y”) del proyectil en tiro parabólico. 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). Tienes que emitir primero tu participación para poder ver las aportaciones de tus compañeros. . la condición y los incrementos que cumplen la sintaxis de la sentencia de control for:  ¿Por qué la sentencia de control for. 4. 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.

Fundamentos de Programación Unidad III. y esto ayuda a ahorrar trabajo al realizar un programa. Esta sentencia se utiliza para ejecutar un número determinado de líneas de código (instrucciones). sigue adelante con tus temas! . ¡Buen trabajo. ya sea una o más veces. Sentencias de control Conclusión: En este tema. se expuso la sentencia for.

Fundamentos de Programación Unidad III. puede ejecutar una o varias instrucciones (líneas de código) cero o más veces. 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 interpretación que se le puede dar en español a esta sentencia es “mientras” (mientras se cumple la condición). en este tema se te explicará cada una. si el auto está apagado no verificara nada. relacional o lógica. como repetir una o más instrucciones (o líneas de código) en lo que se cumple una condición. } Descripción:   La condición indicada después de la sentencia while puede ser cualquier condición numérica. Su sintaxis es la siguiente: while (condición) { Sentencia(s). 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. while La sentencia de control while. así como la diferencia entre ambas. en este contexto es conveniente utilizar una sentencia de control while o una sentencia de control do while. Sentencias de control 2. dependiendo de una condición específica. Se evalúa la condición que se encuentra después de la sentencia while. La ejecución de la sentencia de control while se efectúa de la siguiente manera: 1. 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. . para realizar esta sentencia te puedes apoyar en los operadores lógicos. obteniéndose un resultado verdadero o falso (0 ó 1).

Si el resultado es falso (cero) la(s) sentencia(s) no se ejecuta(n).Fundamentos de Programación Unidad III. y se ejecuta la siguiente instrucción situada después de la llave de cierre ( }). Este programa te permitirá incrementar una variable de forma ininterrumpida. cada incremento debe mostrarse en pantalla a partir del valor inicial hasta llegar al valor final.). depurarlo y compilarlo. El siguiente es el código fuente que permite realizar la acción descrita anteriormente: . 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 (. Sentencias de control 2. 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. 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.

depurar y compilar el código fuente anterior. while ( contador==300 ) Es en estas líneas en las que se encuentra el problema. se te invita a volver a leer el código fuente.Fundamentos de Programación Unidad III. pero ahora con más atención. en ella se ordena ejecutar las instrucciones escritas dentro de las llaves de inicio y cierre ({ } ). siempre y . ahora revisa la sexta línea de código. ¿No funcionó el programa? Si editaste. observa detalladamente las instrucciones en la quinta y sexta líneas de código: int contador = 301. Sentencias de control En la imagen siguiente se muestra el resultado de editar. No te preocupes los errores son muy comunes en la programación. 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. depuraste y compilaste el código fuente anterior pudiste constatar que el programa no funciono como se requería. el puede ayudarte y aclarar tus dudas. busca el posible error y recuerda que puedes ponerte en contacto con tu asesor. 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. sin embargo. como puedes ver.

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. “Nuevo resultado” El resultado de editar depurar y compilar el código fuente ya corregido es el siguiente: . ya que tu aprendizaje será mejor si experimentas lo que se te indica. como ya observaste la variable “contador” fue declarada con un valor de 301. Ahora que ya sabes dónde estuvo el error. es decir que la variable “contador” sea igual al valor 300. no continúes con la lectura hasta que realices esto que se te pide.Fundamentos de Programación Unidad III. Sentencias de control cuando se cumpla la condición entre paréntesis ( contador==300 ). 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ó. depurar y compilar el programa. 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.

\n". 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).Fundamentos de Programación Unidad III. recuerda que a la computadora se le debe indicar exactamente lo que tiene que hacer. la condición solamente se cumplirá si contador almacena un valor igual a 300. } 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. el operador más apropiado para este caso es el operador < (menor que) .. pues bien. Observa el siguiente ejemplo del resultado de compilar el código fuente ya corregido. . por lo que la corrección al código fuente debe ser de la siguiente manera: while ( contador < 300 ) { contador++. Sentencias de control ¡Upss! ¿Aun no funciona? El programa sigue sin funcionar. ese es el problema. entonces no se esta utilizando el operador de comparación adecuado a las necesidades de este programa. lo cual indica que existe otro error en el código fuente. printf( "La variable contiene un: %i. contador ). no te desesperes solo tienes que revisar con mucho detalle tu código fuente.

} while (condición).Fundamentos de Programación Unidad III. dentro de la cual se escribió la comparación siguiente: (contador < 300). con la diferencia de que en la sentencia do while las instrucciones escritas dentro de { y } se ejecutan por lo menos una vez. . Recuerda: cualquier duda que tengas. enseguida se implemento la sentencia de control while. 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. Sentencias de control Explicación: En el código fuente anterior dentro de la función principal main() se declaro una variable de tipo int llamada contador. para enseguida mostrar el contenido de esta variable por pantalla y después de esto volverá a evaluar si contador es menor que trescientos. 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). 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. puedes consultar a tu asesor. la cual fue iniciada con cero. do while La sentencia de control do while es muy similar a la sentencia de control while.

las instrucciones antes mencionadas se ejecutaran continuamente hasta que la condición deje de cumplirse. sea falsa. al revisarlo podrás notar la diferencia entre las sentencias while y do while . relacional o lógica. Nota: La condición es cualquier condición numérica.) Se te presenta el ejemplo de un programa en el que se utiliza la sentencia de control do while. 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. Observa que después del paréntesis de cierre de la condición se escribe punto y coma (. 3. para después evaluar la(s) condición(es) escrita(s) dentro de los paréntesis escritos delante de la palabra reservada while. Si el resultado es falso (cero) la(s) sentencia(s) no vuelven a ejecutarse.Fundamentos de Programación Unidad III. 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. y se ejecuta la siguiente instrucción situada después del paréntesis final de la sentencia while. 4. si las condiciones se cumplen. Se evalúa la condición. obteniéndose un resultado verdadero o falso (0 ó 1). Se ejecutan una vez las instrucciones escritas dentro de las llaves de apertura y cierre ( { } ) 2. Sentencias de control 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. es decir. La ejecución de la sentencia de control do while se efectúa de la siguiente manera: 1.

depurar y compilar este programa es el siguiente: . Sentencias de control El código fuente: Aparentemente se volvió a cometer el error de iniciar a la variable contador con 301. El resultado de editar. debido a la sentencia de control do while.Fundamentos de Programación Unidad III. pero esta vez las instrucciones escritas dentro de { y } se ejecutaran por lo menos una vez.

Fundamentos de Programación Unidad III. Sentencias de control 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 .

son el bloque de instrucciones que se ejecutarán si la condición escrita dentro de los paréntesis de la sentencia se cumple.Fundamentos de Programación Unidad III. 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. inducir la ejecución del programa por un camino u otro. para la realización de esta sentencia el programador se apoya en los operadores lógicos. 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. a partir de un resultado obtenido. La sentencia de control if else permite re-direccionar la ejecución de un programa. si el programa detecta un resultado verdadero (1) se ejecutan cierto bloque de instrucciones. Su traducción aproximada es: If (si) / Else (de lo contrario). Las instrucciones que se escriben dentro de las llaves de apertura y cierre que se encuentran inmediatamente después de la sentencia if(condicion). estudiados en la unidad temática 2. es decir. . es decir. relacional o lógica. 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. Sentencias de control 3. pero si detecta un resultado falso (0) se ejecutara otro bloque de instrucciones distinto.

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. este programa debe indicar al usuario que introduzca un número entero cualquiera y después presione la tecla enter. el programa ejecutará la instrucción que se encuentre inmediatamente después de la llave de cierre ( } ). Se evalúa la condición. obteniéndose un resultado verdadero o falso (0 ó 1). 2.Fundamentos de Programación Unidad III. de este mismo bloque. 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). 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. 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. y dentro de las llaves de apertura y cierre. El programa escrito en Lenguaje C que ejecuta las instrucciones anteriormente mencionadas es el siguiente: . Sentencias de control Las instrucciones que se escriben dentro de las llaves de apertura y cierre ( { } ) que se encuentran inmediatamente después de la palabra reservada else. Ya que se hayan ejecutado las instrucciones de este bloque. el cual debes editar depurar y compilar. 3. 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. La ejecución de la sentencia de control if else se realiza de la siguiente manera: 1.

Sentencias de control El resultado de editar. en el caso de que se introduzca un número entero par.Fundamentos de Programación Unidad III. depurar y compilar este código fuente es el siguiente. Y en el caso de que se introduzca un número entero no par: .

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. escrita entre { y } esta línea debajo de la palabra reservada else. es decir colocar otra sentencia if después de la palabra reservada else. El residuo.h. 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. es decir. Después de ejecutar cualquiera de los dos bloques de instrucciones se ejecuta la función system(“PAUSE”). entonces se ejecutará la línea de código. es decir no se cumple.Fundamentos de Programación Unidad III. printf( "\nEl número es par \n"). 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.0 y %(modulo) devuelve únicamente el residuo de la división no la parte entera. . es decir se cumple. 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. Esto ya sabes cómo hacerlo. ya que 9/2 = 4. escrita entre { y } esta línea debajo de la sentencia if(numero%2 == 0). 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. 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. printf( "\nEl numero no es par \n"). El residuo. 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 dentro de la función principal main() se utiliza la función scanf(). esto se hace para evaluar más de una condición. que es la última función en ejecutarse dentro de la función principal main(). ya que 56554/2 = 28277. y entonces se ejecutará la línea de código. Sentencias de control Explicación: En este programa se incluyó la librería conio. por ejemplo si se necesitara el mismo programa presentado en el ejemplo anterior con algunas variantes.5 y %(modulo) devuelve únicamente el residuo de la división no la parte entera.  If else if Es posible anidar.

Fundamentos de Programación Unidad III.} . Sentencias de control El programa escrito en Lenguaje C que ejecuta las instrucciones anteriormente mencionadas es el siguiente: 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").

Si esta condición no se cumple es decir. se ejecuta la siguiente línea de código: {printf( "\nEl numero es mayor que 60\n "). Sentencias de control Cuyo resultado en pantalla será el siguiente. Si esta otra condición no se cumple (que el número sea mayor que 30 y menor que 60).Fundamentos de Programación Unidad III. es decir que el número sea mayor de 60. 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.}} 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. 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 "). en este caso el operador lógico AND (&&) visto anteriormente.} .

permitiendo así ejecutar un bloque de instrucciones u otro distinto de acuerdo al resultado de una condición especificada. 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.Fundamentos de Programación Unidad III. Sentencias de control Cuyo resultado en pantalla será el siguiente. Además de ser posible la anidación de sentencias de control if else if. ¡Buen trabajo! Sigue adelante con el tema 4 .

Sentencia de control for. El programa escrito en Lenguaje C que ejecuta las instrucciones anteriormente mencionadas es el siguiente: . ya que a esta altura no es necesario monitorear al proyectil. 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. Pero ahora se le agregará una condición especial.Fundamentos de Programación Unidad III. Para ejemplificarte esta sentencia se retomara el programa realizado en el tema 1. 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. 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. el cual calcula y muestra en pantalla las coordenadas cartesianas de un proyectil en tiro parabólico. aún cuando la condición del ciclo for se cumpla (sea verdadera). Sentencias de control 4. de acuerdo a una condición dada. antes de que este termine de ejecutarse.

printf( " Cual es el angulo de lanzamiento: ").Fundamentos de Programación Unidad III. {break. coordenada en y %f. if(y >= 5000) Si se cumple ejecuta break. ang = ((ang*PI)/180).y=0. únicamente se detallarán las líneas de código que se agregaron: if(y >= 5000) {break. printf( "\n Cual es la velocidad inicial de lanzamiento: ").t <= 10. } . for (t=1. } else printf( "\n Coordenada %i en x = %f.x. float x=0.ang. t++) { x = (vi*cos(ang)*t).81 #define PI 3.h> #include <math. Sentencias de control #include <stdio.h> #define grav 9.vi. ".y).h> #include <windows.141592 int main () { int t. scanf("%f".t. scanf("%f".5*grav*t*t)). y = ((vi*sin(ang)*t)*(0. } Explicación: El código fuente anterior ya se explico en el tema 1 (revísalo).&ang). Si no sigue la ejecución de for } system ("PAUSE").&vi).

ejecución un valor mayor o igual a 5000. en esta caso esa línea invoca a la función system(“·PAUSE”). el ciclo for se hubiera ejecutado normalmente calculando las diez coordenadas para lo cual fue declarado. 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. . al ejecutarse esta sentencia se rompe el ciclo for (ya no se sigue ejecutando). 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.Fundamentos de Programación Unidad III. 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. Sentencias de control else Como se puede observar en la línea de código de la sentencia if(y >= 5000). Pero si el ángulo hubiese sido mucho menor.

¡Muy bien. buen trabajo! Sigue adelante . Sentencias de control 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.Fundamentos de Programación Unidad III.

pero su formato es más claro. esta es la sentencia de control switch. 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).Fundamentos de Programación Unidad III. Sentencia de control switch Introducción Ya conoces el funcionamiento y aplicación de la sentencia de control If else. La sintaxis de la sentencia de control switch es la siguiente: . pero y ¿si son muchos caminos?. Sentencias de control 5. switch La sentencia de control switch permite al programador re-direccionar el flujo de ejecución de un programa. es decir. su funcionamiento es semejante al anidamiento de la sentencia de control if else. esta decisión se toma con base en la evaluación de una condición. podrías pensar que la solución está en el anidamiento de la sentencia if else if. regularmente esta sentencia de control se utiliza para elegir una opción de varias disponibles de acuerdo a un menú mostrado en pantalla. pero el Lenguaje C brinda una herramienta aún más sencilla que la sentencia de control if else. ejecutar un bloque de instrucciones u otro.

Una etiqueta es una instrucción que únicamente sirven como referencia para el compilador.Fundamentos de Programación Unidad III. case opción_1: es una etiqueta (sin incluir la palabra reservada case). Se evalúa el contenido de variable. no muestran nada en pantalla y no realizan ninguna operación. Case es una palabra reservada que se utiliza únicamente con la sentencia de control switch. Sentencias de control 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). 2. Las instrucciones que se escriban dentro de { y } debajo de la línea de código switch(variable). es decir. por ejemplo si se tiene la siguiente sentencia de control switch: . se ejecutará el bloque de instrucciones escrito después de esta etiqueta. esta palabra siempre tiene que estar acompañada por una etiqueta escrita inmediatamente después y separada por un espacio en blanco. 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í. no se ejecutan. al final de la línea de código de una etiqueta se pone el operador : (dos puntos). para nombrar una etiqueta se toman las mismas reglas que para nombrar una variable o una constante. Si el contenido de variable corresponde con alguna de las etiquetas escritas en alguno de los casos (case). 1. la interpretación más adecuada para la misma es “caso”. como puedes ver en el código fuente anterior hay dos etiquetas opción_1: y opción_2:.

se ejecutaría el bloque de instrucciones escrito debajo de la etiqueta default: ejecutándose igual que los casos anteriores. Pero si variable almacena un 2.Fundamentos de Programación Unidad III. . después de ejecutarse esta instrucción se realiza la instrucción sentencia de control break. 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. Sentencias de control Si variable almacena un 1. este valor almacenado corresponde con la etiqueta escrita en el segundo caso. después de ejecutarse esta instrucción se realiza la instrucción sentencia de control break. es decir que no corresponda con ninguna etiqueta. este valor almacenado corresponde con la etiqueta escrita en el primer caso. Pero si variable almacena un número diferente. permite romper la acción de otra sentencia de control. la cual como ya sabes. 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. Entonces se ejecutará la instrucción a = a+b. y posteriormente la siguiente sentencia en desarrollarse será la que este escrita inmediatamente después de } de la sentencia de control switch.

Para mostrar tu segundo apellido en pantalla presiona 3. El programa escrito en Lenguaje C que ejecuta las instrucciones mencionadas es el siguiente: . Para mostrar tu primer apellido en pantalla presiona 2. y de acuerdo al valor que almacene la variable opción se ejecutará el caso que muestre únicamente la información correspondiente. de la siguiente forma:    Para mostrar tu nombre en pantalla presiona 1.Fundamentos de Programación Unidad III. Para ejemplificar lo anteriormente explicado se te mostrará un programa escrito en Lenguaje C que muestra un menú de opciones en pantalla. Sentencias de control Nota: La sentencia de control switch puede tener el número de casos que desees. El número que el usuario del programa tecle se almacenara en una variable llamada opción de tipo int.

} system ("PAUSE").Fundamentos de Programación Unidad III. switch( opcion ) { case 1: printf( " RoDrIgO \n" ).\n " ). printf( " Para mostrar tu primer apellido en pantalla presiona 2. scanf( "%i". &opcion ). case 3: printf( " ViLlArEaL \n" ). printf( " Para mostrar tu segundo apellido en pantalla presiona 3.h> #include <windows. } . break.h> #include <conio. case 2: printf( " AvIlEs \n" ). printf( " Para mostrar tu nombre en pantalla presiona 1.\n " ). default: printf( " nO ES UN CASO VALIDO\n" ). break.\n " ). Sentencias de control #include <stdio. break.h> int main() { int opcion.

Sentencias de control El resultado de editar. depurar y compilar este código fuente es el siguiente: 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: .Fundamentos de Programación Unidad III.

Sentencias de control Explicación: En este programa escrito en Lenguaje C. Conclusión La sentencia de control switch permite ejecutar un 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. Esta sentencia de control puede tener el número de casos que el programador decida. de no coincidir el valor de dicha variable con ninguna etiqueta se ejecutar un bloque de instrucciones escrito en un caso llamada default. el cual también muestra una cadena de texto indicando el error. siempre y cuando corresponda a una etiqueta previamente escrita en alguno de los casos (case) de la sentencia switch.Fundamentos de Programación Unidad III. ¡Bien! ¡Sigue con el último tema! . de varios disponibles de acuerdo al contenido de una variable de cualquier tipo. 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.

no se ejecutan.Fundamentos de Programación Unidad III. no muestran nada en pantalla y no realizan ninguna operación. goto La sentencia de control goto permite re-direccionar la ejecución del programa saltando bloques de código hasta encontrar una etiqueta. /*líneas /*líneas de codigo*/ de codigo*/ goto E. al final de la línea de código de una etiqueta se escribe el operador : (dos puntos).Sentencia de control goto Introducción: Con este tema. La interpretación en español del nombre de esta sentencia seria: “Ir a”. . Sentencias de control 6. Recuerda que: Una etiqueta es una instrucción que únicamente sirven como referencia para el compilador. para realizar esto el Lenguaje C brinda al programador la sentencia de control goto. E: Como puedes ver la etiqueta se puede escribir debajo de la instrucción goto. finalizas el estudio de la unidad temática III y con ella el conocimiento de las sentencias de control. es decir. para nombrar una etiqueta se toman las mismas reglas que para nombrar una variable o una constante. Ahora conocerás como re-direccionar el flujo de ejecución de un programa saltando bloques enteros de código. A continuación se te muestran dos formas de sintaxis de esta sentencia de control: Sintaxis 1: Sintaxis 2: E: goto E.

Fundamentos de Programación
Unidad III. Sentencias de control

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á redireccionada, 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()
{
printf( " RoDrIgO \n" );
goto Aqui;
printf( " AvIlEs \n" );

Re++direccionamiento, salto de la instrucción.

Fundamentos de Programación
Unidad III. Sentencias de control
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.
El programa escrito en Lenguaje C que ejecuta las instrucciones anteriormente
mencionadas es el siguiente:

Fundamentos de Programación
Unidad III. Sentencias de control
#include <stdio.h>
#include <conio.h>
#include <windows.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:
printf( " RoDrIgO \n" );
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*/

Fundamentos de Programación Unidad III. El ángulo de giro de este motor a pasos es de 1. (45 grados hacia arriba y 45 grados hacia abajo). Sentencias de control El resultado de editar depurar y compilar este código fuente es el siguiente. es decir nunca terminara. este motor debe mover el alerón de un avión en un rango de 90 grados. “Aplicando las sentencias de control” Instrucciones: 1. En el siguiente video se te muestra como debe ser el movimiento de los alerones: . Actividad integradora 2. Muy bien. 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. este motor proporcionara el impuso necesario para que se mueva un alerón.8 grados por paso. 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. es momento de aplicar tu aprendizaje mediante la realización de una actividad integradora. 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. Explicación: Al colocar la sentencia de control goto INICIO.

El usuario del programa debe escoger de un menú de opciones la dirección en que se moverá el alerón. 5. con la diferencia de que ahora el alerón se moverá hacia abajo. el programa se comportará de forma similar que en la opción número 1. 4. el programa únicamente ejecuta 7 pasos. De esta forma: 3. por lo anterior debes asegurar que el programa no acepte un número de pasos que sobrepase este rango de movimiento. 4.Fundamentos de Programación Unidad III. 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). observa la siguiente imagen: . 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. 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. Sentencias de control 2. el programa debe preguntar el número de pasos que se moverá el alerón. por este motivo los datos enviados al puerto deben ser invertidos. 8. 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. Si se escoge la opción número 2. hacia arriba o hacia abajo. 2. 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. Si se elijen las opciones 1 ó 2.6 grados. Observa la siguiente imagen la cual te muestra el resultado que se obtiene.

Sentencias de control 6. de esta forma: .Fundamentos de Programación Unidad III. el programa debe permitirlo sin tener que volver a ejecutarse.6 grados y se quedo en esta posición (estático). Si después de elegir una opción el usuario desea elegir otra diferente. que fue lo que el usuario tecleo. 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. es decir. Como puedes observar se repitió 3 veces el ciclo de 4 pasos para que el motor girara exactamente 12 pasos. el rotor del motor giro exactamente 21. hasta que el usuario elija la opción correspondiente a salir. 7.

se mueva nuevamente 1. el cual te va a ayudar mucho para la realización de esta actividad.8 grados y se quede estático en esa posición (hasta ahora abra girado 3. Ya que hayas terminado de leer la información referente a los motores a pasos por favor revisa el siguiente archivo (Material de apoyo).6 grados) es necesario que el programa envié un numero 2 a la pantalla de la computadora.Fundamentos de Programación Unidad III. Para que un motor se mueva un primer paso es decir únicamente se mueva 1. Da clic en el siguiente título para que se te muestre el ejecutable. da clic en el siguiente título para que te aparezca dicha información: 10. Sentencias de control 8. Para que el motor se mueva un segundo paso es decir. . 9. 2.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). es decir el resultado a donde debes llegar. la cual te lo explicará. 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. Si no conoces el funcionamiento de un motor a pasos puedes revisar la información que se te muestra a continuación. 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.

13.4 grados) es necesario que el programa envié un numero 4 a la pantalla de la computadora.8 grados y se quede estático en esa posición (hasta ahora abra girado 5. comenzando por el punto 1. El archivo que debes enviar a tu profesor para que se te evalúe es el código fuente.8 grados por paso gire una vuelta completa. 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 . Recuerda que: Para que un motor a pasos que posee un ángulo de giro de 1. de esta forma: Numero de paso Paso 1 Paso 2 Paso 3 Paso 4 Dato enviado 8 4 2 1 11. Recuerda que si tienes alguna duda puedes pedir la ayuda de tu asesor. Numero de paso Paso 1 Paso 2 Paso 3 Paso 4 Dato enviado 1 2 4 8 Si deseas que el motor se mueva en sentido contrario se invierte el orden de los datos enviados.Fundamentos de Programación Unidad III. se mueva nuevamente 1. nuevamente se mueva 1. Para que el motor se mueva un cuarto paso es decir. Para que el motor se siga moviendo es necesario repetir los pasos anteriores. 4. Ya tengas listo tu programa. edítalo. 5.c que se creó.2 grados) es necesario que el programa envié un numero 8 a la pantalla de la computadora. éste tendrá que dar 200 pasos. en otras palabras tendrías que repetir la siguiente secuencia 50 veces.8 grados y se quede estático en esa posición (hasta ahora abra girado 7. Para que el motor se mueva un tercer paso es decir. es decir el archivo con extensión . Sentencias de control 3. depúralo y compílalo en el compilador Dev C++ 12. lo que haría un ciclo.

¡Sigue adelante con la unidad 4! . 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. y con ella has adquirido más conocimientos que te van a ser útiles al realizar programas en Lenguaje C. Sentencias de control Conclusión: Muy bien. Solo falta una unidad para que concluyas esta unidad de aprendizaje. 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. hasta el momento sabes cómo repetir un bloque de instrucciones determinado número de veces utilizando a la sentencia for. acabas de terminar la unidad temática III.Fundamentos de Programación Unidad III.

esta herramienta es conocida con el nombre de arreglos (arrays). imagina cuanto trabajo representaría esto. Estructuras de datos Mapa de conceptos Introducción: Hasta ahora conoces los diferentes tipos de variables con que cuenta el Lenguaje C. 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). flexible y sencilla para hacer más sencilla la declaración y manejo de una gran cantidad de variables del mismo tipo. ¿Pero.Fundamentos de Programación Unidad IV. Estructuras de datos Unidad IV. Estos son dos elementos de un mismo arreglo. qué pasa cuando es necesario declarar una gran cantidad de variables?. 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 133 . y esto es lo que veremos en esta unidad. 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. además de que posiblemente tal declaración ocupará más de una línea de código. además de la complejidad de leer y entender un código tan extenso a consecuencia de tantas declaraciones. aunque no es difícil declarar una variable quizá pueda ser laborioso declarar 24 variables y todas con distinto nombre. tendrías que declarar veinticuatro variables. por ejemplo si quisieras almacenar y promediar el valor de la temperatura de cada hora del día. sabes cómo declarar variables y asignar un valor a las mismas. El Lenguaje C brinda al programador una herramienta eficaz. Por ejemplo el arreglo: numero[20] y numero[21]. 1.

int. nombre: corresponde al nombre del arreglo. [tamaño]: Lo encerrado entre corchetes (índice) es el tamaño del arreglo. en esta unidad de aprendizaje. es decir el número de variables que forman al arreglo. Estructuras de datos se diferencian por el índice. matrices o vectores. es decir cuando el programa está funcionando. es decir el numero entre los corchetes [ y ]. Por tanto. En este caso también se declaro un arreglo de tres variables de tipo entero llamadas num[0]. Una alternativa para realizar esta misma declaración es la siguiente: Int r =3. se va a usar el término arreglo. por ejemplo char. es posible omitir en la declaración de un arreglo el tamaño y posteriormente se puede asignar. todos los arreglos usan cero como índice para el primer elemento. Con esta línea de código se están declarando tres variables de tipo entero llamadas num[0]. Se te muestra un ejemplo en el que se declara un arreglo de números enteros llamado num con tres elementos. por ejemplo en tiempo de ejecución. Descripción: Tipo: es cualquier tipo de variable. int num[r].Fundamentos de Programación Unidad IV. float o doublé. Observa que el tamaño del arreglo está determinado por el valor de la variable r. el ejemplo anterior declara un arreglo de enteros con tres elementos desde num[0] hasta num[2]. num[1] y num[2]. En el Lenguaje C. Nota: Los arreglos también son conocidos con los nombres de arrays. Sin embargo. . este nombre obedece a las mismas reglas que el nombre de una variable o el de una constante. Esta es la sintaxis necesaria para declarar un arreglo: Tipo nombre [ tamaño ]. Entonces uno se llama numero[] con índice veinte y el otro numero[] con índice veintiuno. num[1] y num[2]. este puede estar determinado por el valor que almacena una variable o una constante y debe de ser un número entero. lo cual se hace de la siguiente forma: int num[3].

18. num = listA[2]. el cual vas a utilizar en la siguiente actividad que realices: . analiza el siguiente código fuente. /* 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. como puedes observar el valor de 15 se le dio al tercer elemento. 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.Fundamentos de Programación Unidad IV. num[1] y num[2]. /* Asigna 15 al 3er elemento del arreglo llamado num*/ Con este arreglo se obtendrán dos elementos: num[0] y num[15]. 23. int listA[3]. además de que los números asignados están separados por el operador coma (. listA[2] = 3. 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. El elemento 1 (el segundo) almacenara un 18 y el último elemento es decir. para asignar un valor a un elemento de un arreglo se hace lo siguiente: num[2] = 15. Como puedes observar se utilizaron los operadores { } (llaves de apertura y cierre) para realizar la asignación.). 20. 25 }. Estructuras de datos Siguiendo con el ejemplo anterior. 25. Recuerda que existe el elemento num[0]. el decimo almacenara un 25. 22. 26. Ahora el primer elemento que será temp[0] almacenará un 15. 22. 24.

hora++ ) { printf( "La temperatura a las %i hrs.22. el tercer elemento temp[2].h> #include <windows.16.14.20.24.13.24.14. La línea de código anterior declara un arreglo de tipo entero (tipo de variable) llamado temp[ ].15.26.25.12}.14. Enseguida se encuentra la siguiente línea de código: int temp[24]={15.20.17.\n".14. hora<24 .25.22. } El resultado de editar. es decir el primer elemento del arreglo temp[0] almacena un quince.25. (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.14.17. } system ("PAUSE").21. Estructuras de datos #include <stdio.18.26.22.22. dentro de la función principal main() se declaro una variable llamada hora de tipo entero de esta forma: int hora.18.17. depurar y compilar este código fuente es el siguiente: Explicación: En la primer línea de código.23. hora.22.23.21.14. era de %i grados.15.24.20.24.1 3.h> int main () { int hora.12}.22.25. el tamaño de este arreglo es veinticuatro.18. almacena un 20 y así sucesivamente hasta el último elemento del arreglo temp[23] que almacena un .20. temp[hora] ). for (hora=0 . el segundo elemento temp[1] almacena un dieciocho.18.Fundamentos de Programación Unidad IV.16. int temp[24]={15.17.

observa que se utilizaron los operadores { y } para realizar la asignación. Ya sabes lo que es un arreglo y como funciona. hasta que deje de cumplirse la condición de la sentencia de control for. ¿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". 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. La función printf() muestra la hora y el contenido de cada uno de los elementos que componen el arreglo. Observa la siguiente línea de código que pertenece al código fuente anterior: printf( "La temperatura a las %i hrs. Después de ejecutarse una vez la función printf() se incrementa la variable hora en una unidad. for (hora=0 . hora++ ) por lo tanto la primera vez que se ejecuta printf() el número de elemento que se mostrara en pantalla será temp[0]. Y así se irán mostrando uno a uno el contenido de cada uno de los elementos del arreglo. hora. hora. 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. temp[hora] ). era de %i grados. además de que los números asignados están separados por el operador coma ( . temp[hora] ). observa que la sentencia de control for ejecutara 24 veces la función printf() que se encuentra entre { y } de la sentencia for. 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. uno por uno es decir primero muestra el contenido del elemento cero temp[0] (se mostrara un numero quince en pantalla). hora<24 . (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]. Estructuras de datos doce. ya que así lo indica la condición hora<24. ). 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.\n".Fundamentos de Programación Unidad IV. . esta variable fue iniciada con cero.

3. es decir el archivo con extensión . depura y compila el código fuente que se te acaba de explicar. “Arreglos unidimensionales” Instrucciones: 1. 2. 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 Muy bien. compilado y funcione correctamente el programa sube a la plataforma para su evaluación el archivo del código fuente. depurado. almacena y realiza la media aritmética del muestreo realizado al altímetro de un avión tipo Cessna 500 Citatio. Ya que hayas editado.com/INS/INS23.html 1. como no cuentas con un altímetro y la interfaz electrónica para conectar este instrumento de medición a la computadora. se mostrará en pantalla la información introducida. Edita.Fundamentos de Programación Unidad IV. Imagina que eres el encargado de realizar un programa que monitorea. Recuerda que si te surgen dudas debes consultar a tu asesor.c que se creó. consulta la siguiente dirección: http://www. como funciona y para qué sirve. 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. 2. Estructuras de datos Actividad de aprendizaje 13. “Mas arreglos” Instrucciones: Para realizar correctamente el programa es necesario que conozcas que es un altímetro. el usuario del programa simulará estas lecturas introduciendo el valor de la altitud por el teclado. en vuelo. para corroborar que se almaceno correctamente en cada uno de los elementos del arreglo. . 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.manualvuelo. continúa practicando la implementación de arreglos en un programa realizando la siguiente actividad: Actividad de aprendizaje 14. 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. El programa que vas a realizar debe monitorear las mediciones que realiza el altímetro instalado en el avión.

Además de monitorear. después de mostrar esta información el programa se repetirá indefinidamente. Su tarea es declarar más de una variable del mismo tipo en una sola línea. además se debe mostrar en pantalla la media aritmética de dichas mediciones. 4. El programa únicamente monitoreara y almacenara 10 lecturas. es decir el contenido de las diez variables que almacenan estos valores. depurado. while o Do while. ¡Buen trabajo. (toma como referencia 4500 ft a 5000ft como una altitud apropiada). 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: Un arreglo que también es conocido con el nombre de array. 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. 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. Estructuras de datos 3. Ya que hayas editado. matriz o vector es un conjunto de variables del mismo tipo (tipo de variable) cuyo nombre se diferencia en el índice. incluso en tiempo de ejecución del programa.c que se creó. 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. 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. es decir el archivo con extensión . compilado y funcione correctamente el programa súbelo a la plataforma para su evaluación el archivo del código fuente. 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.Fundamentos de Programación Unidad IV. sigue adelante! . 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.

Por ejemplo el arreglo: nombre[7] y nombre[2]. pero qué sucede si es necesario introducir y almacenar una palabra o frase tecleada por el usuario ¿es posible?. resolver este problema? Por Los arreglos de caracteres son un conjunto de variables de un mismo tipo (tipo de variable char) cuyo nombre se diferencia en el índice. Estructuras de datos 2. es decir el numero entre [ y ]. en esta unidad de aprendizaje. Recuerda que el tipo de variable char permite almacenar un solo carácter por cada variable. Entonces uno se llama nombre[ ] con índice siete y el otro nombre[ ] con índice dos. entonces. 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). 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. Esta es la sintaxis necesaria para declarar un arreglo de caracteres: char nombre [ tamaño ]. Sin embargo. 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(). 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. ¿Ya sabes cuál es la herramienta que utilizaras para supuesto. Nota: Los arreglos de caracteres también son conocidos con el nombre de strings o cadenas de texto. . 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. si por ejemplo.Fundamentos de Programación Unidad IV. vamos a usar el término arreglo de caracteres. los arreglos. Estos son dos elementos de un mismo arreglo.

A continuación se te muestra un ejemplo en el que se declara un arreglo de caracteres llamado nom con tres elementos. Por tanto. El tamaño del arreglo de caracteres puede estar determinado por el valor que almacena una variable o una constante. es decir. Recuerda que en el Lenguaje C. es decir. lo cual se hace de la siguiente forma: char nom[3]. . Es posible omitir en la declaración de un arreglo de caracteres el tamaño. Estructuras de datos Descripción: char: es el tipo de variable capaz de almacenar un carácter dentro de una variable. nom[1] y nom[2]. Una alternativa para realizar esta misma declaración es la siguiente: Int r =3. este nombre obedece a las mismas reglas que el nombre de una variable o el de una constante. nombre: corresponde al nombre del arreglo de caracteres. char nom[r]. nom[1] y nom[2].Fundamentos de Programación Unidad IV. Observa que el tamaño del arreglo está determinado por el valor de la variable r. todos los arreglos usan cero como índice para el primer elemento. en tiempo de ejecución. el ejemplo anterior declara un arreglo de caracteres con tres elementos desde nom[0] hasta nom[2]. para posteriormente asignarlo. el tamaño de un arreglo de este tipo debe de ser un número entero. el número de variables que forman al arreglo. Con esta línea de código se está declarando a tres variables de tipo char llamadas nom[0]. por ejemplo. En este caso también se declaró un arreglo de tres variables de tipo char llamadas nom[0]. [tamaño]: es el tamaño del arreglo de caracteres. cuando el programa está funcionando.

/* 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'. char listA[3]. /* 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. nom = listA[2]. Estructuras de datos Siguiendo con el ejemplo anterior.'m'. /* 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 (“).'L' }. dos formas de asignar un valor a un elemento de un arreglo son las siguientes: nom[2] = ‘A’. esto se debe a que es un solo carácter el que se está asignando. El segundo elemento que es nom[1] almacenará un carácter m.'U'. analízalo: . 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.'e'. listA[2] = ‘x’.Fundamentos de Programación Unidad IV. En este arreglo el primer elemento que es nom[0] almacenará un carácter E.'n'.'A'. 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. nom[2] = 65.

Fundamentos de Programación Unidad IV. depurar y compilar este código fuente es el siguiente: 1er sentencia for 2da sentencia for 3er sentencia for . Estructuras de datos El resultado de editar.

uno por uno. } Esta sentencia de control for. h++ ) { printf( "El elemento %i del arreglo. . es decir. almacena este carcater %c. 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. h<7 . así hasta almacenar en el último elemento de el arreglo el carácter L.\n".'L' }. Estructuras de datos 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. mostrará en pantalla el contenido de cada uno de los elementos del arreglo. Observa que dentro de la función printf() se colocó el modificador %c.'U'. nom[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'. el cual indica a esta función que el tipo de variable que se mostrará en pantalla es de tipo char. Enseguida se encuentra la primera sentencia de control for de este código fuente.'A'. en nom[6] se almacenó el carácter L. es decir a nom[0] se le asigna el carácter E.'m'. Al primer elemento que conforma el arreglo de caracteres.'e'. h. de esta forma: for (h=0 .'n'. desde el elemento cero hasta el elemento seis mostrando en pantalla el siguiente resultado: ¿Por qué se muestran estos caracteres en pantalla? Respuesta. al segundo elemento que es nom[1] se le asigna el carácter m.Fundamentos de Programación Unidad IV.

\n". 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: for (h=0 . h. } Cuyo resultado en pantalla es el siguiente: Como puedes observar. h++ ) { printf( "El elemento %i del arreglo. y guardar esta información en el arreglo llamado nom[ ]. perdiéndose la anterior información almacenada. nom[h] ). 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). 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. . 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ó. nom ). almacena este caracter %c. Estructuras de datos Ahora observa las siguientes líneas de código del programa: printf( "\n\n Ahora introduce un nombre con menos de 7 caracteres: "). es decir EmAnUeL). scanf( "%s". h<7 .Fundamentos de Programación Unidad IV.

No. h<7 .\n". el nombre teclado es BENJAMIN. nom[h] ). permaneció intacto. Estructuras de datos Nota que el quinto elemento muestra un espacio en blanco en la pantalla. ¿Tú crees que se haya tecleado ese espacio en blanco? Respuesta. al presionar esta tecla se añade un carácter especial al arreglo de caracteres. h++ ) { printf( "El elemento %i del arreglo. Observa que también en el último elemento. Por último encontrarás las siguientes líneas de código: printf( "\n\n Ahora introduce un nombre con mas de 7 carcateres: "). el séptimo (nom[6]) se muestra que aun existe el carácter L. Este carácter especial no es imprimible en pantalla por eso se observa un espacio en blanco. el carácter de fin de cadena \0. que sirve para indicar a la función scanf() que ya no hay más caracteres que almacenar. scanf( "%s". este carácter se almacena precisamente en el elemento número cinco que es nom[4]. con la única diferencia de que ahora el nombre tecleado está compuesto por más de siete caracteres. por lo tanto el último elemento del arreglo nom[6] no fue reescrito ni borrado. de la palabra EmAnUeL. h. nom ). 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). el resultado en pantalla de estas líneas de código es el siguiente: . } Estas líneas de código realizan exactamente el mismo trabajo que las anteriormente explicadas. se lee diagonal invertida cero. almacena este caracter %c. que se almacenaron en el arreglo de caracteres solamente ocuparon 6 elementos y no siete. for (h=0 . después de teclear el ultimo carácter de la palabra Josue se presionó la tecla enter.Fundamentos de Programación Unidad IV. es decir.

Conclusión: Un arreglo de caracteres que también es conocido con el nombre de array. sigue adelante! . 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. 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. este carácter se pierde. matriz o vector es un conjunto de variables del mismo tipo (tipo de variable char) cuyo nombre se diferencia en el índice.Fundamentos de Programación Unidad IV. Estructuras de datos Como puedes observar no se almaceno el último carácter del nombre BENJAMIN. ¡Muy bien hecho. la N ya que no hay un elemento (una variable) para poder realizar esta operación. while o Do while. incluso en tiempo de ejecución del programa. Su tarea es declarar más de una variable de tipo char en una sola línea.

Esta es la sintaxis necesaria para declarar un arreglo bidimensional: Tipo 1 nombre [ filas 3 ][ columnas ]. float o doublé. tales declaraciones ocuparán varias líneas de código restando legibilidad al código fuente. Arreglos bidimensionales: Los arreglos bidimensionales son un conjunto de variables del mismo tipo (tipo de variable) agrupadas en filas y columnas. 2 Nombre: corresponde al nombre del arreglo. cuyo nombre se diferencia en el índice (números entre corchetes). 2 4 1 Tipo: es cualquier tipo de variable. por ejemplo char. por ejemplo: Si fuera necesario almacenar las temperaturas de todo un día. es decir el número de filas (variables) que forman la primera dimensión del arreglo. es posible omitir en la declaración de un . int. los siete días de la semana. monitoreando esta magnitud cada hora. sí es muy laboriosa. este nombre obedece a las mismas reglas que el nombre de una variable o el de una constante. Estructuras de datos 3. Para estos casos especiales el Lenguaje de programación C provee al programador la capacidad de declarar arreglos multidimensionales. Arreglos (Arrays) Bidimensionales Introducción: Hasta este momento conoces lo sencillo y útil que es necesario manipular más de una variable del mismo tipo. 3 [filas]: Lo encerrado entre corchetes (índice) es el tamaño de la primera dimensión del arreglo. utilizar arreglos cuando es Pero qué sucede si se necesitan utilizar un número importante de variables. Con lo aprendido hasta el momento la solución a esta situación sería declarar 7 arreglos con veinticuatro elementos cada uno. este puede estar determinado por el valor que almacena una variable o una constante y debe de ser un número entero.Fundamentos de Programación Unidad IV. aunque esta tarea no es difícil. en esta unidad de aprendizaje estudiarás únicamente los arreglos bidimensionales.

num[0][1]. Con esta línea de código se están declarando seis variables de tipo entero llamadas num[0][0]. Estructuras de datos arreglo el tamaño y posteriormente se puede asignar. 4 [columnas]: Lo encerrado entre corchetes (índice) es el tamaño de la segunda dimensión del arreglo. 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. cuando se ejecuta el programa. este puede estar determinado por el valor que almacena una variable o una constante y debe de ser un número entero. es decir el número de columnas (variables) que forman la segunda dimensión del arreglo. num[2][0] y num[2][1]. es decir.Fundamentos de Programación Unidad IV. Una alternativa para realizar esta misma declaración es la siguiente: int r =3. Observa que el tamaño del arreglo está determinado por el valor de la variable r y la variable m. En este caso también se declaró un arreglo de seis variables de tipo entero. Por ejemplo. intnum[r][m]. Nota: En el Lenguaje C.m=2. num[1][1]. Enseguida se muestra una representación gráfica del conjunto de variables que forman al arreglo bidimensional. Columna 0 Fila 0 Fila 1 Fila 2 num[0][0] num[1][0] num[2][0] Columna 1 num[0][1] num[1][1] num[2][1] . por ejemplo en tiempo de ejecución. todos los arreglos bidimensionales usan cero como índice para el primer elemento. 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]. num[1] [0].

el primer índice pertenece a la fila 2 y el segundo índice pertenece a la columna 1. el primer índice pertenece a la fila 1 y el segundo índice pertenece a la columna 0. por lo tanto. En el quinto elemento: num[2] [0]. { 18. 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 segundo elemento: num[0] [1]. En el tercer elemento: num[1] [0]. Otro ejemplo de cómo asignar valores a los elementos de un arreglo bidimensional es el siguiente: int t[2][2] = { { 15.Fundamentos de Programación Unidad IV. 20 } }. En el sexto elemento: num[2] [1]. la lógica es la siguiente: En el primer elemento: num[0] [0]. /* 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. el primer índice pertenece a la fila 0 y el segundo índice pertenece a la columna 0. en esta representación se indican tanto filas como columnas del arreglo bidimensional. Estructuras de datos Como puedes ver. Un ejemplo de cómo asignar un valor a un elemento de un arreglo bidimensional es el siguiente: num[0][0] = 15. solamente puede almacenar un valor. Si el tamaño del arreglo bidimensional fuera mayor se seguiría la misma lógica. 17 }. el primer índice pertenece a la fila 0 y el segundo índice pertenece a la columna 1. el primer índice pertenece a la fila 2 y el segundo índice pertenece a la columna 0.

el cual vas a retomar posteriormente para realizar una actividad integradora.). Lo siguiente. además de que los números asignados están separados por el operador coma (. .Fundamentos de Programación Unidad IV. Estructuras de datos Ahora el primer elemento que será t[0][0] almacenará un 15. Después de almacenar esta información el programa calcula el promedio de la temperatura de toda la semana y lo muestra por pantalla. para almacenar la temperatura de las veinticuatro horas de un día por toda una semana. el tercer elemento t[1][0]almacenará un 18 y el cuarto elemento t[1][1] almacenará un 20. Este código fuente declara un arreglo bidimensional de siete filas y veinticuatro columnas con lo cual se declaran ciento sesenta y ocho variables. por siete días. El segundo elemento t[0][1] almacenará un 17. es la representación gráfica del arreglo: num[0][0]=15 num[1][0]=18 num[0][1]=17 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. es decir. Como puedes observar se utilizaron los operadores { } para realizar la asignación.

Fundamentos de Programación
Unidad IV. Estructuras de datos

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

Fundamentos de Programación
Unidad IV. Estructuras de datos

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:

floattemp[7][24];
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:

for( dia=1 ; dia<8 ; dia++ )
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

Fundamentos de Programación
Unidad IV. Estructuras de datos
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:

media = media +temp[dia][hora];
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:

media = media/168;
printf( "El promedio de la temperatura en toda la semana es: %f\n ", media );
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!

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).  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. La segunda casilla la posición 00002 y así sucesivamente. Estructuras de datos 4. guardar la dirección de memoria de una variable. Al momento de declarar una variable. ya que. por ejemplo. La primera casilla es la posición 00001 de la memoria. como se vio anteriormente. los distintos tipos de variable con que cuenta el Lenguaje C tienen diferentes tamaños. el tamaño de este espacio depende del tipo de variable que se esté declarando. Las direcciones de memoria de una variable deben almacenarse en otras variables llamadas punteros o apuntadores. . ya que es indispensable para comprender el funcionamiento de un apundador. el Sistema Operativo reserva un espacio de la memoria RAM de la computadora para almacenar información. 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. 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. Se te muestra un ejemplo de la representación de la memoria RAM. Apuntadores (Punteros) Concepto Introducción: En el momento en el cual se declara una variable. Esta dirección es un número escrito en el sistema de numeración hexadecimal. Apuntadores: Antes de explicarte lo que es un apuntador es necesario que sepas qué es la dirección de memoria de una variable. el lugar asignado depende del espacio disponible.Fundamentos de Programación Unidad IV. los números: 0022FF74 y 0011FA12 son direcciones de memoria de dos variables.

&numero. el cual devuelve la dirección de memoria de su operando (es decir la variable de la que se desea obtener la dirección). system ("PAUSE"). #include <stdio. a la cual se le asigna un valor de cuarenta y tres. valor de numero = %i\n". numero ). 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 (&). printf( "Dirección de numero = %p.h> int main() { 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. Estructuras de datos Ejemplo: Supón que ahora se declara una variable de tipo char: llamada numero. 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.h> #include <windows.Fundamentos de Programación Unidad IV. } . de esta forma: Int numero =43.

. 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. &numero. recuerda que no es lo mismo la dirección de la variable. se te explicara lo que son los apuntadores: Un apuntador es una variable capaz de almacenar la dirección de memoria de una variable. declara una variable de tipo entero llamada numero. el cual sirve para mostrar direcciones de memoria por pantalla. La función printf() se encarga de mostrar en pantalla tanto la dirección como el contenido de la variable llamada numero. a la cual se le asigna el valor de cuarenta y tres.Fundamentos de Programación Unidad IV. Estructuras de datos El resultado de editar. Observa que dentro de la función printf() se colocó el modificador de formato %p. valor de numero = %i\n". numero ). al colocar delante de este operador el nombre de la variable número. Observa el siguiente fragmento de la línea de código anterior: &numero. En él puedes observar la implementación del operador dirección de (&). 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. numero ). depurar y compilar este código fuente es el siguiente: 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. éste operador devolverá la dirección de memoria de esta variable. Enseguida se encuentra escrita la siguiente línea de código: printf( "Dirección de numero = %p. no el contenido de la variable. Nota: El apuntador almacena la dirección de memoria de una variable. Ahora que sabes lo que es una dirección de memoria. Después muestra el contenido de la variable llamada número.

float o doublé. por ejemplo char. al teclado y a todo el hardware de la computadora. Nombre: corresponde al nombre del apuntador. se escribe antes del nombre del apuntador sin espacios en blanco. Estructuras de datos La sintaxis para declarar un apuntador es la siguiente: tipo *nombre. Depende del tipo de datos de la variable de la cual se pretenda almacenar su dirección de memoria. Nota: Para acceder a la información almacenada en una dirección de memoria a través de un apuntador. A continuación se te muestra un código fuente en el que se utilizan apuntadores. se usa el operador asterisco (*). Otro uso importante es que permiten acceder directamente a la pantalla. debe escribirse antes del nombre del apuntador sin espacios en blanco. int. También permiten el manejo de cadenas de caracteres y de arreglos. Permiten también la posibilidad de acceder (leer o modificar) a esas posiciones de memoria. analízalo: .Fundamentos de Programación Unidad IV. este operador no se debe confundir con el operador de la multiplicación. Los apuntadores tienen otras utilidades. el apuntador que almacene la dirección de esta variable debe ser también de tipo char. por ejemplo:     Nos permiten pasar argumentos (o parámetros) a una función y modificarlos. este nombre obedece a las mismas reglas que el nombre de una variable o el de una constante. *: El operador asterisco indica la declaración de un apuntador. Tipo: es cualquier tipo de variable. Por ejemplo si se desea almacenar la dirección de una variable de tipo char.

numero ). *punt = 30. valor de numero = %i\n".h> int main() { int numero = 43.h> #include <windows. 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. &numero.Fundamentos de Programación Unidad IV. numero ). /*Guardamos 30 en la dirección de memoria que guarda el apuntador*/ printf( "Direccion de numero = %p. /*Almacenamos la dirección en el puntero*/ printf( "Dirección de numero = %p. . Enseguida se encuentra la línea de código siguiente: int *punt. Estructuras de datos #include <stdio. 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. &numero. depurar y compilar este código fuente es el siguiente: Explicación: En la primer línea de código. /*Declaración del apuntador*/ punt = &numero. } El resultado de editar. valor de numero = %i\n". int *punt. system ("PAUSE").

esto es porque se trata de la misma variable. En este momento se dice que punt “apunta” a la variable número ya que almacena su dirección de memoria. sin realizar una asignación directa. Puedes observar que la dirección de memoria no cambio. este valor devuelto se asigna (guarda) en el apuntador llamado punt. se está accediendo a la variable número sin “tocarla”. 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. . Después está escrita la siguiente línea de código: *punt = 30. es decir. Enseguida la función printf( ) se encarga de mostrar en pantalla. dentro de número. El cuarenta y tres que se había guardado previamente en esta misma variable fue reemplazado y en su lugar se guardó un treinta. tanto la dirección de memoria de la variable número como su contenido. es decir. pero el contenido que almacenaba número si cambio (por medio del apuntador). 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. gracias al apuntador punt se está modificando el contenido de una variable sin utilizar su nombre directamente. Estructuras de datos Enseguida se encuentra escrita la siguiente línea de código: punt = &numero. que en este caso son: 0022FF74 y 43 respectivamente. Observa que en esta asignación no se utilizó al operador asterisco ( * ). El operador dirección de (&) devuelve la dirección de memoria de la variable llamada número.Fundamentos de Programación Unidad IV. por ejemplo: numero =30.

cuando un apuntador almacena una dirección de memoria se dice que éste apunta a la variable de la cual almacena su dirección. ¡Muy bien.Fundamentos de Programación Unidad IV. por medio de un apuntador es posible acceder a los datos almacenados en una dirección de memoria (leerlos o modificarlos). Un apuntador es una variable capaz de almacenar la dirección de memoria de otra variable. Estructuras de datos Conclusión. continua con tus temas! .

El resultado de editar.). Una comparación con apuntadores El Lenguaje de programación C permite utilizar en conjunto a los distintos operadores (Operadores de relación. 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. etc. Observa y analiza el siguiente código fuente. a nivel de bits. de comparación.Fundamentos de Programación Unidad IV. lógicos. con los apuntadores. Ejemplo. Estructuras de datos 5. en el se implementan tanto operadores de relación como apuntadores junto con una sentencia de control. 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. depurar y compilar este código fuente es el siguiente: .

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”). los cuales almacenan una dirección de memoria diferente. Con esta línea se guarda tanto la dirección de memoria de la variable a como de la variable b. pero la imagen anterior que muestra la ejecución del código fuente indica lo contrario. enseguida se declararon dos punteros llamados punt1 y punt2. . punt2 = &b. Enseguida se encuentran escritas las siguientes tres líneas de código: if ( punt1 == punt2 ) printf( "Son iguales\n" ). gracias al operador llamado dirección de (&). system ("PAUSE"). Enseguida se encuentra escrita la siguiente línea de código: punt1 = &a. punt1 almacena la dirección de a y punt2 almacena la dirección de b. Explicación: Después de la llave de apertura de la función main() se declararon dos variables llamadas a y b respectivamente. estas fueron iniciadas con el valor de cinco. en los punteros punt1 y punt2 respectivamente. Esto sucedió así debido a que no se coloco el operador asterisco (*) antes del nombre de los apuntadores. 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.Fundamentos de Programación Unidad IV. ambas de tipo entero. Estructuras de datos 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. ambos son capaces de almacenar la dirección de memoria de una variable de tipo entero.

es decir a y b respectivamente. analízalo detalladamente: Como puedes observar el único cambio hecho a este código. Como a y b almacenan un cinco entonces el operador de comparación igual que (=) devuelve un resultado verdadero (un uno). es decir para comparar el contenido de las variables a y b es necesario colocar el operador asterisco (*) antes del nombre de los apuntadores. por lo cual se ejecuta la siguiente línea de código:: printf( "Son iguales\n" ).Fundamentos de Programación Unidad IV. es el siguiente: se le agregó el operador asterisco (*) antes del nombre de los apuntadores. Estructuras de datos Para poder comparar la información que esta almacenada en las direcciones de memoria a donde apuntan los apuntadores. . de esta forma: if ( *punt1 == *punt2 ) Con este cambio se evalúan los contenidos de las variables a donde apuntan los apuntadores punt1 y punt2. El siguiente código fuente incluye el cambio mencionado anteriormente.

continua así! . 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. Estructuras de datos Mostrando el mensaje correspondiente en pantalla: Conclusión. ¡Muy bien.Fundamentos de Programación Unidad IV. de acceder a cualquier variable o hardware de la computadora a través de las direcciones de memoria.

Ya conoces el gran potencial que ofrecen los apuntadores. así son asignadas por tratarse de variables que integran un arreglo. contigua de esta forma: Elemento del arreglo a[0] a[1] Dirección asignada 0022FF40 0022FF41 Nota: La información de la tabla anterior únicamente es para ejemplificar la asignación de las direcciones. el Lenguaje de programación C permite almacenar la dirección de memoria de un elemento del arreglo en un apuntador. a[1]. Si tuvieras un arreglo de 30 elementos (ya sabes que cada uno de estos elementos tiene su propia dirección en la memoria RAM). Continúa leyendo para conocer la respuesta.Fundamentos de Programación Unidad IV. ¿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). Estructuras de datos 6. a[0]. Relación de apuntadores con arreglos Introducción. a las cuales el preprocesador y el SO asignan una dirección de memoria (a cada una). Como puedes observar las direcciones son consecutivas (una después de la otra). por ejemplo al declarar el siguiente arreglo: char a[2]. Como ya se menciono anteriormente un arreglo permite al programador declarar más de una variable en una sola línea de código. también has experimentado la sencillez con que puedes declarar y manejar una gran cantidad de variables a través de los arreglos. Sabes que esto declara tres variables de tipo char. 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í. 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. . el acceder a la información almacenada en cualquier variable o hardware de una computadora.

puntero = &temperaturas[0]. se presenta el siguiente código fuente el cual muestra en pantalla las direcciones de cada uno de los elementos del arreglo. 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. int temperaturas[24]. Analízalo cuidadosamente. Enseguida se muestra un fragmento de código que contiene lo explicado anteriormente: int *puntero. Estructuras de datos También sabes que un apuntador almacena una dirección de memoria.Fundamentos de Programación Unidad IV. Para corroborar que las direcciones asignadas a los elementos que forman a un arreglo son diferentes y consecutivas. es necesario que el apuntador que guarde la dirección de memoria del primer elemento del arreglo es decir al elemento con índice [0]. El apuntador almacena la dirección del primer elemento. en este caso es temperaturas[0]. .

depurar y compilar este código fuente es el siguiente: Explicación: En la primer línea de código de este programa. i. enseguida se declara un arreglo de tipo int de 7 elementos. Esta característica también es permitida para los elementos de un arreglo ya que también son variables. 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: printf( "La dirección del elemento %i es %p. Estructuras de datos El resultado de editar. se declaró una variable de tipo int llamada i. . Posteriormente gracias a la sentencia de control for. Nota: recuerda que los elementos un arreglo comienzan con el índice [0]. la cual no fue iniciada con ningún valor (esta variable se utilizará después dentro de la sentencia de control for).\n".Fundamentos de Programación Unidad IV. 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. 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. de esta forma: int temp[7]. después de la llave de apertura { de la función main(). Esta línea de código muestra en pantalla la dirección de memoria de cada uno de los elementos que forman el arreglo. &temp[i] ).

Fundamentos de Programación Unidad IV. depurar y compilar este código fuente es el siguiente: . Estructuras de datos Analízalo: El resultado de editar.

la cual no fue iniciada con ningún valor. Dentro de { y } está escrita la siguiente línea de código: printf( "Elemento %i: almacena un: %i\n". *punt ). . Enseguida se encuentra escrita la siguiente línea de código: punt = &temperaturas[0]. capaz de almacenar la dirección de memoria de una variable de tipo int. 22. 23. 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. 23. lo cual genera siete elementos.5}. a los cuales se les asignan los siguientes valores: 15. misma que se ejecutara mientras la variable i sea menor que siete. 22. Estructuras de datos Explicación: Después de la llave de apertura de la función main() se encuentra escrita la siguiente línea de código: int temperaturas[7] = { 15. Inmediatamente después se declaro una variable de tipo entero llamada i. asigna la dirección de memoria del elemento cero del arreglo llamado temperaturas[ ] al puntero punt. esta variable se utilizara más abajo dentro de los paréntesis de la sentencia de control for. 18. 20. Esta línea declara un arreglo llamado temperaturas de índice siete. 24. Esta línea de código. i. Enseguida se encuentra escrita la sentencia de control for.Fundamentos de Programación Unidad IV. esto por medio del operador dirección de (&). el mismo tipo que los elementos del arreglo. Posteriormente se declaró un arreglo llamado punt. 20. 24 y 5 respectivamente a cada uno de los elementos que forman este arreglo. 18.

para asignar o acceder a la información que almacena cada uno de los elementos de un arreglo. Recuerda que si te surgen dudas debes consultar a tu asesor. . como arreglos bidimensionales y de caracteres. matriz o vector.Fundamentos de Programación Unidad IV. 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.c que se creo 4. es decir el archivo con extensión . el programador puede hacer uso de las sentencias de control for. 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. incluso en tiempo de ejecución del programa. depurado. Ya que hayas editado. 2. 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. while o Do while. Actividad Integradora 3. compilado y funcione correctamente el programa sube a la plataforma para su evaluación el archivo del código fuente. un arreglo es un conjunto de variables del mismo tipo cuyo nombre se diferencia en el índice. Las características mencionadas anteriormente son validas tanto para los arreglos unidimensionales. 3. 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”. Su tarea es declarar más de una variable del mismo tipo en una sola línea. 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. Estructuras de datos Es momento de poner en práctica todo tu conocimiento. “Arreglos y apuntadores” 1.

Acabas de terminar la Unidad de aprendizaje. diste un paso más en la adquisición de tus conocimientos académicos y lograste una más de tus metas. cuando un apuntador almacena una dirección de memoria se dice que éste apunta a la variable de la cual almacena su dirección. ¡Felicidades concluiste la Unidad de aprendizaje! . no resta más que felicitarte. 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. Anónimo. ya sea únicamente para leerla o para modificar esta información. por medio de un apuntador es posible acceder a los datos almacenados en una dirección de memoria (leerlos o modificarlos). Por último debes recordar que es posible que los apuntadores permitan acceder a la información almacenada en los elementos de un arreglo.Fundamentos de Programación Unidad IV. Estructuras de datos También aprendiste que un apuntador es una variable capaz de almacenar la dirección de memoria de otra variable. en hora buena. El éxito no es para los que piensan que pueden hacer algo sino para quienes lo hacen.