C++ cap 7

Tema 7 - Funciones.
El formato general de una función de C es:
tipo nombre(lista de parámetros)
{
   cuerpo de la función
}
Las funciones son simulares a las de cualquier otro lenguaje, pero, tal  y como
citamos  en la  introducción,  al  no ser  un lenguaje  estructurado  por  bloques,  no es
posible declarar funciones dentro de otras funciones.
7.1 - La sentencia return.
Antes  de  empezar  la  explicación  de  las  funciones,  conviene  explicar  la
sentencia return. La sentencia return permite, en primer lugar, salir de la función desde
cualquier  punto de la misma,  y en segundo lugar,  devolver  un valor  del  tipo de la
función, si ello es necesario (no se devuelve ningún valor si la función es de tipo void).
Veamos un ejemplo:
int Comparacion(int a,int b)
{
   if (a>b) return 1;  /* a es mayor que b */
   if (a<b) return -1; /* a es menor que b */
   return 0;           /* a y b son iguales */
}
Como se  observa  en  el  ejemplo,  una  función  puede  contener  más  de  una
sentencia  return.  Ello  permite,  la  posibilidad  de  poder  salir  de  la  función  desde
distintos puntos de la misma. Un aspecto que conviene resaltar es el hecho de que una
función también  termina  su  ejecución si  llega  al  final  de  la  misma  sin  encontrar
ninguna sentencia  return.  Ello es posible en toda  función de tipo  void.  Veamos un
ejemplo:
void A(int *a)
{
   *a=5;
}
Esa función es equivalente a otra que tuviera como última línea una sentencia
return, y funcionaría de igual forma.
7.2 - Argumentos de las funciones,  llamada por valor y por
"referencia".
Una vez conocido el  uso de la  función  return,  podemos introducirnos  en la
explicación  de  las  funciones.  En primer  lugar,  si  una  función usa  argumentos,  esEl lenguaje de programación C
necesario declarar  variables  que acepten los argumentos  de la función.  Veamos  un
ejemplo:
int EstaEn(char *cad,char c) /* Devuelve 1 si el carácter c */
{                            /* esta en el string cad */
   while (*cad!=‘\0’)
{
      if (*cad==c)
         return 1;
cad++;
}
return 0;
}
Esta función, podría ser llamada desde otra función de la siguiente forma:
char cadena[]=“Esta es una cadena de prueba”;
if (EstaEn(cadena,’a’))
   printf(“Esta”);
else
   printf(“No esta”);
