Practicas bloque 1

Practicas Programación 2015 Fecha de entrega: Nombre: Firma profesor:

Manual de Practicas Lenguaje C

Bienvenido Bienvenido a esta serie de tutoriales, ha sido una grandiosa elección empezar a programar

en C. Si no tienes ni idea de qué es eso, te informaré un poco:

C es un lenguaje de programación (Creo que eso es obvio), sucesor de B, creado en 1972.

Se caracteriza por su inigualable potencia y aplicación a sistemas operativos,

especialmente aquellos basados en Unix.

C es elegido por gran cantidad de personas que buscan un perfecto equilibrio

entre eficacia y facilidad de aprendizaje. Al ser un lenguaje considerado de medio nivel,

posee características comparables al lenguaje humano al igual que otras que lo acerca al

lenguaje de máquina, de aquí su perfecto equilibrio.

Si no te convences aún, esto debería hacerlo: Los sistemas operativos Linux, está

hechos casi en su totalidad en C.

Preparando tu PC C es simple, pero requiere un buen entorno de desarrollo. Un entorno de desarrollo es un

programa que simplifica varias tareas, desde escribir el código fuente, hasta la tarea

de compilar, todo en uno.

Compilar Com-pi-lar, debes de acostumbrarte a utilizar esta palabra. ¿Alguna vez te has preguntado

cómo se hacen los *.exe? Si eres curioso deberías de abrir con el Bloc de Notas un

ejecutable. Lo que verás son miles de líneas de código binario. En realidad es lo mismo que

se escribe en un código fuente, pero traducido a un lenguaje que la máquina pueda

entender. Es prácticamente imposible programar directamente en binario, es por eso que

nosotros lo hacemos a través de comandos y operaciones que podemos entender

(Código Fuente o Source Code).

El compilador transforma nuestro código fuente, fácilmente comprendido, en un ejecutable

(En el caso de Windows) capaz de ser comprendido por una computadora.

Y esta es otra característica que le brinda un gran poder a C, en vez de ser interpretado

como otros lenguajes (Lua, HTML, etc.) es compilado.


Estructura Antes de empezar sería conveniente saber la estructura básica de C, te evitarás muchos

dolores de cabeza si sabes ésta.

• Siempre al principio de todo programa en C, se deben de incluir las Directivas (No

te preocupes mucho por los nombres).

• Todo programa en C, debe de tener por lo menos una función llamada main.

• Todos los comandos en C, se separan por un punto y coma ;

• C distingue entre mayúsculas y minúsculas.

• Puedes usar todo el espacio en blanco que desees para darle una mejor vista al

programa, excepto al momento de declarar directivas.

Creo que ya tuviste suficiente introducción, ya sabes lo suficiente para hacer el primer

programa de todo programador: el archiconocido Hello World.


Practica No. 1 Hola Mundo

Ya estas listo para hacer tu primer programa en C. No es nada del otro mundo, pero

servirá enormemente para que te des una idea de qué es programar y las particularidades

del lenguaje. Estoy hablando del famosísimo Hola Mundo, el primer programa por

excelencia.

Vamos a empezar. Abre tu IDE Visual C++ Express 2010 e inicia un nuevo documento.

Primero hay que escribir aquí todo el programa, posteriormente se explicará línea por

línea éste. Escribe el siguiente código, no copies y pegues, es mejor que lo escribas tú

msimo, favorece el aprendizaje.

/* Mi primer programa en C: Hello world Tu nombre La fecha */ #include <stdio.h> int main() { printf("Hola Mundo"); return 0; }

Ahora a analizar el programa parte por parte:

/* Mi primer programa en C: Hello world Tu nombre La fecha */

Esto es un comentario. Se usa para describir el programa, señalar su autor o describir

alguna función, son ideales si un proyecto se prolonga mucho, con ayuda de ellos podrás

identificar facilmente fragmentos de código, incluso si no has revisado el código por años. Un

comentario siempre debe empezar con /* y u prterminar con */, aunque hay otras formas

de hacerlos. Es importante aclarar que el compilador no los toma en cuenta, por eso no

alterarán tu programa.

Si escribieramos:

Mi primer programa en C: Hello world Tu nombre La fecha


El compilador marcaría un error ya que trataría de interpretar estas líneas y no sabría que

hacer con ellas.

Es válido hacer comentarios que ocupen varias líneas, como el ejemplo, o una sola:

/*Esto es un comentario*/ Válido /*Esto es un comentario*/

Válido

Debes cuidar que el comentario se cierre correctamente, si quitáramos el */ al ejemplo

anterior, tendríamos como resultado sólo un comentario, todo tu programa quedaría

convertido en un comentario y el compilador marcaría un error.

Como decía existe otra forma de establecer un comentario, es valido utilizar una doble

barra://. Como desventaja, no es posible hacer comentarios en varias líneas, pero como

punto positivo, no es necesario cerrarlos. Si quisiéramos usar las dos barras para el ejemplo

anterior, tendríamos que hacerlo así:

//Mi primer programa en C: Hello world //Tu nombre //La fecha

Nunca intentes poner comentarios dentro de los argumentos de una función o dentro de

una palabra clave, el compilador marcaría un error.

Pasemos a la siguiente parte.

#include <stdio.h>

Esto es una directiva. Al llamar a una directiva, estaremos indicando al compilador que

incluya esta librería (En este caso stdio.h) en el programa. En las librerías se incluyen

funciones ya definidas, así, sólo basta con llamarlas. Es el ejemplo estamos llamando

a stdio.h que contiene la función printf, que utilizamos en el programa.

Un programa puede contener cuantas directivas decida su autor.

int main()

Esto es la función principal. Todo programa debe de tener una función principal, en ella se

específica qué es lo que hará el programa, en el ejemplo imprimirá un "Hola Mundo" en


pantalla. El int, viene de Interger o Entero. Más adelante explicaré más a fondo los tipos

de datos (int, float, void, etc.) y el main, simplemente indica que es la función principal.

Recuerda poner los paréntesis () y siempre debe de estar delimitada por corchetes {}.

