[C con Clase] Tipos de funciones

Steven Davidson steven en conclase.net
Jue Ene 25 07:09:12 CET 2007


Hola Alejandro y Santiago,

El pasado 2007-01-24 20:08:54, Alejandro escribió:

A> Hola, somos otra vez nosotros. Ahora el problema (los problemas, mejor dicho) tiene que ver con las funciones.
A> Estas son nuestras dudas:

Veamos las dudas.

A> 1. ¿Para qué sirve el "return"? Porque en este programa:

El vocablo 'return' sirve para retornar o regresar de inmediato al punto de llamada de una función. Si una función indica un tipo de retorno, entonces del valor o expresión que sigue a 'return' es tal valor de retorno. Este valor retornado se usará, a modo de comunicación, al punto de llamada. Podemos decir que el valor retornado por la función "sustituye" a la función llamada.

A> #include<iostream>
A> using namespace std;
A> int Sumar();
A> int main()
A> {
A>     Sumar();
A>     
A>     cin.get();
A>     return 0;
A> }
A> int Sumar()
A> {
A>     int a;
A>     int b;
A>     
A>     a = 10;
A>     b = a * a;
A>     
A>     return b;
A> }
A> El resultado no es 100, sino que no es nada.

El resultado de la función sí es 100. Lo que pasa es que en 'main()' no haces nada con este valor retornado, ya que invocas a la función de esta manera:

Sumar();

Esto es tan impráctico como hacer lo siguiente:

100;

Esto es correcto, pero no hace nada aparente en el programa.

Lo que sí podrías hacer es usar 'cout <<' para imprimir el resultado en la pantalla. Por ejemplo,

cout << Sumar();

Aparecerá en pantalla: 100, que es justamente el valor retornado por 'Sumar()'.

A> 2. Continuando, ¿qué más da el tipo de retorno?

No todas las funciones tienen por qué retornar un valor. Esto ya depende del diseño de la función. Si no es necesario enviar o retornar algo, entonces la función no debería retornar nada. Esto se indica escribiendo 'void' como el tipo de retorno.

A> Porque este programa:
A> #include<iostream>
A> using namespace std;
A> int Sumar();
A> int main()
A> {
A>     Sumar();
A>     
A>     cin.get();
A>     return 0;
A> }
A> int Sumar()
A> {
A>     int a;
A>     int b;
A>     
A>     a = 10;
A>     b = a * a;
A>     cout << b;
A>     
A>     return b;
A> }
A> Es exactemente igual que este:
A> #include<iostream>
A> using namespace std;
A> void Sumar();
A> int main()
A> {
A>     Sumar();
A>     
A>     cin.get();
A>     return 0;
A> }
A> void Sumar()
A> {
A>     int a;
A>     int b;
A>     
A>     a = 10;
A>     b = a * a;
A>     cout << b;
A> }
A> Y te ahorras una línea.

Cierto, pero ¿qué ocurre si no queremos imprimir el valor en la pantalla? La respuesta es que no podríamos hacer nada al respecto. En general, es mucho más sencillo agregar funcionalidad que eliminarla. En tu caso, es más fácil agregar 'cout <<' a tu programa que eliminar esta sentencia en la función 'Sumar()'.

Imagínate que queremos invocar 'Sumar()' unas diez mil veces en un bucle. No podríamos hacerlo con tu función, ya que estaría constantemente mostrando el resultado de "100" durante el transcurso del programa. El usuario seguramente se volvería loco intentando detener este programa "malvado".

En cuanto al diseño, una función debe realizar la tarea imputada; ni más ni menos. Si tu función es diseñada para calcular la suma de dos números, entonces debería hacer eso mismo: calcular la suma. En tu caso, estarías agregando otra tarea: mostrar el resultado por pantalla. Sin embargo, esta tarea no forma parte del diseño de "sumar dos números".

A> 3. ¿Qué son los valores entre paréntesis?

Me imagino que te refieres a los paréntesis de la función. En el prototipo, los paréntesis indican la lista de parámetros con cada tipo de dato separado por comas. Esta lista de parámetros sirve para pasar información a la función, para que ésta pueda hacer la tarea implementada. Por defecto, los valores son copiados al ser pasados a la función. En la implementación de la función, se indica la lista de parámetros pero esta vez se debe escribir los nombres de cada parámetro. En la llamada o invocación de la función, indicamos los valores que queremos pasar (por copia) a cada uno de los parámetros de la función. Por ejemplo,

int resta( int min, int sus );

Aquí indicamos el prototipo de la función 1) de nombre 'resta()', 2) que retorna un valor entero de tipo 'int', y 3) con una lista de dos parámetros de tipos 'int' e 'int'.

int resta( int min, int sus )
{
  return min - sus;
}

Aquí indicamos la implementación o definición de la función 'resta()'.

Para la llamada o invocación de 'resta()', podríamos hacer algo así:

int main()
{
  cout << "5 - 3 = " << resta( 5, 3 ) << endl;

  return 0;
}

Pasamos los valores 5 y 3 como parámetros a la función 'resta()'. Como el comportamiento por defecto es pasar valores por copia, los números 5 y 3 son copiados a los parámetros 'min' y 'sus', respectivamente. Es decir, internamente hacemos algo así,

int min = 5;
int sus = 3;

int valor_de_retorno = min - sus;  // return min - sus;

Al diseñar una función, típicamente hablamos de parámetros entrantes, salientes, y ambos (entrantes y salientes). En el ejemplo anterior, 'min' y 'sus' son parámetros entrantes, ya que la función recibe los datos; o sea, "entran" en la función.


Sugiero consultar el capítulo 3 de nuestro curso de C++ para aclarar estos conceptos. Puedes ir directamente a: http://c.conclase.net/curso/index.php?cap=003  Por supuesto, si tienes dudas, siempre puedes plantearlas aquí.


Espero que todo esto te ayude.

Steven


Más información sobre la lista de distribución Cconclase