A diferencia de otros lenguaje, el lenguaje C, solo permite pasar parámetros a
las funciones por valor. Si se desea que los cambios efectuados en una función sobre
una variable afecten fuera del alcance de la función, es posible simular un paso por
referencia mediante el uso de punteros. En efecto, si a una función le pasamos como
argumento la dirección de una variable, cualquier modificación que se realice en esa
dirección,  afectara,  lógicamente,  al  valor  que tiene la  variable  original,  y con ello,
conseguiremos el mismo efecto que un paso por referencia. Veámoslo con un ejemplo:
#include <stdio.h>
void Alfa(int *val,float pos)
{
   *val=5;
pos=7.7;
return;
}
void Beta(int val,float *pos)
{
val=10;
*pos=14.7;
}
int main(void)
{
int a=6;
float b=9.87;
printf(“Al principio valen a=%d b=%f\n”,a,b);
   Alfa(&a,b);
   printf(“Después de Alfa valen a=%d b=%f\n”,a,b);
   Beta(a,&b);
   printf(“Después de Beta valen a=%d b=%f\n”,a,b);
}
Este programa mostrara en pantalla:El lenguaje de programación C
Al principio valen a=6 b=9.87
Después de Alfa  valen a=5 b=9.87
Después de Beta valen a=5 b=14.7
Ello es, pues a Alfa se le pasa la variable a por "referencia" (se le pasa  &a, o
sea, un puntero a la variable a), y la variable b por valor, mientras que en Beta sucede
al revés.
7.3 - Arrays como argumentos de funciones.
Un aspecto a tener muy en cuenta es que C no permite el paso de un array por
valor a una función, un array es siempre pasado por "referencia", pues en la llamada, lo
que se pasa es la dirección del primer elemento del array (recuérdese que el nombre de
un array es un puntero al  primer elemento).  Por valor  tan solo es posible pasar  por
valor  elementos individuales del  array,  pero no el  array completo.  Veámoslo en un
ejemplo:
#include <stdio.h>
void PasoValorReferencia(int *array,int valor)
{
   array[5]=-8.6;
valor=4;
}
int main(void)
{
   int array[10]={0,0,0,0,0,0,0,0,0,0};
   PasoValorReferencia(array,array[3]);
   printf(“Array[5] vale: %d y array[3] vale:%d\n”,array[5],array[3]);
   return 0;
}
Colocara en pantalla en el mensaje:
Array[5] vale: 8.6 y array[3] vale: 0
7.4 - Argumentos de la función main.
La  función  main(),  como  toda  función  de  C,  acepta  argumentos.  Los
argumentos que acepta la función main() son un entero (int argc), un array de punteros
a strings (char *argv[]), y otro array de punteros a strings (char *env[]). Aunque los
nombres  de  dichos  argumentos  no tienen porque ser  argc,  argv,  y  env,  en toda  la
literatura de C se usan dichos nombres, y aquí los respetaremos. El significado de los
parámetros argc, argv y env es el siguiente:
• El parámetro argc contiene el número de argumentos en la línea de ordenes de
la llamada al programa.
• El parámetro argv contiene un puntero a cada uno de los argumentos (strings)
de la línea de ordenes de la llamada al programa.El lenguaje de programación C
• El parámetro env contiene un puntero a cada una de las variables de ambiente
(strings) del sistema operativo.
Veamos un ejemplo de programa que use argumentos en la línea de ordenes:
#include <stdio.h>
int main(int argc,char *argv[],char *env[])
{
   int i;
printf(“El valor de argc es: %d\n”,argc);
for(i=0;i<argc;i++)
      printf(“El argumento %d es: %s\n”,i,argv[i]);
for(i=0;env[i]!=NULL;i++)
printf("La variable de ambiente %d es: %s\n",i,env[i]);
   return 0;
}
Supongamos que el programa lo hemos llamado prueba.exe, entonces, llamando
al programa con la siguiente línea:
prueba.exe   Este_es_el_argumento_1   Este_es_el_argumento_2
Escribirá en pantalla:
El valor de argc es: 3
El argumento 0 es: prueba.exe
El argumento 1 es: Este_es_el_argumento_1
El argumento 2 es: Este_es_el_argumento_2
La variable de ambiente 0 es: COMSPEC=C:\DOS\COMMAND.COM
La variable de ambiente 1 es: TEMP=C:\WINDOWS\TEMP
La variable de ambiente 2 es: PROMPT=$P$G
Como se puede observar, existen 3 argumentos, numerados de 0 a 2, siendo el
argumento 0,  siempre, el  nombre del  programa,  y siendo el resto de argumentos los
argumentos del  programa.  El  número y valor  de las variables de ambiente depende,
tanto  de  que  sistema  operativo  se  trate  (MS-DOS,  UNIX,  etc.),  como  de  la
configuración, etc., del procesador de comandos de dicho sistema operativo.
7.5 - Recursividad.
Una función de C puede llamarse a si misma. Este proceso recibe el nombre de
recursividad. Los ejemplos de recursividad abundan, siendo uno de los mas habituales
la función factorial:
unsigned Factorial(unsigned num)
{
   if (num==0) return 1;
return num*Factorial(num-1);
}El lenguaje de programación C
La recursividad es una poderosa  herramienta  de programación,  sin embargo,
presenta dos problemas:
• La velocidad de ejecución de un algoritmo programado de forma recursiva es
mucho mas lento que el programado de forma iterativa.
• La recursividad, si es excesiva, puede ocasionar el desbordamiento de la pila, y
con ello, el fallo en la ejecución del programa.
Sin  embargo,  el  uso  de  la  recursividad  es  frecuente  en  campos  como  la
inteligencia artificial, etc., y en la implementación de ciertos algoritmos tales como el
algoritmo de ordenación "QuickSort", muy difícil de implementar de forma iterativa,
pero relativamente sencillo de forma recursiva.
7.6 - Punteros a funciones.
Al  igual  que cualquier otro tipo de dato,  una función ocupa una dirección de
memoria, y por tanto, puede ser apuntada por un puntero. La declaración de un puntero
a una función es:
tipo de dato (*nombre de la variable)(prototipo);
Veamos algunos ejemplos:
int (*a)(int,float);
void (*b)(void);
Generalmente,  los  punteros  a funciones se usan en la programación de bajo
nivel,  tal  como  modificación  de  interrupciones,  creación  de  controladores  de
dispositivos, etc.
7.7  -  El  modificador  de  almacenamiento  static  aplicado  a
funciones.
Al igual que en el caso de las variables globales, es posible aplicar delante de
una función el modificador de almacenamiento static. Dicho modificador hace que la
función sobre la que se aplica sea local al módulo donde se encuentra, y no pueda ser
conocida por los restantes módulos del programa, de igual forma a como sucedía con
las variables globales.  Esta modificación del alcance de una función permite realizar
un mejor encapsulado del código y simplificar la programación en proyectos de gran
envergadura.