{ printf("Hola Mundo");

Esto es el cuerpo del programa. El corchete { indica que ahí empieza la función. printf es

una función definida en stdio.h, ésta muestra información por pantalla. C distingue entre

mayúsculas y minúsculas, por lo tanto cuida no escribir Printf en vez de printf. Después

de llamar a la función, se establecen sus argumentos ("Hola Mundo") esta es la expresión

más simple de printf, simplemente contiene entre comillas "" el texto que se mostrará en

pantalla. Fíjate que después de los argumentos hay un punto y coma ; en C son utilizados

para separar los comandos, cuida ponerlos, es un error muy común y dificil de encontrar.

return 0; }

Este es un comando que forma parte de tu programa, es recomendable que siempre lo

utilices. Aquí se define cuál será el valor que regresará la función en caso de que se haya

llevado a cabo correctamente. De nuevo, separamos el comando con ;. Y finalmente

cerramos los corchetes }.

Es muy probable, sobre todo si usas Windows, que al ejecutar el programa sólo aparezca

una ventana y se cierre inmediatamente. Para evitar esto puedes añadir lo siguiente, antes

del return 0;:

getchar();

Esta función se incluye en stdio.h, lo que hace es esperar a que se presione una tecla para

cerrar el programa.

También puedes añadir:

system("PAUSE");

El inconveniente de esta función es que muestra un feo mensaje en pantalla y es probable

que tengas que incluir la directiva: #include <windows.h>

Ya que entiendes el código, por qué no lo pruebas, escribe el programa de ejemplo en tu

editor y después compilalo. En Visual C++ .


El resultado será algo como esto:


Practica 2 “Tipos de Datos”

En un programa completo, es necesario utilizar y controlar mucha información, nos

volveríamos locos si esa información no se almacenará, o no la pudiéramos identificar. En

este capítulo aprenderemos a utilizar variables, e identificaremos los tipos de datos básicos,

sólo una sencilla aproximación. Sin duda es una parte elemental en la programación.

Antes de empezar es necesario que entiendas ciertos términos.

Memoria La memoria en una computadora, al igual que en el ser humano, se encarga de retener

información. Es muy común, y de hecho correcto, que también se le llame RAM a la que

corresponde al ordenador. La memoria RAM es esencial en el funcionamiento de una

computadora, simplemente si no se pudieran retener datos, no existirían las cosas como las

conocemos hoy. Es muy común que confundamos la memoria RAM con el Disco Duro,

pero son cosas totalmente distintas. La memoria RAM es temporal, en cuanto apagamos el

ordenador, su información desaparece; el Disco Duro es casi permanente, retiene

información durante mucho, mucho tiempo. Todos los programas hacen uso de la memoria

RAM, en ella guardan información que será utilizada, desde imágenes hasta números.

Bytes, Bits y más Ahora hablemos de unidades. Estoy casi seguro que alguna vez has oído: "Mi disco duro es

de 100 <<gigas>>" o "Me quedan 20 <<megas>> en mi USB" o cosas parecidas. También

estoy casi seguro que alguna vez te has detenido a pensar: "¿Qué demonios es un

<<giga>>?".

En informática se utilizan estas unidades de medida. Podemos decir que surgen del

sistemabinario (1/0). Pueden indicar desde el tamaño de un dato, hasta la capacidad de un

dispositivo. Son la unidad de información. No vale la pena extenderse mucho sobre esto,

vamos al grano.

La unidad más pequeña es el Bit: Binary Unit (Unidad de Binario).

8 Bits = 1 Byte (Octeto)

A partir de aquí, se utilizan prefijos, para indicar multiplos de Bytes:

• 1 KiloByte (KB) = 1024 Bytes

• 1 MegaByte (MB) = 1024 KiloBytes

• 1 GigaByte (GB) = 1024 MegaBytes


• 1 TeraByte (TB) = 1024 GigaBytes

No deben confundirse sus símbolos con Kb (KiloBit) o Mb (MegaBit). Recuerda 1 bit (b) es

diferente a 1 byte (B).

Esta es una memoria Ram de los años 80´s. Se pueden apreciar los bits físicos

como pequeñas celdas.

Suficiente teoría, vamos al Laboratorio (Quiero decir: Abre Visual C++).

Variables y tipos de datos Son cosas diferentes, pero están estrechamente relacionadas. Esta es otra cosa que le da

a C un gran poder y flexibilidad. El poder elegir qué tipo de dato usar, nos permite guiarnos,

y por otro lado evita el uso de memoria innecesario. Una variable de Entero, no pesa la

mismo que un Caracter, ni se comporta igual. Vamos a ver qué y cuáles son los tipos de

datos:

• int: O Interger/Entero (En inglés). Almacena un número entero de -32768 a

+32767. Ocupa 16 bits en memoria*.

• float: O Flotante. Almacene un número con punto decimal con 7 dígitos de

precisión. Ocupa 32 bits en memoria*.

• double: Un número décimal de doble precisión, hasta 13 dígitos. Ocupa 64 bits en

memoria*.

• char: O Caracter. Almácena un sólo caracter. O un número entero. Ocupa 8 bits en

memoria*.

• void: Tipo personalizado. Se explicará a fondo en el futuro.

*La cantidad de bits puede variar según el compilador. Lo que si está claro es que un char es más ligero que un double,

por ejemplo. Estos valores son principalmente orientativos.


Ahora vamos a poner en práctica esto que acabas de aprender. De nuevo, escribe tú mismo

el código, no lo copies. Al terminar de escribirlo compílalo y observa el resultado. Explicaré

todo línea por línea.

int

/*Jugando con los enteros*/ #include <stdio.h> int main() { /* Declaración de Variables*/ int a,b,suma; /*Asignado valores a las variables previamente establecidas*/ suma = 1000; a = 2000; b = a + suma; /*Imprimiendo en pantalla las variables*/ printf("a = %i\n",a); printf("suma = %i\n",suma); printf ("a + suma = %i\n",b); printf("Tamano en bits de int: %i",sizeof( int )*8); getchar(); return 0; }

