Pila,retorno,etc

PILA

Una pila es una estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last in First Out, último en entrar, primero en salir) que permite almacenar datos.

Se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.
En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack  en inglés).

Para entender mejor su funcionamiento podemos usar la analogía de una pila de platos, el primero que ponemos encima de la pila de platos es el primer plato que sacamos.

La pila de llamadas es la zona de memoria que utiliza esta estructura de datos para almacenar información sobre las llamadas a funciones. Cuando empieza la ejecución del programa, la pila está vacía. En cada llamada a una función o subrutina, en la pila se almacena:

1.        La dirección de memoria a la siguiente instrucción de código donde debe retornar despúes de ejecutarse la función.

1. Los datos pasados como parámetros a la función.
2.  Las variables locales utilizadas por la función.
3. i la función devuelvo algún valor también lo almacena en la pila.
4. Vamos a ver un ejemplo con un trozo de código en C#.

Ejemplo de Pila:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

#include <iostream.h> #include <conio.h> #include <string.h> #include <stdlib.h> #include <stdio.h> struct pilas { int d; pilas *a; }*c,*e; void menu(void); void ingresar(void); void sacar (void); void actualizar_pila(void); main() { menu(); } void menu(void) { int y,opc;  for(;;)  {  cout<<"\n1. Ingresar datos";  cout<<"\t2. Sacar datos";  cout<<"\t0. Terminar";  cout<<"\n Ingrese opcion: ";cin>>opc;  switch(opc)  {  case 1:  ingresar();  break;  case 2: sacar();  break;  case 0: exit(1);  default: cout<<"\n Opcion no valida!!"; break;  } actualizar_pila(); cout<<"\n\nOprima una tecla para continuar"; getch();  } } void ingresar (void) {  if(!c)  {  c=new(pilas);  cout<<"Ingrese elemento: ";  cin>>c->d;  c->a=NULL;  return;  }  e=new(pilas);  cout<<"\nIngrese elemento: ";  cin>>e->d;  e->a=c;  c=e; } void sacar(void) {  if(!c)  {  cout<<"\n\nNo hay elementos!!";  return;  }  e=new(pilas);  e=c;  cout<<"\n\nElemento eliminado: " <<e->d;  c=e->a;  delete(e); } void actualizar_pila(void) {  int y=2,i,ca=0;  e=c;  while(e)  {  ca++;  e=e->a;  } for(i=0;i<=ca;i++)  {  cout<<" ";  }  //muestro lo que tiene la pila!!  i=0;  e=c;  while(e)  {  cout<<"\n";  cout<<++i<<" - "<<e->d;  e=e->a;  } }

RETORNO

Las funciones con retorno son muy parecidas a las funciones sin retorno, pero su diferencia radica en para qué se utilizan.

Las funciones con retorno crean un “mini-programa” que se encarga de obtener, preparar o modificar una variable. La función con retorno nos devuelve ese valor justo cuando se lo pidamos, sin tenerle que decir una y otra vez al programa como obtener ese dato que necesitamos. Un ejemplo podría ser una función que se encargue de mapear el valor del potenciómetro y después retorne el valor ya mapeado del mismo componente, o también se podría hacer una función que según la distancia que viera el sensor de ultrasonidos te dijera si estás más o menos cerca del objeto que tienes delante.

Estas variables con las que jugamos en nuestras funciones con retorno pueden ser de cualquier tipo: numéricas, de texto o incluso vectores

Ejemplo

Veamos ahora las funciones que devuelven un valor, pueden ser del tipo que queramos. En este caso hagamos la misma función "Suma", pero ahora va a devolver un valor, que será el resultado de la suma de los dos números que recibe por parámetro.

Quedaría de esta forma:

De esta forma la función cambia un poco. Lo primero es que ahora no es "void", ya que si devuelve un valor en vez de "void" ponemos el tipo de dato que devolverá la función, en este caso un número entero, por lo tanto "int".

Dentro de la función, hacemos la suma de ambos números y la guardamos en una variable llamada "r". Para devolver el valor escribimos la cláusula "return", por lo tanto, esta función devolverá el resultado de la suma de ambos números, que está en la variable "r".

Parámetro y Argumentos defunciones

Las palabras parámetro y argumento, aunque de significado similar, tiene distintas connotaciones semánticas: Se denominan parámetros los tipos declarados en el prototipo (que deben corresponder con los declarados en la definición). Cuando se realiza una llamada a la función, los "valores" pasados se denominan argumentos. A veces se utilizan también las expresiones argumentos formales, para los parámetros y argumentos actuales para los valores pasados.

La sintaxis utilizada para la declaración de la lista de parámetros formales es similar a la utilizada en la declaración de cualquier identificador.  A continuación, se exponen varios ejemplos:

int func(void) {...}                  // sin parámetros
inf func() {...}                      // ídem.
int func(T1 t1, T2 t2, T3 t3=1) {...} // tres parámetros simples,
                                      // uno con argumento por defecto
int func(T1* ptr1, T2& tref) {...}    // los argumentos son un puntero y
                                      // una referencia.
int func(register int i) {...}        // Petición de uso de registro para
                                      // argumento (entero)
int func(char* str,...) {...}         /* Una cadena y cierto número de otros
             argumentos, o un número fijo de argumentos de tipos variables */

  Los argumentos son siempre objetos. Sus tipos pueden ser: escalares; estructuras; uniones, o enumeraciones; clases definidas por el usuario; punteros o referencias a estructuras y uniones, o punteros a funciones, a clases o a matrices. El tipo void está permitido como único parámetro formal. Significa que la función no recibe ningún argumento.

Variable Locales

Una variable local es aquella cuyo ámbito se restringe a la función que la ha declarado se dice entonces que la variable es local a esa función. Esto implica que esa variable sólo va a poder ser manipulada en dicha sección, y no se podrá hacer referencia fuera de dicha sección. Cualquier variable que se defina dentro de las llaves del cuerpo de una función se interpreta como una variable local a esa función.

Cuando una variable x es local a una función func1, significa que la función func1 es la propietaria de dicha variable, y puede acceder a ella y modificarla. Si cualquier otra función del programa necesita conocer el valor de la variable x, es la función func1 la que debe transferir el valor de x a través del paso de argumentos en la llamada a la función. Si además esta función desea modificar el valor de dicha variable, entonces tendrá que devolver el nuevo valor a func1, y será func1 quien se encargue de asignar el valor devuelto a su variable x.