fundamentos

1. Fundamentos de la
programación
Integrantes:
Juan José Yanangomez Salinas.

2. Procedimientos
Un procedimiento es un fragmento de código cuya función es la de realizar una tarea
específica independientemente del programa en el que se encuentre. Con los
procedimientos se pueden crear algoritmos de ordenación de arrays, de modificación
de datos, cálculos paralelos a la aplicación, activación de servicios, etc. Prácticamente
cualquier cosa puede realizarse desde procedimientos independientes.

3. #include <stdio.h>
#include <stdlib.h>
void areatriangulo (void) {
float base, altura;
printf("Introduce base: ");
scanf("%f",&base);
printf("Introduce altura: ");
scanf("%f",&altura);
printf("El área es: %2.2f n",(base*altura)/2);
}
int main(int argc, char *argv[])
{
areatriangulo();
system("PAUSE");
return 0;
}

4. Funciones
Una función es una parte con nombre de un programa que puede ser involucrada o
llamada desde cualquier otra parte del programa cuando haga falta. La sintaxis de las
funciones depende de si la declaramos o las definimos.
La declaración se escribe poniendo el tipo que retorna la función seguido de su nombre
y de una lista de parámetros entre paréntesis (los parámetros deben ser de la forma
tipo-parametro, (nom_param), donde los corchetes indican que el nombre es opcional),
para terminar la declaración ponemos punto y coma (recordar que una declaración es
una sentencia).
Para definir una función se escribe el tipo que retorna, el nombre de la función y una
lista de parámetros entre paréntesis. A continuación se abre una llave, se escriben las
sentencias que se ejecutan en la función y se cierra la llave.

5. #include <stdio.h>
#include <stdlib.h>
float areatriangulo (void) {
float base, altura;
printf("Introduce base: ");
scanf("%f",&base);
printf("Introduce altura: ");
scanf("%f",&altura);
return (base*altura)/2;
}
int main(int argc, char *argv[])
{
float area;
area=areatriangulo();
printf("El área es: %2.2f n",area);
system("PAUSE");
return 0;
}

6. Variables locales
A diferencia de las anteriores, las variables definidas DENTRO de una función, son
denominadas VARIABLES LOCALES a la misma, a veces se las denomina también como
AUTOMÁTICAS, ya que son creadas y destruidas automáticamente por la llamada y el
retorno de una función, respectivamente.
Estas variables se ubican en la pila dinámica (stack) de memoria , destinándosele un
espacio en la misma cuando se las define dentro de una función, y borrándose cuando la
misma devuelve el control del programa, a quien la haya invocado.
Este método permite que, aunque se haya definido un gran número de variables en un
programa, estas no ocupen memoria simultáneamente en el tiempo, y solo vayan
incrementando el stack cuando se las necesita, para luego, una vez usadas desaparecer,
dejando al stack en su estado original.

7. El identificador ó nombre que se la haya dado a una variable es sólo relevante entonces,
para la función que la haya definido, pudiendo existir entonces variables que tengan el
mismo nombre, pero definidas en funciones distintas, sin que haya peligro alguno de
confusión .
La ubicación de estas variables locales, se crea en el momento de correr el programa, por lo
que no poseen una dirección prefijada, esto impide que el compilador las pueda inicializar
previamente. Recuérdese entonces que, si no se las inicializa expresamente en el momento
de su definición, su valor será indeterminado (basura).

8. Variables globales
Este tipo de variable será ubicada en el segmento de datos de la memoria utilizada
por el programa, y existirá todo el tiempo que esté ejecutándose este.
Este tipo de variables son automáticamente inicializadas a CERO cuando el programa
comienza a ejecutarse.
Son accesibles a todas las funciones que estén declaradas en el mismo, por lo que
cualquiera de ellas podrá actuar sobre el valor de las mismas.

9. #include <stdio.h>
double una_funcion(void);
double variable_global ;
main()
{
double i ;
printf(“%f”, variable_global ); /* se imprimirá 0 */
i = una_funcion() ;
printf(“%f”, i ); /* se imprimirá 1 */
printf(“%f”, variable_global ); /* se imprimirá 1 */
variable_global += 1 ;
printf(“%f”, variable_global ); /* se imprimirá 2 */
return 0 ;
}
double una_funcion(void)
{
return( variable_global += 1) ;
}

10. nt y; /* Global. Conocida tanto por main() como por MiFuncion() */
main ()
{
int x; /* Esta x es local a main () */
y = 100;
x = 1;
printf (“x=%d, y=%d”, x, y) /* Visualiza x=1, y=100 */
{ /* Comienza bloque */
int x; /* Esta x es local al bloque */
x = 2;
printf (“x=%d, y=%d”, x, y) /* Visualiza x=2, y=100 */
MiFuncion () /* Visualiza x=3, y=100 */
printf (“x=%d, y=%d”, x, y) /* Visualiza x=2, y=100 */
} /* Fin del bloque */
printf (“x=%d, y=%d”, x, y) /* Visualiza x=1, y=100 */
}
MiFuncion ()
{
int x; /* Local a MiFuncion() */
x = 3;
printf (“x=%d, y=%d”, x, y) /* Visualiza x=3, y=100 */
}

11. Observemos que la variable_global está definida afuera de las funciones del programa,
incluyendo al main(), por lo que le pertenece a TODAS ellas. En el primer printf() del
programa principal se la imprime, demostrándose que está automáticamente
inicializada a cero .
Luego es incrementada por una función() que devuelve además una copia de su valor,
el cual es asignado a i ,la que, si es impresa mostrará un valor de uno, pero también la
variable_global ha quedado modificada, como lo demuestra la ejecución de la
sentencia siguiente. Luego main() también modifica su valor , lo cual es demostrado
por el printf() siguiente.
Esto nos permite deducir que dicha variable es de uso público, sin que haga falta que
ninguna función la declare, para actuar sobre ella.

12. Parámetros
Todos los parámetros se pasan valor por valor, es decir, se hace una copia de los
parámetros cuando llamamos a la función.
En la llamada, antes de hacer la copia, se chequea que los parámetros actuales (los valores
o variables especificados en la llamada) son del mismo tipo que los parámetros formales (
los que declaramos en la lista de parámetros de la declaración de la función). Si los tipos
son iguales o existe una conversión implícita la llamada puede realizarse, si no son iguales
deberemos realizar conversiones explicitas.
Una función es un bloque de sentencias identificado por un nombre y puede recibir y
devolver datos. En bajo nivel, en general, las funciones operan como las subrutinas de
Assembler, es decir, al ser llamadas, se guarda en la Pila el valor actual del PC (Program
Counter), después se ejecuta todo el código de la función y finalmente se recobra el PC
para regresar de la función.