Lo primero ya lo sabes. Las directivas. Llamamos a stdio.h.

#include <stdio.h>

Iniciamos la función principal: int main().

int main()

Esta parte es importante:


{ int a,b,suma;

Aquí, declaramos las variables que usaremos dentro de int main().

Una variable es, podemos decir, un lugar reservado en la memoria, declarar una variable

es decirle al ordenador que reserve X número de bits en ella. Al explicar todo el

programa, tendrás una visión más completa sobre qué es una variable.

Las variables pueden ser locales o globales, se diferencian en que las primeras, sólo

pueden ser usadas en la función en donde han sido declaradas; las segundas pueden ser

usadas en cualquier función del programa, siempre se declaran después de las directivas y

fuera de cualquier función.

Ahora, en el programa, estamos declarando 3 variables a la vez: a,b y suma. A esas tres

variables les estamos reservando en memoria el número de bits que equivale un dato int

(Entero). Podemos declarar, como en el programa, tantas variables como

queramos siempre y cuando queramos que sean del mismo

tipo. a,b y suma son enteros(int). El equivalente "largo" de lo anterior sería:

#include <stdio.h> int main() { /* Declaración de Variables*/ int a; int b; int suma;

Lo que hacemos para reducir estas líneas es declarar al mismo tiempo a,b y suma ya que

las 3 son enteros.

Ahora asignamos un valor a esa reservación de memoria que hicimos al declarar las

variables:

suma = 1000; a = 2000; b = a + suma;

suma almacena al número entero 1000, a almacena al entero 2000, y b almacena la suma

dea (2000) y suma (1000). Fíjate que se le asigna el valor a b, ya que fueron

almacenados valores en suma y a. Si hubiéramos escrito b = a + suma; antes de haber


definido a y suma el compilador hubiera marcado un error. También fíjate que no es

necesario que sigas el orden en que declaraste las variables para asignarle un valor.

También es posible asignarles un valor al mismo tiempo que se declaran, no lo recomiendo,

en un código largo te pierdes y pueden llegar a dar problemas, en cualquier caso, aquí está

el método:

int a = 1000,b = 2000,c = 3000;

Ahora, estudiaremos un uso más de la función printf:

printf("a = %i\n",a);

Entre paréntesis puedes ver 2 argumentos. Hasta aquí ya deberías de conocer el

primero "a = %i\n" entre comillas se indica el texto que aparecerá en pantalla; en este

caso estamos diciendo que se muestre " a = %i" y se de un salto de línea. Conoce a tu

nuevo mejor aliado el % este símbolo te ayudará a imprimir el valor almacenado

en variables; en este ejemplo estamos usando %i la i viene de el tipo de dato int, estamos

indicando que se muestre un dato del tipo int. El segundo argumento va estrechamente

ligado al %, en el escribimos una a que como ya vimos quedó definida al momento de

declarar y darle valor a esa variable; la variable que se encuentre en el segundo argumento

va a ser aquella que se muestre en el primer %. El resultado en pantalla será:

a = 2000

Lo mismo sucede con las siguientes declaraciones de printf:

printf("suma = %i\n",suma); printf ("a + suma = %i\n",b);

En la primera hacemos lo mismo, sólo que trabajamos con la variable suma.

La segunda mostrará en pantalla "a + suma =" y a continucación mostrará el valor

almacenado en b, es decir la suma de a y suma; recordemos: b = a + suma. Es

exactamente lo mismo, sólo que b es una variable más compleja.

El siguiente fragmento es muy curioso y de suma importancia en este tutorial:

printf("Tamano en bits de int: %i",sizeof( int )*8);


De nuevo, lo que está entre comillas se imprimirá en pantalla. El %i hace referencia al

siguiente argumento (igual que en las funciones anteriores). Sólo que este útimo argumento

no se refiere a ninguna variable previamente establecida. Analicemos esta parte: sizeof( int

)*8 sizeof es una función ya definida, lo que hace es obtener el tamaño en bytes de lo

que se encuentre entre sus paréntesis, en este caso, siplemente ponemos entre

paréntesis int para que obtenga el tamaño de ese tipo de datos, después lo multiplicamos

por 8 para hacer la conversión a bits. Es simple, aunque no lo parezca.

Finalmente:

getchar(); return 0; }

Establecemos (con getchar()) que si no se preisona Enter, el programa no se cierra. Y que si

la función termina correctamente devuelva un 0.

Resultado

El programa es simple, aunque la explicación parezca larga, recuerda que toda esta

"parrafada" sólo se refiere a los enteros (int), aún falta estudiar float, double y char. No te

deseperes, su uso es extremadamente parecido, te tomará 1 minuto comprenderlo.

float

/*Jugando con los flotantes*/

Practicas Programación 2015 Fecha de entrega: Nombre: Firma profesor: #include <stdio.h> int main() { float a,b,c; a = 0.55; b = 350.1; c = a + b; printf("El resultado de a + b es: %f\n",c); printf("Tamano en bits de float: %i",sizeof( float )*8); getchar(); return 0; }

La primera parte, ya la conoces: las directivas. Después iniciamos main.

Aquí, se definen las variables como tipo float (flotante):

float a,b,c;

Su uso es el mismo que en Interger. Pero recuerda que float es para números decimales.

Ahora definimos los valores de cada variable tipo float:

a = 0.55; b = 350.1; c = a + b;

Estos pasos ya los tienes muy estudiados. Puedes ver que a y b son números decimales.

Ahora imprimimos las variables:

printf("El resultado de a + b es: %f\n",c); printf("Tamano en bits de float: %i",sizeof( float )*8);

Fíjate que después del % usamos una f (float) así, asegurmaos que el valor que aparecerá

en pantalla será un decimal.


En el segundo printf calculamos el valor de un dato tipo float, funciona exactamente igual

que en el ejemplo de int, sólo que cambiamos a float entre paréntesis. También funciona, si

pones una variable ya declarada en los paréntesis, según su tipo, será su tamaño.

Resultado

