Trabajar con funciones en C ++

Los desarrolladores a menudo necesitan la capacidad de romper los programas en trozos más pequeños que son más fáciles de desarrollar. Programas "mundo real" pueden ser muchos de miles (o millones!) De las largas colas. Sin esta capacidad de dividir el programa en partes, el desarrollo de este tipo de programas grandes se convertiría rápidamente imposible.

C ++ permite a los programadores dividen su código en trozos conocido como funciones. Una función con una descripción sencilla y una interfaz bien definida con el mundo exterior se puede escribir y depurar sin preocuparse por el código que lo rodea.

La sobrecarga de nombres de funciones

C ++ permite al programador para asignar el mismo nombre a dos o más funciones. Este uso múltiple de los nombres se conoce como sobrecargar funciones o, simplemente, sobrecarga.

En general, las dos funciones en un solo programa no pueden compartir el mismo nombre. Si lo hicieran, C ++ no tendría forma de distinguirlos.

Sin embargo, el nombre de la función incluye el número y el tipo de sus argumentos. (El nombre de la función no incluye su argumento de retorno.) Por lo tanto, los siguientes no son las mismas funciones:

void algunaFuncion (void)
{
// .... Realizar alguna función
}
void algunaFuncion (int n)
{
// ... Realizar alguna función diferente
}
void algunaFuncion (double d)
{
// ... Realizar alguna función muy diferente
}
void algunaFuncion (int n1, n2 int)
{
// .... Hacer algo diferente pero
}

C ++ todavía sabe que las funciones algunaFuncion (void), algunaFuncion (int), algunaFuncion (doble), y algunaFuncion (int, int) no son lo mismo. Como tantas cosas que tienen que ver con las computadoras, esto tiene una analogía en el mundo humano.

vacío como un tipo de argumento es opcional. sumFunction (void) y sumFunction () son la misma función. Una función tiene un nombre taquigrafía, tales como algunaFuncion (). Mientras que utilizamos el nombre completo, nadie se confunde - no importa cuántas someFunctions puede haber. El nombre completo de uno de los someFunctions ()es algunaFuncion (int). Mientras este nombre completo es único, no hay confusión se produce.

Una aplicación típica puede aparecer como sigue:

int intVariable1, intVariable2- // equivalente a
// Int Variable1-
// Int Variable2-
doble doubleVariable-
// Funciones se distinguen por el tipo de
// El argumento pasado
algunaFuncion () - // llama algunaFuncion (void)
algunaFuncion (intVariable1) - // llama algunaFuncion (int)
algunaFuncion (doubleVariable) - // llama algunaFuncion (doble)
algunaFuncion (intVariable1, intVariable2) - // llamadas
// AlgunaFuncion (int, int)
// Esto funciona para las constantes, así
algunaFuncion (1) - // llama algunaFuncion (int)
algunaFuncion (1.0) - // llama algunaFuncion (doble)
algunaFuncion (1, 2) - // llama algunaFuncion (int, int)

En cada caso, el tipo de los argumentos coincide con el nombre completo de las tres funciones.

El tipo de retorno no es parte del nombre extendida (también conocido como el firma de función) De la función. Las dos funciones siguientes tienen el mismo nombre y, por lo tanto, no puede ser parte del mismo programa:

int algunaFuncion (int n) - // nombre completo de la función
// Es algunaFuncion (int)
doble algunaFuncion (int n) - // mismo nombre

El siguiente es aceptable:

int algunaFuncion (int n) -
double d = algunaFuncion (10) - // promover valor devuelto

los int devuelto por algunaFuncion () se promueve en una doble. Por lo tanto, la siguiente sería confuso:

int algunaFuncion (int n) -
doble algunaFuncion (int n) -
double d = algunaFuncion (10) - // promover int devuelto?
// O uso regresó doble como es

C ++ sabría si se debe utilizar el valor devuelto por la doble versión de algunaFuncion () o promover el valor de regresar de int versión.

Definición de prototipos de funciones

El programador puede proporcionar el resto de un C ++ archivo de origen o módulo, el nombre extendida (el nombre y funciones) durante la definición de la función.

Una función puede ser definido en cualquier lugar en el módulo. (LA módulo es otro nombre para el archivo de código fuente de C ++.) Sin embargo, algo tiene que decir main () el nombre completo de la función antes de que pueda ser llamado. Considere el siguiente fragmento de código:

int main (int argc, Char pargs * [])
{
someFunc (1, 2) -
}
int someFunc (doble arg1, arg2 int)
{
// ...hacer algo
}

La llamada a someFunc () desde dentro main () no sabe el nombre completo de la función. Se puede conjeturar a partir de los argumentos que el nombre es someFunc (int, int) y que su tipo de retorno es que invalidaría sin embargo, como se puede ver, esto es incorrecto.

C ++ podría ser menos perezosos y mirar hacia adelante para determinar el nombre completo de someFunc ()s por su cuenta, pero no es así. Lo que se necesita es alguna manera de informar main () del nombre completo de someFunc () antes de su uso. Lo que se necesita es una declaración de la función antes de su uso. Algún tipo de prototipo es necesario.

LA declaración prototipo aparece el mismo como una función sin cuerpo. En uso, una declaración prototipo aparece como sigue:

int someFunc (doble, int) -
int main (int argc, Char pargs * [])
{
someFunc (1, 2) -
}
int someFunc (doble arg1, arg2 int)
{
// ...hacer algo
}

La declaración prototipo le dice al mundo (al menos esa parte del mundo después de la declaración), que el nombre extendido para someFunc () es algunaFuncion (doble, int). La llamada en main () ahora sabe a emitir el 1 a una doble antes de hacer la llamada. En adición, main () sabe que el valor devuelto por someFunc () es un int.

Una llamada a una función que devuelve un valor es una expresión. Al igual que con cualquier otra expresión ofrecer, se le permite lanzar el valor devuelto por una función.

Tipos de almacenamiento de variables

Las variables de función se almacenan en tres lugares diferentes. Las variables declaradas dentro de una función se dice que son locales. En el siguiente ejemplo, la variable localVariable es local a la función fn ():

int globalVariable-
fn void ()
{
int localVariable-
static int staticVariable-
}

La variable localVariable no existe hasta que la función fn () se llama. localVariable deja de existir cuando la función devuelve. A su regreso, cualquiera que sea el valor que se almacena en localVariable esta perdido. Además, sólo fn () tiene acceso a localVariable - otras funciones no pueden llegar a la función para acceder a ella.

En comparación, la variable GLOBALVariable existe siempre y cuando el programa se está ejecutando. Todas las funciones tienen acceso a GLOBALVariable todo el tiempo.

La variable estática staticVariable es una especie de mezcla entre un local y una variable global. La variable staticVariable se crea cuando la ejecución llega primero la declaración (más o menos, cuando la función fn () se llama). En adición, staticVariable sólo es accesible dentro de fn (). diferente a localVariable, sin embargo, staticVariable continúa existiendo incluso después de que el programa regresa de fn (). Si fn () asigna un valor a staticVariable una vez, todavía estará allí la próxima vez que fn () se llama.

En caso de que alguien le pregunta, hay un cuarto tipo, auto, pero hoy en día tiene el mismo significado que locales, así que ignorarlos.