FUNCIONES

Permiten modular los programas, en otras palabras permite dividir un programa en secciones más pequeñas (módulos) que realizan una tarea específica. Son equivalentes a las funciones (function) del Pascal.

Sintaxis:

[Tipo de retorno] Nombre ([Declaración de Parámetros])
{    instrucción;
     ...
     ...
     [return expr;]
}

De omitirse el tipo de retorno, la función deberá devolver un valor de tipo int . La cláusula return expr; permite devolver el resultado de la función al módulo que la invocó, expr es una expresión aritmética cuyo resultado será valor devuelto.

Consideraciones:

1. En C, los parámetros de la función pasan exclusivamente por valor, en C++ los parámetros pasan por valor o por referencia. Un parámetro por referencia se indica colocando el símbolo & entre el tipo de dato y el parámetro.

2. Toda función debe retornar un valor por medio de la instrucción "return", a menos que el tipo de retorno haya sido definido como void.

3. Las funciones pueden ser colocadas en cualquier orden dentro del programa, pero si se van a invocar antes de su declaración, se deberá colocar el "prototipo" de la función al inicio del programa. El "prototipo no es más que el encabezado de la función, el cual termina con un ";".

Ejemplo:

Donde X₀ es una primera aproximación de la raíz. Con X₀ se calcula X_n; si X_n da como resultado un valor diferente de X₀, se reemplaza X₀ por X_n en la expresión y el proceso se repite hasta que X₀ sea igual a X_n.

#include <stdio.h>

const float LIMITE = 0.001;
const int   FIN = 0;

//Prototipos:

  float raiz_n (int, float);
  float potencia (float, int);
  float abs (float);
  int LeeNum (int &);  //Parámetro por referencia

void main (void)
{ float s = 0.0, a;
  int coef, raiz;
  printf("Ingrese el valor de \"a\": ");
  scanf("%f",&a);
  printf("Ingrese los coeficientes y potencias por parejas \n (cero para terminar)");
  while ( LeeNum (coef))
  { LeeNum(raiz);
    s += coef*raiz_n (raiz,a);
  }
  printf("s= %10.3f\n", s);
}

int LeeNum(int   &coef)
{ scanf("%d", &coef);
  return coef;
}

float raiz_n (int n, float Q)
{ float Xo = 0.0, Xn = 1.0;
  while (abs (Xo - Xn) > LIMITE)
  { Xo = Xn;
    Xn = ((n-1)*Xo+Q/potencia(Xo,n-1))/n;
  }
  return Xo;
}

float abs (float X)
{ return X>0? X:-X;
}

float potencia (float X, int n)
{ float r = 1;
  while (n--) r *= X;
  return r;
}

Ámbito y Alcance de la Declaración de Variables

Variables globales

Se definen fuera de cualquier bloque de instrucciones. Estas variables pueden ser utilizadas a partir de su dfinición en cualquier parte del programa.

Por ejemplo:

#include <stdio.h>

int a; 		//variable global

void main (void)
{ int p = 3 ; 	//variable local o automática
  a = p;
  printf("%5d %5d\n", a, p);
}

También se puede definir en forma explíta dentro de un bloque de instrucciones, como se muestra a continuación:

int a; 	//variable global

void main (void)
{ int p = 3;
  extern int a;	//declaración explícita
  a = p;
  printf("%5d %5d\n", a, p);
}

El ámbito de las variables globales se puede apreciar a continuación:

Variables Automáticas y Estáticas

Las variables automáticas son aquellas variables que se definen dentro de un bloque de instrucciones { ... }, su nombre viene debido a que se crean cuando se declara la variable y se destruyen cuando se sale del bloque.

Las variables automáticas se pueden ser definidas en cualquier parte del programa.

Así:

void main (void)
{ int a, b = 7;	//variables automáticas, sólo se pueden usar dentro de la función main.
  a=b-7;
  float p; 	//variable automática, no se puede hacer en C pero si en C++.
  ...
  }

 void f(void)
 { inx x;	//variable automática, sólo se pueden usar dentro de la función f.
   x = a;	//ERROR: no puede usas la variable a dentro de la función f.
   ...
 }