double Su funcionamiento es el mismo que el de float, únicamente cambia la forma

de declarar (Eso ya lo deberías de saber)

double a,b,c;

Declaramos 3 variables tipo double.

Se imprimen en pantalla de la misma forma que un float.

Para saber su tamaño puedes escribir:

printf("Tamano en bits de float: %i",sizeof( double )*8);

Generlamente el resultado de esto será 64.

char Ahora estudiemos un tipo de dato, que para mi gusto, es muy interesante: char.


Como expliqué anteriormente los datos del tipo char almacenan caracteres. Son las

variables más "ligeras" y sólo pueden almacenar una sola letra o un número entero.

¿Números? Char es un tipo de dato dedicado a caracteres, pero, tienes que saber que

existen equivalentes numéricos a las letras, se le conoce como código ASCII. No sirve de

mucho saber el código ASCII y utilizarlo para imprimir letras, pero la importancia de los char

radica en que al poder almacenar números enteros, pueden sustituir a int, el beneficio es

que un char mide 8 bits, frente a 32 de un interger.

Existen programas que se les conoce como Bloatware, su principal carcaterística es que

están "inflados" contienen cosas innecesarias que terminan convertidas es un programa muy

pesado. Este puede ser un buen truco para evitar el Software Gordo.

Ahora estudiemos su uso, es idéntico al de los otros tipos.

/* jugando con caracteres*/ #include <stdio.h> int main() { char letra; int ascii = 66; letra = 'A'; printf("La letra almacenada en la variable es: %c. Y su valor ASCII es: %i.\n",letra,letra); printf("El co\'digo ASCII es: %i. Y su correspondiente letra es: %c.",ascii,ascii); getchar(); return 0; }

Empecemos a analizar la función principal:

char letra; int ascii = 66;

Aquí declaramos 2 variables un entero y un caracter, ascii y letra respectivamente. Fíjate

que estamos dándole un valor a ascii al mismo tiempo que la declaramos. Ya es de

suponerse que estas familiarizado con esto, no me extenderé más.


letra = 'A';

Le asignamos un valor a letra. Fíjate que el caractér está "encerrado" en ''.

printf("La letra almacenada en la variable es: %c. Y su valor ASCII es: %i.\n",letra,letra); printf("El co\'digo ASCII es: %i. Y su correspondiente letra es: %c.",ascii,ascii);

Ahora, estudiemos un poco más a printf. Fíjate que en la primera función, estamos usando

dos %, uno con c (para caracteres) y otro con i (para enteros). Ahora nota que se está

sumando un argumento más, el primer % corresponde al 2° argumento, el segundo %

corresponde al tercer argumento.

El primer % tiene una C, la C viene de caracter, y va ligado al segundo argumento: "letra"

por lo tanto imprimirá A. El segundo le damos forma de entero (int), pero está ligado de

nuevo, a la variable letra; esto da lugar a que se imprima el equivalente en código ASCII de

A (65).

El segundo printf funciona inversamente, ya que en lugar de utilizar una letra, utilizamos

un número. Compila y ejecuta tu programa, es más fácil entenderlo así.


Practica No. 3 Constantes

Ya vimos lo que es una variable, pero no es lo único que hay para manipular datos, existen

tambien las constantes, son similares, pero las últimas tienen la singular característica de

ser "definitivas", inmutables. Esta Practical es sencilla, pero no podemos dejar por un lado

el uso de #define.

A continuación una pequeña tabla, explicando las diferencias principales entre una constante

y una variable. Aquí va:

Ahora, ¿por qué no cambiar la frase anterior? "Un código fuente dice más que mil

palabras". Con esto quiero que abras tu IDE, vamos a estudiar un poco de código.

/*Jugando con las constantes*/ #include <stdio.h> #define agnos_en_un_lustro 5 #define agnos_en_una_decada 10 #define agnos_en_un_siglo agnos_en_una_decada*(agnos_en_un_lustro*2) int main() { printf("Un lustro tiene %i agnos.\n",agnos_en_un_lustro); printf("Una decada tiene %i agnos.\n",agnos_en_una_decada); printf("Un siglo tiene %i agnos.",agnos_en_un_siglo); getchar(); return 0; }

Primero, como es una costumbre, llamamos a stdio.h.

Aquí viene la parte que nos interesa:


#define agnos_en_un_lustro 5

Esto es una constante, fíjate, que como expliqué en la tabla para declarar una, tenemos

que anteponer #define, dejamos un espacio, escribimos su nombre (fíjate que no contienes

caracteres extraños, salvo _, y no tiene espacios), dejamos otro espacio y le asignamos un

valor. A diferencia de las variables, aquí es indistinto el tipo de dato, no es necesario

especificarlo; en el ejemplo estamos usando enteros (más adelante veremos más). En el

ejemplo la constante se llama agnos_en_un_lustro, y almacena un 5.

Las constantes son datos que nunca cambian, esta es su principal característica, para

enfatizar esto, usé unidades de tiempo como ejemplo, todos sabemos que una década tiene

10 años (Si en donde vives una década no son 10 años, no eres de la Tierra).

Repetimos esto con otras 2 variables:

#define agnos_en_una_decada 10 #define agnos_en_un_siglo agnos_en_una_decada*(agnos_en_un_lustro*2)

La siguiente constante es simple, se llama agnos_en_una_decada y almacena un 10.

La siguinete es más compleja, agudiza tu vista, te puedes confundir. Se

llamaagnos_en_un_siglo y almacena un 100, éste es el resultado de las operaciones ahí

representadas, empezemos por los paréntesis: agnos_en_un_lustro almacena un 5, si lo

multiplicamos por 2 obtendremos un 10, si ese 10, lo multiplicamos

poragnos_en_una_decada, es decir por 10, el resultado será 100 (Un siglo).

Después, iniciamos main() e imprimimos todas las constantes:

int main() { printf("Un lustro tiene %i agnos.\n",agnos_en_un_lustro); printf("Una decada tiene %i agnos.\n",agnos_en_una_decada); printf("Un siglo tiene %i agnos.",agnos_en_un_siglo); getchar(); return 0; }

