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 = %in",a);
printf("suma = %in",suma);
printf ("a + suma = %in",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 = %in",a);
Entre paréntesis puedes ver 2 argumentos. Hasta aquí ya deberías de conocer el
primero "a = %in" 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 = %in",suma);
printf ("a + suma = %in",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*/

#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: %fn",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: %fn",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 40sn",
precioIva);
precio = 50;
printf("nHoy, mi auto cuesta %f "$imoleanos" sin
IVA.n",precio);
printf("Hoy, mi auto cuesta %f "$imoleanos" con IVA.n",
precioIva);

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;
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 40sn",
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;

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: %fn",a);
getchar();
printf("Introduce una letra: ");
scanf("%c",&b);
printf("Introduciste la letra %cnn",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: %fn",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 %cnn",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ñosnnPresiona 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 %in",timer);
}
printf("Presiona ENTER para continuar");
getchar();
return 0;
}
Paso a paso

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;
}
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;
++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 %in",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("nnPresiona 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)
{
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;
scanf("%i",&a);
getchar();
if (a >= 100)
{
100.",a);
}
else
{
printf("El número %i es menor que 100.",a);
}
getchar();
return 0;
}
Aquí está la parte importante,
if (a >= 100)
{
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;
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);
}
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 ");
}
{
printf("Navidad ");
}
{
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;
{
printf("Feliz ");
}
{
printf("Navidad ");
}
{
printf("A ");
}
if (numero >= 30)
{
printf("CETIS 50n");
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();

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

Más contenido relacionado

La actualidad más candente

Similar a Practicas bloque 1

Más de Arana Paker

Último

Practicas bloque 1