This Text file is old! In a ��Museum, an unsorted archive of (user-)pages. (Saved from Geocities in Oct-2009. The archival story: oocities.org)
--------------------------------------- (To 🚫report any bad content: archivehelp @ gmail.com)

1.- Enunciado:

Escriba un programa que pida un número cualquiera
y luego muestre el doble del número.

2.- Resolución paso a paso:

Como no se toman argumentos en la línea de argumentos
del programa, el esqueleto de la función main() será:

int
main(void)
{
	return 0;
}

El int de retorno es obligatorio por el estándar ANSI, y void indica
que no se toman argumentos.  Como la función se declara que retorna 
un int, se agrega la instrucción return 0; para satisfacer ese requisito.
Si no se pusiera ningún return, el compilador se quejaría con un aviso
por ello.

Escribimos entonces el esqueleto en un archivo cuyo nombre tenga la
extensión .c como por ejemplo doble.c y lo compilamos con la siguiente
orden:

cc -Wall -o doble doble.c

En esta orden indicamos al compilador que debe activar todos (all) los avisos
(-W), que el nombre del ejecutable (-o) será doble, y que el fuente a
compilar se llama doble.c.

Dado que el esqueleto es tan sencillo no hay muchas posibilidades para el
error.  Si hubiera alguno, se debe comparar el contenido de doble.c con
el fragmento de código descripto más arriba y compilarlo hasta que en el
directorio actual aparezca el archivo doble con permisos ejecutables y
el proceso de compilación no muestre ningún mensaje.

Luego procedemos a correr el programa con la orden:

./doble

y el prompt debe volver a aparecer.  El programa no ha hecho nada, 
pues no le hemos puesto código para que haga nada.  Bueno, esto no es
tan así, pues sí hay una instrucción en el programa: el return 0;.
De acuerdo al sistema operativo, será la manera de controlar el
código de retorno de un programa ejecutable.  En el caso de Unix y sus 
variantes, esto se hace con:

echo $?

que mostrará un 0.

Esta instrucción para el shell le solicita que muestre el código de 
retorno del último programa que se ejecutó en forma sincrónica.  Más
información sobre estos temas la puede encontrar consultando las 
páginas de manual del programa shell que usa.  Por ejemplo, si usa
el shell Bash, haciendo man bash encontrará la página de manual del Bash.
Si su sistema operativo no es parecido a Unix, deberá buscar en la
documentación de desarrollo del sistema para ver cómo se controlan
los códigos de retorno (return code, o ERRORLEVEL, según los sistemas)
en su caso particular.

Volvemos al programa doble.c.

El programa tendrá una estructura elemental, que es compartida por 
muchos programas:

* Comienzo
* Entrada de datos
* Cálculo
* Salida de resultados
* Final

El comienzo y el final ya los tenemos codificados en nuestro
esqueleto: el comienzo será a través de la función main() y el
final es la instrucción return 0;.

Vamos a hacer ahora la salida de resultados.

int
main(void)
{
	printf("El número es 2 y el doble es 4\n");
	return 0;
}

Estamos dejando fijo el número en el valor 2, con lo cual su doble
será 4.  Esto no es lo que pide el enunciado, pero lo hacemos para
acomodar las instrucciones en el programa.  La instrucción usada es
printf() que toma como argumentos una cadena de caracteres (que va
entre comillas dobles) y a continuación una lista de expresiones (que
en este caso es una lista vacía).

Cuando compilamos este programa aparece el siguiente mensaje:

doble.c: In function `main':
doble.c:12: warning: implicit declaration of function `printf'

y el ejecutable se genera sin problemas.

Esta clase de mensajes es el aviso (warning) de que algo del fuente
es irregular, sin ser un error.

La forma de evitar ese mensaje ---y resolver el problema de fondo--- es 
declarar la función printf() mediante un prototipo.  Podríamos escribir 
el prototipo nosotros mismos, pero eso es más propenso a error.  La 
forma aceptable para declarar los prototipos de las funciones de la 
biblioteca estándar es mediante la inclusión del archivo de cabecera 
correspondiente.

#include 

Esta es una instrucción para el preprocesador, que le indica que debe 
incluir el archivo stdio.h en ese punto del código fuente.  Sabemos que 
stdio.h se buscará en los directorios estándar del sistema porque el 
nombre está encerrado entre corchetes angulares ( < y > ).   Si el 
nombre del archivo estuviese entre comillas dobles, entonces significa 
que dicho archivo se busca entre los archivos del proyecto en curso, y  
no entre los estándares.

Ahora el programa nos queda:

#include 

int
main(void)
{
        printf("El número es 2 y el doble es 4\n");
        return 0;
}

Lo compilamos, lo ejecutamos y todo bien hasta acá.

Vamos a agregar los cálculos.


#include 

int
main(void)
{
	int numero, doble;

	numero= 7;
	doble= numero * 2;

        printf("El número es %d y el doble es %d\n", numero, doble);
        return 0;
}

Veamos cada instrucción por turno:

int numero, doble; 

La primer sentencia ahora es la declaracion de dos variables de tipo
entero, cuyos nombres son numero y doble.


numero= 7;

Se asigna la variable numero con el valor entero 7.


doble= numero * 2;

Otra asignación, esta vez se asigna a la variable doble el resultado de 
la expresión (numero * 2).


printf("El número es %d y el doble es %d\n", numero, doble);

En el printf() hemos cambiado la cadena de especificación de formato, 
para incluir un par de %d, que sirven para indicar que se escribirá un 
número en formato decimal.  Estos %d se corresponden con cada una de las 
expresiones que siguen a la cadena de especificación de formato, que son 
en este caso los valores de las variables numero y  doble, 
respectivamente.


Agreguemos ahora la entrada de datos.


#include 

int
main(void)
{
        int numero, doble;

        scanf("%d", &numero);
        doble= numero * 2;

        printf("El número es %d y el doble es %d\n", numero, doble);
        return 0;
}

La función scanf() sirve para leer desde la entrada estándar usando 
formato, muy parecido a lo que hace printf() para la salida.

El formato %d indica que se va a leer un número en formato decimal.

Note que a diferencia de printf(), la variable está precedida por un 
signo ampersand (&) que indica al compilador que se debe obtener la 
dirección de la variable, en lugar de su valor.

Con esto damos por terminado el ejercicio.