Tambien hacemos uso del % seguido de la i de interger. Eso es todo, nada complicado, el

resultado será:


Ahora veamos como es que pueden interactuar las variables y las constantes. Inicia un

nuevo documento.

/*Mezclando Variables con Constantes*/ #include <stdio.h> #define IVA 15 float precio, precioIva; int main() { precio = 100; precioIva = precio + ((precio * IVA)/100); printf("Mi auto costaba %f \"$imoleanos\" sin IVA en los 40s.\n", precio); printf("Mi auto costaba %f \"$imoleanos\" con IVA en los 40s\n", precioIva); precio = 50; precioIva = precio + ((precio * IVA)/100); printf("\nHoy, mi auto cuesta %f \"$imoleanos\" sin IVA.\n",precio); printf("Hoy, mi auto cuesta %f \"$imoleanos\" con IVA.\n", precioIva);

Practicas Programación 2015 Fecha de entrega: Nombre: Firma profesor: getchar(); return 0; }

Como siempre, las directivas. En seguida, declaramos una constante: IVA, y almacena 15.

#define IVA 15

El IVA (Al menos en México) es el 15% del precio de un objeto, es por eso que vale 15.

Sigamos analizando.

float precio, precioIva;

Ahora declaramos dos variables tipo Float: precio y precioIva.

Ahora vamos a asignar valores a las variables. La funcion main() ya fue declarada.

precio = 100; precioIva = precio + ((precio * IVA)/100);

precio almacena un 100. precioIva, almacena precio más su 15% (IVA), fíjate que IVA es

una constante, nunca cambia, y ya fue declarada.

Ahora imprimimos las variables:

printf("Mi auto costaba %f \"$imoleanos\" sin IVA en los 40s.\n", precio); printf("Mi auto costaba %f \"$imoleanos\" con IVA en los 40s\n", precioIva);

Esto ya lo sabes. Nota que usamos %f ya que las variables on del tipo Float.

La siguiente parte, es la que me interesa del programa:

precio = 50; precioIva = precio + ((precio * IVA)/100);


Aquí Variamos las variables, cosa que no podríamos hacer con una constante. Después las

volvemos a imprimir:

printf("\nHoy, mi auto cuesta %f \"$imoleanos\" sin IVA.\n",precio); printf("Hoy, mi auto cuesta %f \"$imoleanos\" con IVA.\n", precioIva);

El programa da un giro. El resultado derá:

Y para finalizar, vamos a experimentar con texto. Abre un nuevo documento y escribe:

/*Aun más constantes... ¿Texto?*/ #include <stdio.h> #define texto "HOLA" int main() { printf(texto); getchar(); return 0; }


Fíjate que la forma de declarar esta constante no varía, sólo que el valor se encuentra entre

comillas "".

Después, cuando queremos imprimir al constante, sólo ponemos el nombre de la variable

como argumento, sin comillas ni nada parecido.

El resultado será:

Hasta aquí el tutorial de constantes, es muy simple comparado con los anteriores, pero,

repito, las constantes son una parte importante, no podemos dejarlas pasar.


Practica 4 Entrada y Salida: scanf/printf

La gran mayoría de los programas necesitan la interacción entre el usuario y la máquina.

Desde la simple calculadora, hasta las complejas GUIs necesitan que el usuario introduzca

datos. En este tutorial vamos a complicar un poco las cosas y vamos a construir un

programa que no funcionará si no interactúas con él.

Primero vamos a estudiar un poco la función scanf. Ésta es el equivalente e inverso de la

función printf, de hecho también se incluye en la librería estándar de C (stdio.h). Funciona

exactamente igual que printf, pero al inverso. Es decir en vez de "devolver" datos,

"recibirá". No te costará aprenderla.

Vamos a analizar un pequeño programa que hice para introducirte a esta bella función, lo

digo y lo seguiré diciendo: Escribe el código, no hagas copy-paste. Mucha teoría y poca

programación, aquí va:

/*Entrada y Salida: scanf*/ #include <stdio.h> int main() { float a; char b; printf("Introduce un numero: "); scanf("%f",&a); printf("Intrduciste el numero: %f\n",a); getchar(); printf("Introduce una letra: "); scanf("%c",&b); printf("Introduciste la letra %c\n\n",b); printf("Presiona Enter pasa Salir"); getchar(); getchar(); return 0; }

Ahora el análisis por pasos:


float a;

char b;

Declaramos las variables, una de tipo float y una de tipo char.

printf("Introduce un numero: ");

Mostramos por pantalla el mensaje entre comillas "".

scanf("%f",&a); printf("Intrduciste el numero: %f\n",a);

Y aquí está scanf. Lo que hace está función es "escanear el teclado, en busca de una

tecla activa". Ahora vamos a ver como se utiliza. Entre paréntesis tenemos un % y

una letra, al igual que en printf usamos el % acompañado de una letra para indicar con

qué tipo de dato estamos trabajando. En este caso estamos diciendo que el teclado escanee

en busca de números flotantes. Al final de las comillas encontramos otro

argumento &a esto hace que lo que se introduzca en el teclado, quede guardado en la

variable a (declarada anteriormente y de tipo float) y termina la función con su ; obligatorio.

El número, entero (ej:2.00000) o decimal (ej:2.3456) quedó guardado en la variable a.

Ahora, para comprobar si la función scanf funciona, vamos a pedir que el programa muestre

la variable a en pantalla, esto ya lo conoces. ¡Sorpresa! En pantalla aparece el número que

introducimos previamente. Así de simple operan y pueden coexistir las funciones más

importantes de C.

En el mismo programa se incluye otro ejemplo similar, pero, trabajando con caracteres.

Antes de empezar con esta parte, quiero que se note el getchar() entre los dos "bloques".

La máquina interpreta el código ya compilado en el orden en que fue escrito, sin ese

getchar(), al imprimir en pantalla, se "brincaría" a la siguiente parte, llegando incluso a dar

errores extraños, para mantener esto controlado, ponemos esta función, que espera a que

