Función principal.
Todo programa C y C++ debe tener una función principal; y depende de ti dónde lo coloques. Algunos programadores lo colocan al principio del archivo, otros al final. Sin embargo, independientemente de su posición, es necesario recordar lo siguiente: Argumentos de la función "principal". El procedimiento de inicio de Borland C++ envía tres parámetros (argumentos) a la función principal: argc, argv y env. - argc, un número entero, es el número de argumentos de la línea de comando enviados a la función principal, - argv es una matriz de punteros a cadenas (char *). En DOS 3.x y posteriores, argv se define como la ruta completa del programa que se ejecutará. Cuando se ejecuta en versiones anteriores de DOS, argv apunta a una cadena nula (""). argv apunta a la primera línea de comando después del nombre del programa. argv apunta a la segunda línea de comando después del nombre del programa. argv apunta al último argumento enviado a main. argv contiene NULL. - env también es una matriz de punteros a cadenas. Cada elemento env contiene una cadena del formato ENVVAR=valor. ENVVAR es el nombre de una variable de entorno, como PATH o 87.<значение>este es el valor de una variable de entorno determinada, por ejemplo C:\DOS;C:\TOOLS (para RUTA) o YES (para 87). Sin embargo, tenga en cuenta que si especifica algunos de estos argumentos, debe especificarlos en este orden: argc, argv, env. Por ejemplo, las siguientes declaraciones de argumentos son válidas: main() main(int argc) /* válido pero no muy bueno */ main(int argc, char *argv) main(int argc, char *argv, char *env) Main (int) declaración argc) no es muy conveniente porque conociendo el número de parámetros, usted mismo no tiene acceso a ellos. Siempre se puede acceder al argumento env a través de la variable global de entorno. Consulte la variable de entorno (en el Capítulo 3) y las funciones putenv y getenv (en el Capítulo 2). Los parámetros argc y argv también están disponibles a través de las variables _argc y _argv. Programa de ejemplo usando argc, argv y env. Este es un programa de ejemplo, ARGS.EXE, que demuestra la forma más sencilla de utilizar los argumentos pasados a la función principal. /* programa ARGS.C */ #includePágina 53 de 85
1.5.3. Pasar parámetros a la función principal.
La función principal, que inicia la ejecución de un programa en C, se puede definir con parámetros que se pasan desde el entorno externo, por ejemplo, desde la línea de comando. El entorno externo tiene sus propias reglas para la representación de datos, o mejor dicho, todos los datos se presentan en forma de cadenas de caracteres. Para pasar estas cadenas a la función principal, se usan dos parámetros, el primer parámetro se usa para transmitir la cantidad de cadenas a transmitir, el segundo se usa para transmitir las cadenas mismas. Los nombres comunes (pero no obligatorios) de estos parámetros son argc y argv. El parámetro argc es de tipo int, su valor se forma a partir del análisis de la línea de comando y es igual al número de palabras en la línea de comando, incluido el nombre del programa llamado (una palabra es cualquier texto que no contenga un espacio personaje). El parámetro argv es una matriz de punteros a cadenas, cada una de las cuales contiene una palabra de la línea de comando. Si una palabra debe contener un carácter de espacio, debe estar entre comillas al escribirla en la línea de comando.
La función principal también puede tener un tercer parámetro, que suele denominarse argp, y que sirve para transferir a la función principal los parámetros del sistema operativo (entorno) en el que se ejecuta el programa en lenguaje de programación C.
El encabezado de la función principal se ve así:
Si, por ejemplo, la línea de comando de un programa en el lenguaje de programación C tiene el siguiente aspecto:
A:\>cprog trabajando "programa C" 1
luego los argumentos argc, argv, argp se representan en la memoria como se muestra en el diagrama de la Fig. 1.
argc[4]
argv --> -->
-->
-->
-->
argumento --> -->
-->
-->
-->
Figura 1. Diseño de opciones de línea de comando
El sistema operativo admite el paso de valores para los parámetros argc, argv, argp, y es responsabilidad del usuario pasar y utilizar los argumentos reales a la función principal.
El siguiente ejemplo es un programa que imprime los argumentos reales pasados a la función principal desde el sistema operativo y los parámetros del sistema operativo.
Ejemplo:
int principal (int argc, char *argv, char *argp)
(intyo=0;
printf("\nNombre del programa %s", argv);
para (i=1; i>=argc; i++)
printf("\n el argumento %d es %s", argv[i]);
printf("\nConfiguración del sistema operativo:");
mientras (*argp)
( printf ("\n %s",*argp);
argp++;
}
retorno(0);
}
También se puede acceder a los parámetros del sistema operativo utilizando la función de biblioteca geteuv; su prototipo se ve así:
char *geteuv (const char *varname);
El argumento de esta función especifica el nombre del parámetro de entorno, un puntero a cuyo valor será devuelto por la función geteuv. Si el parámetro especificado no está definido actualmente en el entorno, el valor de retorno es NULL.
Usando el puntero obtenido por la función geteuv, solo puede leer el valor del parámetro del sistema operativo, pero no puede cambiarlo. La función puteuv se utiliza para cambiar el valor de un parámetro del sistema.
El compilador del lenguaje de programación C construye un programa en C de tal manera que se realiza alguna inicialización al comienzo del programa, que incluye, entre otras cosas, procesar los argumentos pasados a la función principal y pasarle los valores de los parámetros del entorno. Estas acciones las realizan las funciones de biblioteca _setargv y _seteuv, que el compilador siempre coloca antes de la función principal.
Si un programa en el lenguaje de programación C no utiliza el paso de argumentos y valores de los parámetros del sistema operativo, entonces es aconsejable prohibir el uso de las funciones de la biblioteca _setargv y _seteuv colocándolas en el programa C en el lenguaje de programación, antes de la función principal, funciones con los mismos nombres, pero que no realizan ninguna acción (stubs). El comienzo del programa en este caso se verá así:
setargv()
}
-seteuv()
(retorno; /* función vacía */
}
int principal()
( /* función principal sin argumentos */
...
...
rendimiento(0);
}
En el programa anterior, al llamar a las funciones de la biblioteca _setargv y _seteuv, se utilizarán las funciones colocadas en el programa por el usuario y no realizarán ninguna acción. Esto reducirá significativamente el tamaño del archivo exe resultante.
Borland C++ admite tres argumentos para main(). Los dos primeros son los tradicionales argc y argv. Estos son los únicos argumentos para main() definidos por el estándar ANSI C. Permiten pasar argumentos de línea de comando al programa. Los argumentos de la línea de comando son la información que sigue al nombre del programa en la línea de comando del sistema operativo. Por ejemplo, cuando un programa se compila utilizando el compilador de línea Borland, normalmente se escribe bcc nombre_programa
Dónde nombre_programa es un programa que necesita ser compilado. El nombre del programa se pasa al compilador como argumento.
El parámetro argc contiene el número de argumentos de la línea de comando y es un número entero. Siempre es igual al menos a 1, ya que el nombre del programa califica como primer argumento. El parámetro argv es un puntero a una matriz de punteros de caracteres. Cada elemento de esta matriz apunta a un argumento de línea de comando. Todos los argumentos de la línea de comando son cadenas. Todos los números son convertidos por el programa al formato interno. El siguiente programa imprime "Hola" seguido del nombre de usuario cuando se escribe directamente después del nombre del programa:
#incluir
{
si(argc!=2)
{
printf("Olvidaste escribir tu nombre\n");
devolver 1;
}
printf("Hola %s", argv);
devolver 0;
}
Si llama a este programa por su nombre y el nombre de usuario es Sergey, para iniciar el programa debe escribir:
nombre Sergey.
Como resultado del programa aparecerá lo siguiente:
"Hola Serguéi."
Los argumentos de la línea de comando deben estar separados por espacios o tabulaciones. Las comas, el punto y coma y caracteres similares no se consideran delimitadores. Por ejemplo:
Consta de tres líneas, mientras que
Hierba, Rick, Fred
Esta es una línea; las comas no son delimitadores.
Si necesita pasar una cadena que contiene espacios o tabulaciones como argumento único, debe encerrarla entre comillas dobles. Por ejemplo, este es un argumento:
"esto es una prueba"
Es importante declarar argv correctamente. El método más típico es:
Los paréntesis vacíos indican que la matriz no tiene una longitud fija. Puedes acceder elementos individuales usando indexación argv. Por ejemplo, argv apunta a la primera línea, que siempre contiene el nombre del programa. argv apunta a la siguiente línea y así sucesivamente.
A continuación se muestra un pequeño ejemplo del uso de argumentos de línea de comando. Cuenta atrás desde el valor especificado en la línea de comando y emite una señal cuando llega a cero. Tenga en cuenta que el primer argumento contiene un número convertido a un número entero utilizando la función estándar atoi(). Si la cadena "display" está presente como segundo argumento, entonces el contador se mostrará en la pantalla.
/* programa de conteo */
#incluir
#incluir
#incluir
int principal(int argc, char *argv)
{
int disp, contar;
si(argc)<2)
{
printf("Debes ingresar la longitud del conteo\n");
printf("en la línea de comando. Inténtalo de nuevo.\n");
devolver 1;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
de lo contrario disp = 0;
para(cuenta=atoi(argv); cuenta; -cuenta)
if (disp) printf("%d ", cuenta);
printf("%c", "\a"); /* en la mayoría de las computadoras esto es una llamada */
devolver 0;
}
Tenga en cuenta que si no se especifica ningún argumento, aparece un mensaje de error. Esto es más típico en programas que utilizan argumentos de línea de comando para emitir instrucciones si se intenta ejecutar el programa sin la información correcta.
Para acceder a caracteres de línea de comando individuales, agregue un segundo índice a argv. Por ejemplo, el siguiente programa imprime todos los argumentos con los que fue llamado, un carácter a la vez:
#incluir
int principal(int argc, char *argv)
{
int t, yo;
para(t=0; t
yo = 0;
mientras(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(" ");
}
devolver 0;
}
Debemos recordar que el primer índice es para acceder a una cadena y el segundo es para acceder a un carácter de una cadena.
Normalmente, argc y argv se utilizan para obtener comandos fuente. Teóricamente es posible tener hasta 32767 argumentos, pero la mayoría de los sistemas operativos ni siquiera te permiten acercarte a eso. Normalmente, estos argumentos se utilizan para especificar un nombre de archivo u opciones. El uso de argumentos de línea de comando le da al programa un aspecto profesional y permite que se utilice en archivos por lotes.
Si incluye el archivo WILDARGS.OBJ suministrado con Borland C++, puede utilizar plantillas en argumentos de tipo *.EXE. (Borland C++ maneja automáticamente los comodines e incrementa argc en consecuencia). Por ejemplo, si conecta WILDARGS.OBJ al siguiente programa, le indicará cuántos archivos coinciden con el nombre de archivo especificado en la línea de comando:
/* Vincula este programa con WILDARGS.OBJ */
#incluir
int principal(int argc, char *argv)
{
registrarse ent i;
printf("%d archivos coinciden con el nombre especificado\n", argc-1);
printf("Ellos son: ");
para(i=1; yo
devolver 0;
}
Si llamamos a este programa WA, lo ejecutamos de la siguiente manera, obtendremos la cantidad de archivos con la extensión EXE y una lista de los nombres de estos archivos:
Además de argc y argv, Borland C++ también proporciona un tercer argumento de línea de comando: env. El parámetro env permite que un programa acceda a información sobre el entorno del sistema operativo. El parámetro env debe seguir a argc y argv y se declara de la siguiente manera:
Como puede ver, env se declara de la misma manera que argv. Al igual que argv, es un puntero a una serie de cadenas. Cada línea es una cadena de entorno definida por el sistema operativo. El parámetro env no tiene un parámetro argc equivalente que indique cuántas filas de entorno hay. En cambio, la última línea del entorno es nula. El siguiente programa imprime todas las cadenas de entorno definidas actualmente en el sistema operativo:
/* este programa muestra todas las líneas del entorno */
#incluir
int principal(int argc, char *argv, char *env)
{
int t;
para(t=0; entorno[t]/t++)
printf("%s\n", entorno[t]);
devolver 0;
}
Tenga en cuenta que, aunque el programa no utiliza argc y argv, deben estar presentes en la lista de parámetros. C no conoce los nombres de los parámetros. En cambio, su uso está determinado por el orden en que se declaran los parámetros. De hecho, puedes llamar al parámetro como quieras. Dado que argc, argv y env son nombres tradicionales, es mejor continuar usándolos para que cualquiera que lea el programa pueda comprender instantáneamente que son argumentos para la función main().
Una tarea típica de los programas es buscar un valor definido en una cadena de entorno. Por ejemplo, el contenido de la línea PATH permite a los programas utilizar rutas de búsqueda. El siguiente programa demuestra cómo encontrar cadenas que declaren rutas de búsqueda estándar. Utiliza la función de biblioteca estándar strstr(), que tiene el siguiente prototipo:
Char *strstr(const char *str1, const char *str2);
La función strstr() busca la cadena a la que apunta str1 en la cadena a la que apunta str2. Si se encuentra dicha cadena, se devuelve un puntero a la primera posición. Si no se encuentran coincidencias, la función devuelve NULL.
/* el programa busca entre las cadenas del entorno una línea que contenga PATH */
#incluir
#incluir
int principal (int argc, char *argv, char *env)
{
int t;
para(t=0; entorno[t]; t++)
{
if(strstr(env[t], "RUTA"))
printf("%s\n", entorno[t]);
}
devolver 0;
}
Cualquier programa en C comienza con una llamada a la función main(). Esta función debería estar en todos los programas.
Como cualquier otra función, la función main() puede tener parámetros. A veces, al iniciar un programa, es útil pasarle alguna información. Esta información se pasa a main() usando argumentos de línea de comando. Argumentos de línea de comando– esta es información que se ingresa en la línea de comando después del nombre del programa cuando el programa se inicia para su ejecución fuera del entorno de desarrollo del programa. Por ejemplo, para comenzar a archivar el archivo task.cpp, debe escribir lo siguiente en la línea de comando:
winrar una tarea de arcotarea.cpp // winrar.exe una tarea de arcotarea.cpp
donde winrar es el nombre del programa de archivado y las líneas " a», « archTarea" Y " tarea. cpp» representa argumentos de línea de comando que le dicen al programa que cree un archivo (" a") Con nombre archTarea de un archivo tarea. cpp.
Al pasar parámetros a la función main(), se debe definir así:
int main(int argc, char *argv) ( ) // o void main(...)()
El parámetro argc contiene el número de argumentos en la línea de comando y es un número entero, y siempre es al menos 1, porque el primer argumento es siempre el nombre del programa (el nombre del programa con la ruta completa al programa).
El parámetro argv es un puntero a una matriz de punteros a cadenas. En esta matriz, cada elemento apunta al siguiente argumento de la línea de comando. Los corchetes vacíos indican que la matriz tiene una longitud indefinida. Puede acceder a argumentos individuales indexando la matriz argv. Por ejemplo, argv apunta a la primera cadena de caracteres, que siempre es el nombre del programa; argv apunta al primer argumento y así sucesivamente. La lista de argumentos está limitada a NULL, es decir. argv == NULO.
Para acceder a un carácter individual de uno de los argumentos de la línea de comando, debe usar el segundo índice en argv. Es decir, el primer índice argv proporciona acceso a la cadena y el segundo índice proporciona acceso a sus caracteres individuales.
Todos los argumentos de la línea de comando son cadenas, por lo que la conversión de parámetros numéricos al formato deseado debe proporcionarse en el programa cuando se desarrolla.
Un ejemplo de un programa con diferentes formas de convertir números en formato simbólico a enteros y reales:
#incluir
#incluir
// al inicio configuramos, por ejemplo, los siguientes argumentos: 100 2.7
vacío principal (int a, char *b) (
k = strtol(b, &ptr, 10); // ptr = dirección del error en la línea
f = strtod(b, &ptr);
sscanf(b, "%d", &k);
sscanf(b, "%lf", &f);
Los nombres argc y argv son tradicionales, pero no obligatorios. Estos dos parámetros en la función main() se pueden llamar como quieras.
Un ejemplo sencillo del uso de argumentos de línea de comando:
int principal(int argc, char *argv) (
si (argc != 4) (
printf("¡Parámetros de inicio del programa no válidos!\n");
k = atoi(argv); // conversión del parámetro numérico
printf("Hola, %s del grupo %s de %d año",
Si el nombre del programa es tarea y su nombre es "Vasya", grupo "PM-11" del primer año, entonces para iniciar el programa debe ingresar en la línea de comando:
tarea vasya pm-11 1
Como resultado de ejecutar el programa, aparecerá el siguiente mensaje en la pantalla: "Hola, Vasya del grupo PM-11 de primer año".
Tenga en cuenta que si no se proporcionan todos los argumentos de la línea de comando, se mostrará un mensaje de error. Los programas que toman argumentos de línea de comando a menudo hacen lo siguiente: cuando el usuario ejecuta estos programas sin ingresar la información requerida, muestran instrucciones sobre cómo especificar correctamente los argumentos.
Los argumentos de la línea de comando deben estar separados por un espacio. Si hay espacios en el argumento en sí, para evitar que forme múltiples argumentos, este argumento debe estar entre comillas dobles. Como resultado, toda la cadena entrecomillada se considerará un argumento. Por ejemplo, el programa se puede iniciar así: tarea “Vasya y Petya” PM-21 2. Como resultado de ejecutar el programa, aparecerá el mensaje en la pantalla: “Hola, Vasya y Petya del segundo año PM- Grupo 21”.
¿Qué es el carácter *argv? Este una matriz cuyos elementos son punteros, eso es conjunto de punteros. Esto significa que al pasar parámetros a main(), se puede definir así:
vacío principal (int argc, char **argv) (
Tarea. Muestra todos los argumentos de la línea de comando (no es necesario mostrar el nombre del programa).
#incluir
vacío principal (int argc, char *argv)(
para (yo = 1; yo< argc; i++)
printf("%s\n", argv[i]);
Segunda opción =================
#incluir
vacío principal (int argc, char **argv)(
mientras((p=*argv) != NULL) (
printf("%s\n", p);
Normalmente, los argumentos de la línea de comando se utilizan para proporcionar al programa los datos iniciales que necesitará cuando se inicie (por ejemplo, los argumentos de la línea de comando a menudo pasan datos como el nombre del archivo o los parámetros de inicio del programa).
Cuando un programa no requiere parámetros de línea de comando, la función main() usa la palabra clave void en su lista de parámetros (o simplemente no especifica nada).
Cómo depurar en ANTES DE CRISTO. programas que requieren argumentos de línea de comando. En el menú Ejecutar→Argumentos... debe ingresar los argumentos de la línea de comando. No es necesario especificar el nombre del programa. Luego, simplemente puede ejecutar y depurar el programa en el entorno de desarrollo como de costumbre.
Suspenda AdBlock en este sitio.
Entonces, ¿por qué necesitamos funciones personalizadas? Se necesitan funciones definidas por el usuario para facilitar a los programadores la escritura de programas.
Recuerde, hablamos de paradigmas de programación, más precisamente de programación estructurada. La idea principal era que cualquier programa se puede escribir utilizando sólo tres construcciones básicas: seguimiento, condición y bucle. Ahora agregaremos una más a estas estructuras, "subrutinas", y obtendremos un nuevo paradigma. programación procesal".
La única diferencia es que escribiremos partes individuales de nuestro programa principal (en particular, las repetidas) en forma de funciones separadas (subrutinas, procedimientos) y las llamaremos según sea necesario. Básicamente, el programa describirá ahora la interacción de varias funciones.
Entonces, en este tutorial discutiremos en detalle cómo se construyen las funciones internamente. También aprenderemos a crear nuestras propias funciones personalizadas.
Cómo funcionan las funciones
Recordemos la información de la primera lección. Todas las funciones, incluidas las escritas por el usuario, están organizadas de forma similar. Tienen dos partes principales: el encabezado de la función y el cuerpo de la función.
Listado 1.
int main(void)( // encabezado de función // el cuerpo de la función está escrito entre llaves)
Con el cuerpo de la función todo está claro: describe el algoritmo de la función. Miremos el título. Consta de tres partes obligatorias:
- tipo de retorno;
- nombre de la función;
- Argumentos de función.
Primero, el tipo de retorno se escribe, por ejemplo, int , como en la función principal. Si una función no debe devolver ningún valor al programa, entonces la palabra clave void se escribe en este lugar. Parecería que como la función no devuelve nada, entonces no es necesario escribir nada. Anteriormente, por cierto, esto se hacía en lenguaje C, pero luego lo agregaron para mayor uniformidad. Hoy en día, los compiladores modernos emitirán advertencias/errores si no especifica un tipo de devolución.
En algunos lenguajes de programación, las funciones que no devuelven ningún valor se denominan procedimientos (por ejemplo, Pascal). Además, existen diferentes sintaxis para crear funciones y procedimientos. No existe tal discriminación en el lenguaje C.
El nombre de la función se escribe después del tipo de retorno. Pues bien, después del nombre se indican los tipos y número de argumentos que se pasan a la función.
Veamos los títulos de las funciones con las que ya estamos familiarizados.
Listado 2.
// una función llamada srand que toma un número entero no devuelve nada void srand(int) // una función llamada sqrt que toma un float real devuelve un float float sqrt(float) // una función llamada rand que no toma argumentos, devuelve un número entero int rand(void) //una función llamada pow que toma dos argumentos de tipo double, devuelve un número real de tipo double double pow(double, double)
Cómo crear tu propia función
Para crear su propia función, debe describirla completamente. Aquí se aplica la regla general: antes de usarlo, declara y describe cómo debería funcionar. Para hacer esto, volvamos al diagrama de la estructura del programa en lenguaje C, que teníamos en la primera lección. Marquemos en él los lugares donde se pueden describir funciones.
Fig.1 Aclaración de la estructura del programa. Declaración de funciones.
Como puede ver, hay dos lugares donde esto se puede hacer.
Veamos un ejemplo que ilustra la creación de una función personalizada para calcular el máximo de dos números.
Listado 3.
#incluir
Permítanme describir en detalle cómo funcionará este programa. Se ejecuta el cuerpo de la función principal. Se crean las variables enteras x, y y m. Las variables xey se leen desde el teclado. Digamos que ingresamos 3 5, luego x = 3, y = 5. Todo esto debería quedar claro para ti. Ahora la siguiente línea
Listado 4.
M = núm_máx(x,y);
La variable m debe asignarse a lo que está a la derecha del signo =. Allí tenemos el nombre de la función que creamos nosotros mismos. La computadora busca la declaración y descripción de esta función. Se encuentra arriba. Según esta declaración, esta función debe aceptar dos valores enteros. En nuestro caso, estos son los valores escritos en las variables x e y. Aquellos. números 3 y 5. Tenga en cuenta que no son las variables xey las que se pasan a la función, sino solo los valores (dos números) que se almacenan en ellas. Lo que realmente se pasa a una función cuando se llama en un programa se denomina parámetros reales de la función.
Ahora la función max_num comienza a ejecutarse. El primer paso es crear una variable temporal separada para cada parámetro descrito en el encabezado de la función. En nuestro caso, se crean dos variables enteras denominadas a y b. A estas variables se les asignan los valores de los parámetros reales. Los propios parámetros, descritos en el encabezado de la función, se denominan parámetros formales. Entonces, a los parámetros formales a y b se les asignan los valores de los parámetros reales 3 y 5, respectivamente. Ahora a = 3, b = 5. Más dentro de la función podemos trabajar con estas variables como si fueran variables ordinarias.
Se crea una variable entera llamada max y se le asigna el valor b. A continuación, se comprueba la condición a > b. Si es verdadero, entonces el valor de la variable max debe reemplazarse con un .
Luego viene la declaración de retorno, que devuelve al programa que llama (la función principal) el valor escrito en la variable max, es decir 5 . Después de lo cual las variables a, by max se eliminan de la memoria. Y volvemos a la línea
Listado 5.
M = núm_máx(x,y);
La función max_num devolvió el valor 5, lo que significa que ahora hay 5 escrito a la derecha del signo =. Este valor se escribe en la variable m. Luego se muestra la línea en la pantalla y el programa finaliza.
Lea atentamente los últimos 4 párrafos nuevamente para comprender completamente cómo funciona el programa.
Mientras tanto, te diré por qué es necesario el bloque inferior de descripciones de funciones. Imagine que ha escrito 20 funciones pequeñas en su programa. Y todos ellos se describen antes de la función principal. No es muy conveniente llegar al programa principal durante tanto tiempo. Para solucionar este problema, las funciones se pueden describir en un bloque inferior.
Pero no será posible simplemente transferir allí el código de función completo, porque entonces se romperá la regla: antes de usar algo, debes declararlo. Para evitar este problema, es necesario utilizar un prototipo de función.
El prototipo de función repite completamente el encabezado de la función, seguido de ; . Habiendo especificado el prototipo en el bloque superior, en el inferior ya podemos describir completamente la función. Para el ejemplo anterior, podría verse así:
Listado 6.
#incluir
Todo es muy sencillo. Tenga en cuenta que el prototipo de función no tiene que especificar los nombres de los parámetros formales; basta con indicar sus tipos. En el ejemplo anterior, hice exactamente eso.