Se puede hacer también lo siguiente:

void main (void)
{ int a, b = 7;
  while (b3)
  { int f = 5; 	//variable local al bloque;
    a += f;
    printf("a= %d\n",a);
    b--;
  }
  b = f;	//ERROR: no puefe usar la variable f aquí
}

Finalmente:

// Archivo Main3.cpp
// Utiliza las funciones f1 y f2, obsérvese que el programa yo no presenta
// errores de compilación.
#include 
#include "Lib2.CPP"
#include "Lib3.CPP"
void main (void)
{ f1 ( );
  printf("%5d %5d %5d\n", a, b, c);
  f2 ( );
  printf("%5d %5d %5d\n", a, b, c);
}

Macros

La cláusula #define permite definir, como se indicó anteriormente, constantes simbólicas; sin embargo, también permite la definición de lo que se denominan "macros".

Una macro es también un texto de reemplazo, sin embargo, a diferencia de las constantes simbólicas el reemplazo se hace en forma más inteligente, dando la impresión que se estuvieran pasando parámetros.

Así por ejemplo se puede escribir:

#define SUMA(x,y)    x+y
#define PRODUCTO(x,y)    x*y

Luego en un programa se puedrá escribir:

cont = SUMA (cont, 1);
actual = PRODUCTO (2, actual);
total = SUMA (total, actual);

Estas instrucciones serán reeplazadas por el preprocesador por las siguientes líneas:

cont = cont + 1;
actual = 2 * actual;
total = total + actual;

Se debe tener mucho cuidado cuando se quiere implementar una macro, muchas veces se confunde una macro con una funcíón sin tener en cuenta que no lo es y que sólo se trata de un reemplazo de texto. Un ejemplo de esto se muestra a continuación:

#define  CUADRADO(x)   x*x

Si se escribe en un programa una expresión sencilla como la que se muestra a continuación:

printf("%d\n", CUADRADO(4));         obviamente se obtiene 16

Pero si se escribiera lo siguiente:

printf("%d\n", CUADRADO(3+5));        se obtiene 23 !!!!!, y si se escribe:
printf("%d\n" 5.0 / CUADRADO(8) );         da como resultado 5 !!!!!

Esto se debe a que, como hemos dicho anteriormente, cuando el preprocesador reemplaza el texto lo hace literalmente, así:

CUADRADO(3+5)    se reemplaza por 3+5*3+5        y esto da coo resultado 23,

Por la misma razón:

5.0/CUADRADO(8)    se reemplaza por 5.0/8*8        que resulta 5.0

Para solucionar el primer caso se deberá agregar en la definició de la macro paréntesis, de la siguiente forma:

#define   CUADRADO(x)    (x)*(x)

al ejecutarlo se tiene:

CUADRADO(3+5)    se reemplaza por (3+5)*(3+5)    dando como resultado: 64

sin embargo para la segunda expresión:

5.0 / CUADRADO(8)    se reemplaza por 5.0 / (8)*(8)    dando como resultado: 5, que es un resultado incorrecto.

Para solucionar esto se deberá agregar un nuevo juego de paréntesis en la definició de la macro, de la siguiente forma:

#define   CUADRADO(x)    ((x)*(x))

con lo que se tendría:

5.0 / CUADRADO(8)    se reemplaza por 5.0 / ((8)*(8))    dando como resultado: 0.078125, resultado correcto.

Funciones en Línea

Lo complicado de la definición de las macros en C y los problemas que se presentan al implementar un programa con macros, ha hecho que en C++ se implementen otro tipo de herramienta, más eficiente y simple. Esta herramienta se denomina "Función en Línea".

Una función en línea, a diferencia de las macros, sí es compilada, es decir se transforma en un código objeto (lenguaje máquina). Sin embargo, la ubicación de este código no se realiza en forma similar al de una función común. El código generado se inserta, en el programa objeto, en cada llamado a la función en línea.