se presione "Enter" para seguir.

Ahora sí:

printf("Introduce una letra: "); scanf("%c",&b); printf("Introduciste la letra %c\n\n",b);


Imprimimos en pantalla el mensaje. Llamamos a scanf, pero fíjate que ahora usamos

un %c, por lo tanto escaneará en busca de caracteres (Recuerda que char, también puede

almacenar un entero, por lo tanto podrás introducir un número sin problemas) y

almacenamos en b (Previamente declarada como tipo char).

Después imprimimos b en pantalla, el resultado es el mismo que introducimos previamente.

Finalmente, terminamos el programa con una frase "Presiona Enter para salir".

Resultado

Hay que notar que los signos guardan cierta congruencia; por ejemplo, a es tipo float, en él

se almacena un número y al imprimirlo lo imprimimos como tipo float; b es del tipo char, va

a almacenar un caracter t se imprime como tal. Tal vez te pueda parecer redundante, pero

puede ser un error muy dificil de encontrar.

Con esto tienes suficiente para poder manejar esta función. Ahora vamos a hacer un

programa propiamente dicho, es sencillo, pero te servirá como un buen ejemplo para jugar

tú mismo con la programación en C.


Un código vale más que mil palabras. Aquí va:

/*Edad*/ /*Un simple programa que calcula tu edad. Fíjate que sólo uso las funciones básicas de entrada y salida: printf y scanf*/ #include <stdio.h> int main() { int nacimiento, actual, edad; printf("Introduce tu año de nacimiento: "); scanf("%i",&nacimiento); getchar(); printf("Introduce el año actual: "); scanf("%i",&actual); getchar(); edad = actual - nacimiento; printf("Tienes aproximadamente %i años\n\nPresiona Enter para Salir", edad); getchar(); return 0; }

Iniciamos el programa llamando a 3 variables del tipo int:

int nacimiento, actual, edad;

No es necesario asignarles un valor.

Después mostramos un mensaje en pantalla y escaneamos en busca de un número

entero. Al terminar esto, esperamos a que se presione enter, los motivos ya fueron

explicados.

printf("Introduce tu año de nacimiento: "); scanf("%i",&nacimiento); getchar();

Fíjate como se almacena en nacimiento, con la ayuda de &, no lo olvides.


Después pedimos que se introduzca el año actual. El proceso es el mismo:

printf("Introduce el año actual: "); scanf("%i",&actual); getchar();

Ahora almacenamos en edad la diferencia de actual y nacimiento, dando como resultado

una edad aproximada.

edad = actual - nacimiento;

Y finalmente imprimimos actual en pantalla. Finalizamos el programa.

Esto ya lo sabes, sólo quiero mostrar un ejemplo "útil" de su uso. Juega con las funciones y

crea programas más complejos, te darás cuenta que esto (scanf/printf) no es suficiente,

pero eso ya lo veremos después.


Practica 5 Bucles y Sentencias

Nuestros últimos programas ya tenían más forma, pero seguramente te diste cuenta de que

se quedaban cortos, no eran lo suficientemente eficientes para lograr algo más complejo.

Alégrate, aún hay más que aprender. Los bucles y sentencias son parte importantísima en

cualquier lenguaje de programación. Regulan el flujo de información, haciéndonos la vida

más fácil.

En esta practica aprenderemos los bucles más importantes: While y For. También

estudiaremos los condicionales: If, else, else if. Como ya es costumbre, no veo motivos

para extenderme en la teoría. Vamos al laboratorio.

While Empecemos por aprender el bucle While. Es muy simple, y muy útil si está bien aplicado.

Citaré el clásico ejemplo a la hora de explicar los bucles. Si dijera "Haz un programa que

imprima 5 <<Holas>> en pantalla". Lo primero que se te pasaría por la cabeza,

seguramente, sería: Escribir 5 printfs. ¿Y si dijera "Haz un programa que imprima 5000

<<Holas>> en pantalla"? La cosa cambia. No creo que te atrevas a escribir cinco mil

printfs. Aquí es donde adorarás los bucles, vamos a materializar el ejemplo, vamos

a imprimir 5000 veces "Hola".

/*Ejercicio de Bucles: While*/ #include <stdio.h> int main() { int timer; timer = 0; while (timer < 5000) { ++timer; printf("Hola %i\n",timer); } printf("Presiona ENTER para continuar"); getchar(); return 0; }

Paso a paso

Practicas Programación 2015 Fecha de entrega: Nombre: Firma profesor: int timer; timer = 0;

Nada del otro mundo (Tal vez sí, pero ya lo sabes usar) declaramos una variable del tipo

int y le asignamos el valor 0. Está parte es importante, y si no se lleva a cabo puede ser una

fuente difícil de identificar de errores extraños. Vamos a enriquecer nuetsros conocimientos

con un dato: Si no le asignaramos 0 a timer, el programa se asignaría a sí mismo un valor

aleatorio, el resultado sería una cuenta incompleta a la hora de usar el While.

while (timer < 5000) { ++timer; printf("Hola %i\n",timer); }

Y he aquí al protagonista de esta sección: el famosísimo While. Vamos a estudiarlo

minuciosamente.

Podemos apreciar que para iniciar un bucle del tipo While, basta con poner esa misma

palabra (sin mayúsculas). Después, escribimos entre paréntesis la condición; es decir, el

bucle se ejecutara, mientras esa condición sea verdadera; en este caso, estamos diciendo

que el bucle se ejecute una y otra vez hasta que timer sea igual a 5001.

Después podemos ver, que al igual que las funciones (me refiero a int main()) delimitamos

una serie de tareas mediante las llaves, el final del bucle está justo en la llave de cierre }.

Dentro de estas llaves tenemos lo siguiente:

++timer; printf("Hola %i\n",timer);

++timer es lo mismo que timer = timer + 1. Es decir que la variable se sumara a sí

misma la unidad por tiempo indefinido (en este caso las veces las delimita timer). En otras

palabras++timer es una manera más corta de hacer lo mismo. al sumar 1 a timer por cada

vez que se ejecute el bucle, aseguraremos que éste se ejecutara sólo (Sí, nada

más) 5000 veces.

Después tenemos un printf que imprimirá Hola, seguido del número almacenado en timer.

Lo último con el fin de comprobar que en realidad el bucle se está repitiendo 5000 veces.


Fíjate que las tareas las estamos separando, al igual que fuera de un bucle, con un ;.

También es un error común saltarse los punto y coma.

Finalmente le damos un poco de estilo al programa e imprimimos un mensaje de salida.

Compila el código, verás que sí, se imprimen 5000 Holas sin mucho esfuerzo.

Ahora vamos a repetir el ejemplo, pero usando otro método: el bucle For.

For

/*Ejercicio de Bucles: For*/ #include <stdio.h> int main() { int a; for (a = 0; a <= 5000; a ++) { printf("Hola %i\n",a); } printf("Presiona Enter para salir"); getchar(); return 0; }

Vamos directo a la función principal.

Declaramos, primeramente, la variable a del tipo int. Fíjate que ahora no es necesario que le

asignemos un valor al momento de ser declarada. Esto viene en "combo" con el bucle for.

Y ahora presente a otra estrella de los premios Oscar: For.

La estructura es muy similar a While. Fíjate cómo se declara y cómo se finaliza. Ambos

utilizan las llaves y llevan una condición, o más entre paréntesis. Vamos a estudiar estas

condiciones.

Primero, le asignamos un valor a a, en este caso 0; igualmente le podríamos asignar

libremente un 5 o un 2543636, pero esta vez alteraría el resultado deseado.

Después, establecemos la condición principal: El bucle se repetirá una y otra vez,

mientras a sea menor o igual que 5000; esta condición es similar a la ya estudiada. Y por

último está un tercer argumento, aquí establecemos que se le sumará la unidad a a; si


pusieramos un a = a + 2, obtendríamos una cuenta de 2 en 2, y por lo tanto, sólo 2500

impresiones.

Después, sólo hacemos uso de printf.

Para terminar, la frase de cierre.

Haz la prueba. Obtendrás el mismo resultado que con While.

Juega con ambos bucles. Cambia el valor de las variables, las sumas de for, en fin...

experimenta todo lo que se te ocurra.

¿Ya jugaste un rato? Perfecto, vamos a divertirnos un poco más con los condicionales.


If ¿Qué es un condicional? Seguramente fue la primera pregunto que se e ocurrió. Un

condicional es una sentencia que si es verdadera, realizará una acción determinada por

el autor. La práctica hace al maetsro, mejor te daré un ejemplo, y seguramente te quedará

más claro el concepto.

/*Sentencias: if*/ #include <stdio.h> int main() { int a; printf("Introduce un número entero mayor o igual que 100: "); scanf("%i",&a); getchar(); if (a >= 100) { printf("Perfecto, el número %i es mayor o igual que 100.",a); } printf("\n\nPresiona ENTER para salir."); getchar(); return 0; }

Paso a paso, todo lo que no se explique, ya lo sabes pues se realizo en practicas anteriores.

if (a >= 100) { printf("Perfecto, el número %i es mayor o igual que 100.",a); }

Ésta es la estructura básica de un condicional, fíjate que es muy parecida la de un bucle.

Entre paréntesis tenemos la condición, si ésta es verdadera, se ejecutará la acción entre

llaves.

En este caso estamos diciendo que si a (previamente declarado, y modificado en scanf) es

mayor o igual a 100 mostrará un mensaje en pantalla.

Compila el programa y fíjate cómo funciona.


If se puede complicar un poquito más, existen las sentencias else y else if. Lo que hacen es

duplicar la funcionalidad de if. Vamos a hacer más complejo el ejemplo con ayuda de estas

extensiones.

/*Sentencias: if segunda parte*/ #include <stdio.h> int main() { int a; printf("Introduce un número entero mayor o igual que 100: "); scanf("%i",&a); getchar(); if (a >= 100) { printf("Perfecto, el número %i es mayor o igual que 100.",a); } else { printf("El número %i es menor que 100.",a); } printf("\n\nPresiona ENTER para salir."); getchar(); return 0; }

Aquí está la parte importante,

if (a >= 100) { printf("Perfecto, el número %i es mayor o igual que 100.",a); } else { printf("El número %i es menor que 100.",a); }

En realidad es muy simple, se declara una sentencia como ya lo vimos y se establece la

acción a realizar en caso de que el condicional sea verdadero. Pero, al finalizar las llaves de

if, escribimos la palabra else y su "acción".


Else, podríamos decir que significa "si no" o "en caso de que no". Así podemos

traducir C al Castellano de la siguiente forma:

Si a es mayor o igual a 100 escribe "Perfecto, el número %i es mayor o igual que 100." en

caso de que no, escribe "El número %i es menor que 100."

Con esto debería de quedarte más claro como funciona.

Compílalo y ejecútalo.

En el programa anterior, si escribíamos un número menor que 100 simplementelo ignoraba y

finalizaba el programa. Esta vez, intenta escribir un 12 por ejemplo y fíjate como muestra el

segundo mensaje por que la primera aseveracíon fue falsa.


Para terminar vamos a ver el tercer brazo de los condicionales: el else if.

/*Sentencias: if tercera parte*/ #include <stdio.h> int main() { int a; printf("Introduce un número entero mayor o igual que 100: "); scanf("%i",&a); getchar(); if (a > 100) { printf("Perfecto, el número %i es mayor que 100.",a); } else if (a == 100) { printf("Perfecto, introduciste un %i.",a); } else if (a < 100) { printf("Muy mal, el número %i es menor que 100.",a); } printf("\n\nPresiona ENTER para salir."); getchar(); return 0; }

Vamos a lo que nos interesa:

if (a > 100) { printf("Perfecto, el número %i es mayor que 100.",a); } else if (a == 100) { printf("Perfecto, introduciste un %i.",a); } else if (a < 100) { printf("Muy mal, el número %i es menor que 100.",a); }