Sintaxis:

inline   Tipo de Retorno   Nombre de la Función   ([Declaración de Parámetros])
{ instrucción;
...
...
[return n;]
}

Ejemplo:

inline int abs (int x) { return x0?x:-x; }
inline float cuadrado (int x) { return x*x; }
inline float potencia (float*, int n)
{    float r=1;
     while (n--) r * x;
     return r;
}

La compilación de las funciones en línea se realizán de un modo peculiar, es el compilador y no el usuario quien decide que una función en línea se compile como tal o como una función común y corriente. El compilador descartará la posibilidad de compilarla como función en línea si encuentra que:

Proyectos

Como se mencionó anterioermente, emplear la cláusula #include para incluir archivos que contengan código no es una manera óptima de modular un programa. Esto se debe a que en el momento de compilar el programa, todos los archivos que se encuentren en las cláusulas de inclusión se agregan al texto del programa para luego compilarse por completo todos. Si se quisiera hacer una modificación en uno de los archivos, al momento de compilar el programa, todos los archivos serán traducidos nuevamente, haciendo la tarea de compilación muy engorrosa y lenta.

Por otro lado, como la cláusula #include incluye un archivo en el texto de un programa, este archivo debe ser escrito empleando la sintaxis de C/C++, si se tuviera una función escrita en otro lenguaje de programación, ésta no podría agregarse al programa mediante la cláusula #include.

Un proyecto es la reunón de un grupo de archivos que generarán un único archivo ejecutable. Cada archivo debe ser compilado independientemente de modo que se cree un archivo en lenguaje máquina por cada, uno denominado archivo objeto ( archivo con extensión .obj). Luego se reunen todos estos archivos mediante un programa denominado "linker" (enlazador), quien crea finalmente el archivo ejecutable ( archivo con extensión .exe).

Como cada archivo es compilado independientemente y luego se enlazan, si se tuviera que hacer una modicficación a uno de los archivos, sólo se tendría que compilar nuevamente ese archivo, los demás no. Esto mejora notablemente la eficiencia del proceso de compilación. Por la misma razón, al compilarse independientemente cada archivo, en teoría cada archivo podría estar escrito en un lenguaje de programación distinto.

Para elaborar un proyecto, se debe remitir al ambiente integrado de desarrollo (IDE) que se esté utilizando en ese momento, cada IDE tiene un modo particular de elaboar los proyectos.

Por ejemplo en el Borland C++ versión 3.1, la elaboración de un proyecto se realiza mediante la opción:

Project

La opción Open project permite abrir un proyecto ya existente o crear uno nuevo. La ventana que aparece es similar a la que permite abrir o guardar un archivo cualquiera.

Luego de abierto, a un proyecto se le pueden agregar los archivos que desean enlazar en conjunto mediante la opción Add Item.

Los archivos pueden estar precompilados (con extensión obj).

Luego para compilar un proyecto hay que elegir:

compile Build All.

Bibliotecas de funciones

Una biblioteca de funciones (LIBRARY) es la agrupación de un conjunto de funciones en un archivo. Teóricacmente, un módulo creado para la elaboración de un proyecto que contiene un conjunto de funciones es un biblioteca de funciones, sin embargo el concepto de biblioteca de funciones está ligado a los archivos con extensión .LIB.

Un archivo .LIB es muy parecido a un archivo .OBJ, sin embargo diferencia de los archivos .OBJ, cuando un archivo .LIB es colocado dentro de un proyecto, al momento del enlace, sólo se añade al programa ejecutable aquellas funciones que se encuentren en la biblioteca y que efectivamente se están empleando en los demás módulos. Un archivo .OBJ se añade completamente al programa ejecutable, así sólo se emplee una función de las cientos de funciones que pueda contener el archivo.

La eleboración de una bibloteca de funciones también depende del IDE que se estÉ utilizando. En el Borland C++ versión 3.1, la elaboración de un archivo .LIB se realiza, apartir de un archivo .OBJ, mendiante el programa tlib.