Todo el condicional. Fíjate que el principal es el que se encuentra al principio. Se declara de

la misma forma. Al terminar sus llaves declaramos un else if, que sigue la

misma morfología. En total son dos else if.

Un else if es como decir: "si no se cumple y..." Como lo hice antes, vamosa traducir el C a

Español:

Si a es mayor a 100 escribe "Perfecto, el número %i es mayor que 100." Si no es mayor a

100, pero es igual a éste, "Perfecto, introduciste un 100". Si ninguno de los anteriores es

verdadero y a es menor a 100, "Muy mal, el número %i es menor que 100."

Es simple entenderlo si ya tienes las bases (ya las tienes, sino, LEE la practica nuevamente

completa).

A diferencia de else, else if brinda más posibilidades.

Compila el programa, ejecútalo y observa los resultados.


Practica 6 Funciones

En esta practica vamos a echar un vistazo (tal vez un poco más que eso) al trabajo

con funciones de C. Su uso es tan común como importante; nos ayudan a tener un

código más legible y estructurado y hasta reducir centenares de líneas inútiles (entre otros

menesteres).

Una función es una estructura que almacena pedazos de código y que puede ser utilizada

cuantas veces se desee en cualquier parte de nuestro programa. Hasta aquí la teoría, no se

requiere más; inicia tu IDE y comienza un nuevo archivo.

/*Funciones*/ #include <stdio.h> int numero = 0; int texto() { if (numero >= 0 && numero < 10) { printf("Feliz "); } if (numero >= 10 && numero < 20) { printf("Navidad "); } if (numero >= 20 && numero < 30) { printf("A "); } if (numero >= 30) { printf("CETIS 50."); } return 0; } int main() { texto(); getchar(); numero = 10; texto(); getchar(); numero = 20; texto(); getchar(); numero = 30; texto(); getchar(); return 0; }

¿Recuerdas que main es una función? (Si no regresa a los primeros tutoriales o date un baño

de agua fría para refrescar la memoria.) Pues no hay diferencia en las funciones que estamos

tratando en este tutorial (a excepción de que las últimas no son imprescindibles).


¿También recuerdas los tipos de datos? Para declarar una función basta con anteponer a su

nombre el tipo de dato al que pertenecerá la función, posteriormente escribir paréntesis y

continuar con el código de la función entre corchetes {}. Aségurate de no elegir nombres

con espacios y/o con palabras reservadas (int,while,if,return) o caracteres extraños,

En el ejempĺo estamos usando el tipo int; siempre, de ser así, la función debe de devolver

un valor, es por eso que la finalizar nuestro código escribimos el return 0;. Si quieres evitar

poner esta última línea puedes usar el tipo personalizado void. Void e Int son los más

comunes.

Ahora que sabes cómo declarar una función te debes de estar preguntando cómo ponerla en

acción (bueno, seré sincero: seguramente ya descubriste cómo). Para hacerlo basta con

poner el nombre de la función seguido de sus respectivos paréntesis(). Cuidado con el punto

y coma.

Como mencionaba en la introducción puede llamar a una función las veces que quieras. Sólo

echa un vistazo al ejemplo.

Felicidades, ya sabes usar funciones. Pero antes de finalizar quisiera entrar en un subtema

que seguramente hubiera dado muchos dolores de cabeza a los poco experimentados: Las

variables locales y globales.

Una variable global es aquella que puede ser utilizada en cualquier parte del código de

principio a fin.

Por otro lado una variable local es aquella cuyo uso queda restringido a la región del

código en donde fue declarada.


Cómo mencioné para hacer distinción entre una variable local y una global basta con

declararlas en ciertas zonas del código. Vamos a echar un vistazo a la estructura ideal (en la

mayoría de los casos):

1. Directivas

2. Variables y Constantes

3. Funciones

4. Main (hago distinción, pero sigue siendo una función).

Para declarar una variable global basta con iniciarla en el apartado dos (Variables y

Constantes). Por el contrario si queremos que una variable sea de uso restringido debemos

iniciarla en la función en donde actuará. Vamos a poner esto en práctica.

/*Globalización :P*/ #include <stdio.h> int numero = 0; int texto() { int a; if (numero >= 0 && numero < 10) { printf("Feliz "); } if (numero >= 10 && numero < 20) { printf("Navidad "); } if (numero >= 20 && numero < 30) { printf("A "); } if (numero >= 30) { printf("CETIS 50\n"); for (a=0; a<70; a++) { printf("*"); } } return 0; } int main() { int a; for (a=0; a<30; a++) { printf("~"); } texto(); getchar(); for (a=0; a<30; a++) { printf("~"); } numero = 10; texto();

Practicas Programación 2015 Fecha de entrega: Nombre: Firma profesor: getchar(); for (a=0; a<30; a++) { printf("~"); } numero = 20; texto(); getchar(); for (a=0; a<30; a++) { printf("~"); } numero = 30; texto(); getchar(); return 0; }

Doy por hecho que entiendes perfectamente el 95% del programa, por eso me limito a

explicar lo que realmente nos interesa.

Empecemos por identificar las variables locales y globales:

numero es global por no estar dentro de ninguna función. Fíjate cómo usamos la variable

numero tanto en main() como en texto().

a es una variable local por estar dentro de las funciones. Fíjate que hemos declarado dos

variables con el mismo nombre (una en main() y otra en texto()). En situaciones diferentes

esto hubiera ocasionado un error grave; pero estamos ante variables locales, su

funcionamiento no "se cruza" por esta simple razón


Como siempre, no te quedes con lo único que viene en esta practica. La programación es

muy amplia (me aventuraría a decir que es casi infinita); experimenta, juega con todo lo

que has aprendido.

Hasta Aquí termina la primera etapa de Prácticas.

Este material fue tomado para ser utilizado con fines Didácticos de http://www.scene

beta.com/ y la autoria es en su totalidad del usuario “the dragon lives” a quien agradecemos

el poder utilizar este material.

Practicas bloque 1

Engineering

Transcript of Practicas bloque 1