Argumentos para la función MAIN(). Cómo funciona el método main() en C

¿Para qué sirven las funciones en C?

Las funciones en C se utilizan para realizar acciones específicas dentro del marco de un programa general. El propio programador decide qué acciones mostrar en las funciones. Es especialmente conveniente utilizar funciones para acciones repetitivas.

Un ejemplo simple de una función en C

Ejemplo de una función en C:

#incluir #incluir int main(void) ( puts("Funciones en C"); return EXIT_SUCCESS; )

Este es un programa en C muy simple. Simplemente imprime la línea "Funciones en C". El programa tiene una única función llamada principal. Veamos esta función en detalle. En el encabezado de la función, es decir en linea

int es el tipo de retorno de la función;

principal es el nombre de la función;

(void) es una lista de argumentos de función. La palabra nula indica que la función no tiene argumentos;

return es una declaración que finaliza la ejecución de una función y devuelve el resultado de la función al punto en el que se llamó a la función;

EXIT_SUCCESS es un valor igual a cero. Está definido en el archivo stdlib.h;

parte de la función después del encabezado, encerrada entre llaves

{
pone("Funciones en C");
devolver EXIT_SUCCESS;
}

llamado cuerpo de la función.

Entonces, cuando trabajamos con una función, debemos indicar el nombre de la función, para nosotros es principal, el tipo de valor devuelto por la función, para nosotros es int, dar una lista de argumentos entre paréntesis después del nombre de la función, no tenemos argumentos, por lo que escribimos void, ejecutamos en el cuerpo de la función algunas acciones (para las cuales se creó la función) y devolvemos el resultado de la función usando la declaración return. Estos son los conceptos básicos que necesita saber sobre las funciones en C.

¿Cómo llamar a otra función desde una función en C?

Veamos un ejemplo de llamada a funciones en C:

/* Autor: @author Subbotin B.P..h> #include int main(void) ( puts("Funciones en C"); int d = 1; int e = 2; int f = suma(d, e); printf("1 + 2 = %d", f); return SALIDA_ÉXITO;

Lo ejecutamos y obtenemos:

Este ejemplo crea una función de suma que suma dos números enteros y devuelve el resultado. Veamos la estructura de esta función en detalle.

encabezado de función de suma:

int suma(int a, int b)

aquí int es el tipo de retorno de la función;

suma es el nombre de la función;

(int a, int b): entre paréntesis después del nombre de la función hay una lista de sus argumentos: el primer argumento es int a, el segundo argumento es int b. Los nombres de los argumentos son formales, es decir. Al llamar a una función, no estamos obligados a enviar los valores de las variables denominadas ayb como argumentos a esta función. En la función principal llamamos a la función suma así: suma(d, e);. Pero es importante que los argumentos pasados ​​a la función coincidan con el tipo declarado en la función.

En el cuerpo de la función de suma, es decir Dentro de las llaves después del encabezado de la función, creamos una variable local int c, le asignamos el valor de la suma de a más b y la devolvemos como resultado de la función con la declaración de retorno.

Ahora veamos cómo se llama a la función suma desde la función principal.

Aquí está la función principal:

Int main(void) ( puts("Funciones en C"); int d = 1; int e = 2; int f = suma(d, e); printf("1 + 2 = %d", f); return SALIDA_ÉXITO)

Primero creamos dos variables int.

Int d = 1;

int mi = 2;

Los pasaremos a la función de suma como valores de argumento.

int f = suma(d, e);

int suma(int a, int b)

su valor será el resultado de la función suma, es decir Llamamos a la función suma, que devolverá un valor int, que asignamos a la variable f. Pasamos d y f como argumentos. Pero en la suma del encabezado de la función

los argumentos se llaman a y b, ¿por qué entonces pasamos d y f? Porque los argumentos formales están escritos en el encabezado de la función, es decir Los nombres de los argumentos NO son importantes, pero sus tipos sí lo son. La función suma tiene ambos argumentos de tipo int, lo que significa que al llamar a esta función, debes pasar dos argumentos de tipo int con cualquier nombre.

Una sutileza más. Se debe declarar una función antes de llamarla por primera vez. En nuestro ejemplo, este fue el caso: primero se declara la función suma y solo después la llamamos desde la función principal. Si una función se declara después del lugar donde se llama, entonces se debe utilizar un prototipo de función.

Prototipo de función en C

/* Autor: @author Subbotin B.P..h> #include Veamos un ejemplo de una función en C:

int suma(int a, int b);

int main(void) ( puts("Funciones en C"); int d = 1; int e = 2; int f = suma(d, e); printf("1 + 2 = %d", f); return EXIT_SUCCESS; ) int suma(int a, int b) ( int c = 0; c = a + b; devuelve c; )

En este ejemplo, la función de suma se define a continuación, donde se llama en la función principal. En este caso, es necesario utilizar el prototipo de función de suma. Nuestro prototipo está declarado encima de la función principal:

Los pasaremos a la función de suma como valores de argumento.

y debajo de la función principal definimos la función suma, que fue previamente declarada en el prototipo:

Int suma(int a, int b) ( int c = 0; c = a + b; devuelve c; )

¿En qué se diferencia una declaración de función en C de una definición de función en C?

Cuando escribimos un prototipo de función, por ejemplo así:

int main(void) ( puts("Funciones en C"); int d = 1; int e = 2; int f = suma(d, e); printf("1 + 2 = %d", f); return EXIT_SUCCESS; ) int suma(int a, int b) ( int c = 0; c = a + b; devuelve c; )

luego declaramos una función.

Y cuando implementamos una función, es decir Anotamos no solo el título, sino también el cuerpo de la función, por ejemplo:

Int suma(int a, int b) ( int c = 0; c = a + b; devuelve c; )

luego definimos una función.

declaración de devolución

La declaración de retorno finaliza una función en C y devuelve el resultado de su operación al punto de llamada. Ejemplo:

Int suma(int a, int b) ( int c = 0; c = a + b; devuelve c; )

Esta función se puede simplificar:

Int suma(int a, int b) ( devuelve a + b; )

aquí la declaración de devolución devolverá el valor de la suma a + b.

Puede haber varias declaraciones de devolución en una función. Ejemplo:

int suma(int a, int b) ( if(a > 2) ( return 0;// Primer caso; ) if(b< 0) { return 0;// Второй случай; } return a + b; }

Si en el ejemplo el valor del argumento a es mayor que dos, entonces la función devolverá cero (el primer caso) y todo lo que esté debajo del comentario “// Primer caso;” no será ejecutado. Si a es menor que dos, pero b es menor que cero, entonces la función completará su trabajo y todo lo que esté debajo del comentario "// Segundo caso;" no será ejecutado.

Y solo si no se cumplen las dos condiciones anteriores, la ejecución del programa llegará a la última declaración de devolución y se devolverá la suma a + b.

Pasar argumentos de función por valor

Los argumentos se pueden pasar a una función C por valor. Ejemplo:

/* Autor: @author Subbotin B.P..h> #include int suma(int a) ( return a += 5; ) int main(void) ( puts("Funciones en C"); int d = 10; printf("suma = %d\n", suma(d)) ; printf("d = %d", d); devuelve EXIT_SUCCESS;

En el ejemplo, en la función principal, creamos una variable int d = 10. Pasamos esta variable por valor a la función sum(d). Dentro de la función de suma, el valor de la variable aumenta en 5. Pero en la función principal, el valor de d no cambiará porque se pasó por valor. Esto significa que se pasó el valor de la variable, no la variable en sí. Esto se evidencia en el resultado del programa:

aquellos. después de regresar de la función de suma, el valor de d no cambió, mientras que dentro de la función de suma sí cambió.

Pasar punteros de función C

Si pasa un puntero a esta variable como argumento de una función en lugar del valor de una variable, entonces el valor de esta variable puede cambiar. Por ejemplo, tomamos el programa del apartado anterior, cambiándolo ligeramente:

/* Autor: @author Subbotin B.P..h> #include int suma(int *a) ( return *a += 5; ) int main(void) ( puts("Funciones en C"); int d = 10; printf("suma = %d\n", suma(&d )); printf("d = %d", d); devuelve EXIT_SUCCESS;

En esta versión del programa, pasé de pasar un argumento por valor a pasar un puntero a una variable. Echemos un vistazo más de cerca a este punto.

printf("suma = %d\n", suma(&d));

Lo que se pasa a la función suma no es el valor de la variable d, igual a 10, sino la dirección de esta variable, así:

Ahora veamos la función de suma:

Int suma(int *a) ( return *a += 5; )

Su argumento es un puntero a int. Sabemos que un puntero es una variable cuyo valor es la dirección de algún objeto. La dirección de la variable d se envía a la función de suma:

Dentro de la suma, se desreferencia el puntero int *a. Esto nos permite pasar del puntero a la variable misma, a la que apunta nuestro puntero. Y en nuestro caso esta es la variable d, es decir expresión

es equivalente a la expresión

Resultado: la función suma cambia el valor de la variable d:

Esta vez el valor de d cambia después de regresar de la suma, lo cual no se observó en el párrafo anterior cuando pasamos el argumento por valor.

C/C++ en Eclipse

Hice todos los ejemplos para este artículo en Eclipse. Puedes ver cómo trabajar con C/C++ en Eclipse. Si trabaja en un entorno diferente, los ejemplos también funcionarán allí.

Etiquetas: Funciones en C, prototipo, descripción, definición, llamada. Parámetros formales y parámetros reales. Argumentos de función, pasando por valor, pasando por puntero. Valor de retorno.

Introducción

Cuanto más estudiamos C, más grandes se vuelven los programas. Recopilamos todas las acciones en una función principal y copiamos las mismas acciones varias veces, creando docenas de variables con nombres únicos. Nuestros programas crecen y se vuelven cada vez menos comprensibles, las ramas son cada vez más largas y ramificadas.

¡Pero hay una salida a esta situación! Ahora aprenderemos cómo crear funciones en C. Las funciones, en primer lugar, ayudarán a separar el código duplicado en subprogramas separados, en segundo lugar, ayudarán a dividir lógicamente el programa en partes y, en tercer lugar, las funciones en C tienen muchas características asociadas que permitirán el uso de nuevos enfoques para estructurar aplicaciones.

Una función es una parte con nombre de un programa que se puede llamar repetidamente desde otra parte del programa (en la que la función es visible). Una función puede tomar un número fijo o variable de argumentos, o puede no tener argumentos. Una función puede devolver un valor o estar vacía y no devolver nada.

Ya conocemos muchas funciones y sabemos cómo llamarlas: son funciones de las bibliotecas stdio, stdlib, string, conio, etc. Además, main también es una función. Se diferencia de los demás sólo en que es el punto de entrada al iniciar la aplicación.
Una función en C se define en un contexto global. Sintaxis de la función: (, ...) ( )

El ejemplo más simple es una función que toma un número flotante y devuelve el cuadrado de este número.

#incluir #incluir float sqr(float x) ( float tmp = x*x; return tmp; ) void main() ( printf("%.3f", sqr(9.3f)); getch(); )

Dentro de la función sqr, creamos una variable local a la que se le asignó el valor del argumento. El número 9.3 se pasó como argumento a la función. La palabra de servicio return devuelve el valor de la variable tmp. Puedes reescribir la función de la siguiente manera:

Flotador sqr(flotante x) ( return x*x; )

En este caso, primero se realizará la multiplicación y luego se devolverá el valor. Si la función no devuelve nada, el tipo de devolución será nulo. Por ejemplo, una función que imprime el cuadrado de un número:

void printSqr(float x) ( printf("%d", x*x); retorno; )

en este caso, regresar significa salir de la función. Si la función no devuelve nada, entonces no es necesario escribir return. Luego, la función completará su finalización y el control volverá a la función que llama.

Vacío printSqr(float x) ( printf("%d", x*x); )

Si la función no acepta argumentos, los paréntesis se dejan vacíos. También puedes escribir la palabra nulo:

void printHolaMundo() ( printf("Hola Mundo"); )

equivalente

void imprimirHolaMundo(void) ( printf("Hola Mundo"); )

Parámetros formales y reales.

Al declarar una función, se especifican parámetros formales, que luego se utilizan dentro de la propia función. Cuando llamamos a una función, usamos los parámetros reales. Los parámetros reales pueden ser variables de cualquier tipo adecuado o constantes.

Por ejemplo, digamos que hay una función que devuelve el cuadrado de un número y una función que suma dos números.

#incluir #incluir //Los parámetros formales tienen nombres a y b //usándolos accedemos a los argumentos pasados ​​dentro de la función int sum(int a, int b) ( return a+b; ) float square(float x) ( return x*x; ) void main() ( // Los parámetros reales pueden tener cualquier nombre, incluido ningún nombre int one = 1; float two = 2.0; //Pasar variables, la segunda variable se convierte al tipo deseado printf("%d\n" , sum(one, two)); //Pasando constantes numéricas printf("%d\n", sum(10, 20)); //Pasando constantes numéricas del tipo incorrecto, se convierten automáticamente al deseado printf ("%d\n ", sum(10, 20.f)); //Una variable de tipo entero se convierte en una variable de punto flotante printf("%.3f\n", square(one)); También se puede utilizar una llamada a una función como argumento, que devuelve el valor deseado printf("%.3f\n", square(sum(2 + 4, 3)));

Tenga en cuenta que la conversión de tipos se produce implícitamente y sólo cuando es posible. Si una función recibe un número como argumento, entonces no se le puede pasar una cadena variable, por ejemplo "20", etc. En general, es mejor utilizar siempre el tipo correcto o convertir explícitamente el tipo al deseado.
Si una función devuelve un valor, no es necesario almacenarlo. Por ejemplo, usamos la función getch, que lee un carácter y lo devuelve.

#incluir #incluir void main() ( char c; do ( //Guarda el valor de retorno en una variable c = getch(); printf("%c", c); ) while(c != "q"); //El retorno el valor no se guarda getch();

Pasar argumentos

Al pasar argumentos, se copian. Esto significa que cualquier cambio que una función realice en las variables se produce sólo dentro de la función. Por ejemplo

#incluir #incluir cambio vacío(int a) ( a = 100; printf("%d\n", a); ) void main() ( int d = 200; printf("%d\n", d); cambio(d) ; imprimirf("%d", d);

Los programas se mostrarán
200
100
200
Está claro por qué. Dentro de la función trabajamos con la variable x, que es una copia de la variable d. Cambiamos la copia local, pero la variable d en sí no cambia. Después de que salga la función, la variable local será destruida. La variable d no cambiará de ninguna manera.
¿Cómo entonces puedes cambiar la variable? Para hacer esto, debe pasar la dirección de esta variable. Reescribamos la función para que acepte un puntero de tipo int

#incluir #incluir cambio vacío (int *a) ( *a = 100; printf("%d\n", *a); ) void main() ( int d = 200; printf("%d\n", d); cambio (&d); imprimirf("%d", d);

Ahora el programa genera
200
100
100
Aquí también se creó una variable local, pero como se pasó la dirección, cambiamos el valor de la variable d usando su dirección en la RAM.

En programación, el primer método de pasar parámetros se llama pasar por valor, el segundo, pasar por puntero. Recuerda una regla simple: si quieres cambiar una variable, debes pasar un puntero a esa variable a la función. Por lo tanto, para cambiar un puntero, debe pasar un puntero a un puntero, etc. Por ejemplo, escribamos una función que tome el tamaño de una matriz int y la cree. A primera vista, la función debería verse así:

#incluir #incluir #incluir void init(int *a, tamaño sin signo) ( a = (int*) malloc(size * sizeof(int)); ) void main() ( int *a = NULL; init(a, 100); if (a = = NULL) ( printf("ERROR"); ) else ( printf("OK..."); free(a); ) getch();

Pero esta función generará ERROR. Pasamos la dirección de la variable. Dentro de la función init se creó una variable local a que almacena la dirección del array. Después de que salió la función, esta variable local fue destruida. Además del hecho de que no pudimos lograr el resultado deseado, descubrimos una pérdida de memoria: se asignó memoria en el montón, pero ya no hay una variable que almacene la dirección de esta área.

Para cambiar un objeto, debe pasarle un puntero, en este caso un puntero a un puntero.

#incluir #incluir #incluir void init(int **a, tamaño sin firmar) ( *a = (int*) malloc(size * sizeof(int)); ) void main() ( int *a = NULL; init(&a, 100); if ( a == NULL) ( printf("ERROR"); ) else ( printf("OK..."); free(a); ) getch();

Ahora todo funciona como debería.
Otro ejemplo parecido. Escribamos una función que tome una cadena como argumento y devuelva un puntero al área de memoria en la que se copió esta cadena.

#incluir #incluir #incluir #incluir char* initByString(const char *str) ( char *p = (char*) malloc(strlen(str) + 1); strcpy(p, str); return p; ) void main() ( char *test = initByString( "¡Hola mundo!"); printf("%s", prueba gratis(prueba);

No hay pérdida de memoria en este ejemplo. Asignamos memoria usando la función malloc, copiamos una cadena allí y luego devolvimos un puntero. Las variables locales se han eliminado, pero la variable de prueba almacena la dirección de una parte de la memoria en el montón, por lo que se puede eliminar utilizando la función gratuita.

Declaración de función y definición de función. Creando tu propia biblioteca

En C, puedes declarar una función antes de definirla. Una declaración de función, su prototipo, consta de un valor de retorno, un nombre de función y el tipo de argumentos. Los nombres de los argumentos se pueden omitir. Por ejemplo

#incluir #incluir //Prototipos de funciones. No es necesario escribir los nombres de los argumentos int odd(int); int par(int); void main() ( printf("si %d impar? %d\n", 11, impar(11)); printf("si %d impar? %d\n", 10, impar(10)); getch () //Definición de funciones int par(int a) ( if (a) ( impar(--a); ) else ( return 1; ) ) int impar(int a) ( if (a) ( par( - -a); más (retorna 0; ) )

Esta es una recursión mixta: la función impar devuelve 1 si el número es impar y 0 si es par.

Por lo general, la declaración de función se coloca por separado, en el archivo .h, y las definiciones de función en el archivo .c. Por lo tanto, el archivo de encabezado representa la interfaz de la biblioteca y muestra cómo trabajar con ella sin entrar en el contenido del código.

Creemos una biblioteca simple. Para hacer esto, necesitará crear dos archivos: uno con la extensión .h y colocar allí los prototipos de funciones, y el otro con la extensión .c y colocar allí las definiciones de estas funciones. Si está trabajando con un IDE, entonces el archivo .h debe crearse en la carpeta Archivos de encabezado y los archivos de código en la carpeta Archivos de código fuente. Deje que los archivos se llamen Archivo1.h y Archivo1.c
Reescribamos el código anterior. Así es como se verá el archivo de encabezado File1.h

#ifndef _FILE1_H_ #define _FILE1_H_ int impar(int); int par(int); #endif

Contenido del archivo de código fuente File1.c

#incluye "Archivo1.h" int par(int a) ( if (a) ( impar(--a); ) else ( return 1; ) ) int impar(int a) ( if (a) ( par(-- a); más (devuelve 0;))

Nuestra función principal

#incluir #incluir #include "Archivo1.h" void main() ( printf("si %d impar? %d\n", 11, impar(11)); printf("si %d impar? %d\n", 10, impar(10));

Veamos las características de cada archivo. Nuestro archivo, que contiene la función principal, incluye las bibliotecas que necesita, así como el archivo de encabezado File1.h. El compilador ahora conoce los prototipos de funciones, es decir, conoce el tipo de retorno, el número y tipo de argumentos y los nombres de las funciones.

El archivo de encabezado, como se indicó anteriormente, contiene el prototipo de función. Las bibliotecas utilizadas también se pueden incluir aquí. Protección de macros #define _FILE1_H_ etc. Se utiliza para evitar que el código de la biblioteca se vuelva a copiar durante la compilación. Estas líneas se pueden reemplazar con una

#pragma una vez int impar(int); int par(int);

El archivo de código fuente File1.c incluye su archivo de encabezado. Todo es lógico y sencillo como siempre. En los archivos de encabezado, además de los prototipos de funciones, es común incluir constantes, sustituciones de macros y definir nuevos tipos de datos. Además, es en los archivos de encabezado donde puedes comentar ampliamente el código y escribir ejemplos de su uso.

Pasar una matriz como argumento

Como se mencionó anteriormente, el nombre de la matriz se reemplaza por un puntero, por lo que pasar una matriz unidimensional equivale a pasar un puntero. Ejemplo: la función recibe un array y su tamaño e imprime:

#incluir #incluir void printArray(int *arr, tamaño sin firmar) ( sin firmar i; for (i = 0; i< size; i++) { printf("%d ", arr[i]); } } void main() { int x = {1, 2, 3, 4, 5}; printArray(x, 10); getch(); }

En este ejemplo, la función podría verse así

void printArray(int arr, tamaño sin firmar) ( unsigned i; for (i = 0; i< size; i++) { printf("%d ", arr[i]); } }

Permítanme recordarles también que la regla para reemplazar una matriz con un puntero no es recursiva. Esto significa que es necesario especificar la dimensión de la matriz bidimensional al transmitir

#incluir #incluir void printArray(int arr, tamaño sin firmar) ( sin firmar i, j; for (i = 0; i< size; i++) { for (j = 0; j < 5; j++) { printf("%d ", arr[i][j]); } printf("\n"); } } void main() { int x = { { 1, 2, 3, 4, 5}, { 6, 7, 8, 9, 10}}; printArray(x, 2); getch(); }

O puedes escribir

#incluir #incluir void printArray(int (*arr), tamaño sin firmar) ( sin firmar i, j; for (i = 0; i< size; i++) { for (j = 0; j < 5; j++) { printf("%d ", arr[i][j]); } printf("\n"); } } void main() { int x = { { 1, 2, 3, 4, 5}, { 6, 7, 8, 9, 10}}; printArray(x, 2); getch(); }

Si se crea dinámicamente una matriz bidimensional, entonces puede pasar un puntero a un puntero. Por ejemplo, una función que toma una matriz de palabras y devuelve una matriz de números enteros igual a la longitud de cada palabra:

#incluir #incluir #incluir #incluir #define TAMAÑO 10 unsigned* getLengths(const char **palabras, tamaño sin firmar) ( unsigned *lengths = NULL; unsigned i; lengths = (unsigned*) malloc(size * sizeof(unsigned)); for (i = 0; i< size; i++) { lengths[i] = strlen(words[i]); } return lengths; } void main() { char **words = NULL; char buffer; unsigned i; unsigned *len = NULL; words = (char**) malloc(SIZE * sizeof(char*)); for (i = 0; i < SIZE; i++) { printf("%d. ", i); scanf("%127s", buffer); words[i] = (char*) malloc(128); strcpy(words[i], buffer); } len = getLengths(words, SIZE); for (i = 0; i < SIZE; i++) { printf("%d ", len[i]); free(words[i]); } free(words); free(len); getch(); }

En lugar de devolver un puntero a una matriz, puede pasar una matriz que debe completarse

#incluir #incluir #incluir #incluir #define TAMAÑO 10 void getLengths(const char **palabras, tamaño sin firmar, sin firmar *out) ( unsigned i; for (i = 0; i< size; i++) { out[i] = strlen(words[i]); } } void main() { char **words = NULL; char buffer; unsigned i; unsigned *len = NULL; words = (char**) malloc(SIZE * sizeof(char*)); for (i = 0; i < SIZE; i++) { printf("%d. ", i); scanf("%127s", buffer); words[i] = (char*) malloc(128); strcpy(words[i], buffer); } len = (unsigned*) malloc(SIZE * sizeof(unsigned)); getLengths(words, SIZE, len); for (i = 0; i < SIZE; i++) { printf("%d ", len[i]); free(words[i]); } free(words); free(len); getch(); }

Aquí termina el primer conocimiento de las funciones: el tema es muy extenso y está dividido en varios artículos.

Al crear una aplicación de consola en el lenguaje de programación C++, se crea automáticamente una línea muy similar a esta:

Int main(int argc, char* argv) // parámetros de la función main()

Esta línea es el encabezado de la función principal main(), los parámetros argс y argv se declaran entre paréntesis. Entonces, si ejecuta un programa a través de la línea de comando, entonces es posible transferir cierta información a este programa, para esto existen los parámetros argc y argv. El parámetro argc tiene un tipo de datos int y contiene la cantidad de parámetros pasados ​​a la función principal. Además, argc siempre es al menos 1, incluso cuando no pasamos ninguna información, ya que el primer parámetro es el nombre de la función. El parámetro argv es una matriz de punteros a cadenas. Sólo se pueden pasar datos de cadena a través de la línea de comando. Los punteros y las cadenas son dos grandes temas para los que se han creado secciones independientes. Entonces es a través del parámetro argv que se transmite cualquier información. Desarrollemos un programa que ejecutaremos a través de la línea de comandos de Windows y le pasaremos información.

// argc_argv.cpp: define el punto de entrada para la aplicación de consola. #incluye "stdafx.h" #incluye usando el espacio de nombres estándar; int principal(int argc, char* argv) (si (argc ><< argv<

// código Código::Bloques

// código de desarrollo-C++

// argc_argv.cpp: define el punto de entrada para la aplicación de consola. #incluir usando el espacio de nombres estándar; int main(int argc, char* argv) ( if (argc > 1) // si pasamos argumentos, entonces argc será mayor que 1 (dependiendo del número de argumentos) ( cout<< argv<

Después de haber depurado el programa, abra la línea de comando de Windows y arrastre el archivo ejecutable de nuestro programa a la ventana de la línea de comando. La ruta completa al programa se mostrará en la línea de comando (pero puede ingresar la ruta al programa manualmente). ), después de lo cual puede hacer clic INGRESAR y el programa se iniciará (ver Figura 1).

Figura 1 - Parámetros de la función principal

Como simplemente ejecutamos el programa y no le pasamos ningún argumento, apareció el mensaje Sin argumentos. La Figura 2 muestra el inicio del mismo programa a través de la línea de comando, pero pasándole el argumento Abrir.

Figura 2 - Parámetros de la función principal

El argumento es la palabra Abrir, como se puede ver en la figura, esta palabra apareció en la pantalla. Puedes pasar varios parámetros a la vez, separándolos con una coma. Si necesita pasar un parámetro que consta de varias palabras, entonces deben estar entre comillas dobles y luego estas palabras se considerarán como un solo parámetro. Por ejemplo, la figura muestra el lanzamiento de un programa, pasándole un argumento que consta de dos palabras: Funciona.

Figura 3 - Parámetros de la función principal

Y si eliminas las comillas. Entonces veremos sólo la palabra Eso. Si no planea pasar ninguna información al ejecutar el programa, puede eliminar los argumentos en la función main() y también puede cambiar los nombres de estos argumentos. A veces se encuentran modificaciones en los parámetros argc y argv, pero todo esto depende del tipo de aplicación que se está creando o del entorno de desarrollo.

La forma básica de escribir una función es la siguiente

tipo_retorno nombre_función(lista_parámetros) { función_cuerpo) El tipo de datos devueltos por la función se especifica mediante el elemento tipo_retorno . Debajo del elemento lista_parámetros implica una lista de variables separadas por comas que pueden tomar cualquier argumento pasado por la función.

En C89, si el tipo de datos devuelto por una función no se especifica explícitamente, se supone el tipo int. En C++ y C99, el tipo int predeterminado no es compatible, aunque la mayoría de los compiladores de C++ todavía asumen esta suposición.

Prototipos de funciones

En el lenguaje C++, todas las funciones deben tener prototipos, y en el lenguaje C, los prototipos son formalmente opcionales, pero muy deseables. La forma general de una definición de prototipo es la siguiente.

tipo_retorno nombre_función(lista_parámetros); Por ejemplo. flotante fn(flotante x); //o flotar fn(flotar);

En C, la palabra clave void se usa en lugar de una lista de parámetros para especificar el prototipo de una función que no tiene parámetros. En C++, una lista de parámetros vacía en un prototipo de función significa que la función no tiene parámetros. La palabra nulo es opcional en este caso.

Valores devueltos (declaración de devolución)

La devolución de valores en funciones se realiza mediante la declaración de devolución. tiene dos formas de notación.

Devolver; devolver significado;

En C99 y C++, una forma de declaración de retorno que no especifica un valor de retorno solo debe usarse en funciones nulas.

Sobrecarga de funciones

En C++, las funciones pueden sobrecarga. Cuando se dice que una función está sobrecargada, significa que dos o más funciones tienen el mismo nombre, pero cada versión de la función sobrecargada tiene un número o tipo de parámetros diferente. Considere un ejemplo de las siguientes tres funciones sobrecargadas.

Función nula (int a)( cout

En cada caso, se analiza el tipo y la cantidad de argumentos para determinar qué versión de func() se llamará.

Pasar argumentos de función predeterminados

En C++, a un parámetro de función se le puede asignar un valor predeterminado, que se usará automáticamente si no se especifica el argumento correspondiente al llamar a la función. Por ejemplo.

Función vacía (int a = 0, int b = 10)() //llamar a func(); función(-1); función (-1, 99);

Alcance y vida útil de las variables.

Los lenguajes C y C++ definen reglas de visibilidad que establecen conceptos como el alcance y la vida útil de los objetos. Hay un alcance global y otro local.

Global existe un ámbito fuera de todos los demás ámbitos. Un nombre declarado en el ámbito global es conocido por todo el programa. Por ejemplo, una variable global está disponible para que la utilicen todas las funciones del programa. Las variables globales existen a lo largo del ciclo de vida de un programa.

Local el alcance está determinado por los límites del bloque. Un nombre declarado dentro de un ámbito local sólo se conoce dentro de ese ámbito. Las variables locales se crean al ingresar a un bloque y se destruyen al salir de él. Esto significa que las variables locales no almacenan sus valores entre llamadas a funciones. Para conservar los valores de las variables entre llamadas, puede utilizar el modificador estático.

recursividad

En C y C++, las funciones pueden llamarse a sí mismas. Este proceso se llama recursividad, y una función que se llama a sí misma es recursiva. Como ejemplo, usemos la función fact(), que calcula el factorial de un número entero.

Int hecho (int n) ( int ans; if (n == 1) devuelve 1; ans = hecho (n-1) * n; devuelve ans; )

función principal()

La ejecución de un programa C/C++ comienza con la ejecución de la función main(). (Los programas de Windows llaman a la función WinMain());

La función main() no tiene prototipo. Por lo tanto, se pueden utilizar varias formas de la función main(). Las siguientes variantes de la función main() son válidas tanto para C como para C++.

Int principal(); int principal(int argc, char *argv)

Como puede verse en la segunda forma de registro, f. main() acepta al menos dos parámetros. Se llaman argc y argv. Estos argumentos almacenarán la cantidad de argumentos de la línea de comando y un puntero a ellos respectivamente. argc es un tipo entero y su valor siempre será al menos 1 porque, como en C y C++, el primer argumento es siempre el nombre del programa. El parámetro argv debe declararse como una matriz de punteros de caracteres, con cada elemento apuntando a un argumento de línea de comando. A continuación se muestra un programa de ejemplo que demuestra el uso de estos argumentos.

#incluir usando el espacio de nombres estándar; int principal (int argc, char *argv) (si (argc

Pasando punteros

Aunque los lenguajes C y C++ usan el paso de parámetros por valor de forma predeterminada, puedes construir manualmente una llamada a f. con parámetros de paso por referencia. Para hacer esto, necesita pasar un puntero al argumento. Dado que en este caso a la función se le pasa la dirección del argumento, Resulta que es posible cambiar el valor del argumento fuera de la función.. Por ejemplo.

Intercambio nulo (int *x, int *y) ( int temp; temp = *x; ​​​​*x = *y; *y = temp; ) //llamar a swap (&a, &b);

En C++, la dirección de una variable se puede pasar a una función automáticamente. Esto se implementa usando parámetro de referencia. Cuando se utiliza un parámetro de referencia, la dirección del argumento se pasa a la función y la función opera sobre el argumento en lugar de sobre una copia. Para crear un parámetro de enlace, debe preceder su nombre con un signo comercial (&). Dentro f. este parámetro se puede utilizar normalmente, sin utilizar el operador asterisco (*), por ejemplo.

Intercambio nulo (int &x, int &y)( int temp; temp = x; x = y; y = temp; ) //llamar a swap (a, b);

Especificadores de funciones

C++ define tres especificadores de funciones:

  • en línea
  • virtual
  • explícito

El especificador en línea es una solicitud al compilador: en lugar de crear una llamada a función, expanda su código directamente en la línea. Si el compilador no puede insertar una función en una cadena, tiene derecho a ignorar este requisito. El especificador en línea puede definir tanto funciones miembro como funciones no miembro.

Como función virtual (usando el especificador virtual) f. se define en la clase base y se anula en la clase derivada. Usando funciones virtuales como ejemplo, puede comprender cómo el lenguaje C++ admite el polimorfismo.

El especificador explícito sólo se aplica a los constructores. Un constructor definido como explícito sólo se utilizará si la inicialización coincide exactamente con lo especificado por el constructor. No se realizarán conversiones (es decir, el especificador explícito crea un "constructor que no convierte").

Plantillas de funciones

La forma general de definir una función de plantilla es la siguiente.

Tipo de plantilla> tipo_retorno nombre_función (lista_parámetros) ( //cuerpo de la función ) Aquí tipo significa una etiqueta de marcador de posición para el tipo de datos que esta función realmente tratará. En la declaración de plantilla, puede definir múltiples parámetros de tipo de datos utilizando la forma de una lista de elementos separados por comas.

Veamos un ejemplo.

Plantilla intercambio vacío (X &a, X &b) ( X temp; temp = a; a = b; b = temp; ) //llamar a int a, b; flotar x, y; intercambiar(a, b); intercambiar(x, y);

Punteros de función

Puede crear un puntero a una función, como a cualquier otro objeto del lenguaje C. La sintaxis es la siguiente.

tipo_retorno (*nombre_indice)(descripción_variable); Esta declaración crea un puntero a una función llamada nombre_indice , que contiene variables descripción_variable y que devuelve un valor de tipo tipo_retorno .

Se puede llamar a una función usando un puntero de la siguiente manera.

nombre_indice = nombre_función; variable = nombre_indice (variables); Aquí la primera línea crea una referencia de función. nombre_función. La segunda línea en realidad llama a la función a través del puntero. nombre_indice , al que se pasan las variables variables, el valor se devuelve a una variable variable .

El siguiente ejemplo demuestra la creación de un puntero y dos formas de llamar a una función a través de un puntero, además de pasar la función como parámetro a otras funciones.

Doble y; doble (*p)(doble x); p=pecado; //creando un puntero a la función sin() y = (*p)(2.5); //llamar y = p(2.5); //llamar //pasando la función como parámetro double y; double f(double (*c)(double x), double y)( return c(y); //llama a la función pasada al puntero c y devuelve el valor ) y = f(sin, 2.5); //pasa la función sin a la función f, así como el parámetro que será procesado

También puede crear matrices de punteros de función.

Int f1(nulo); int f2(nulo); int f3(nulo); int (*p)(vacío) = (f1, f2, f3) y = (*p)(); //llamada a función f2 y = p(); //llamada a función f3

Función principal.

Todo programa C y C++ debe tener una función principal;<значение>este es el valor de una variable de entorno determinada, por ejemplo C:\DOS;C:\TOOLS (para RUTA) o YES (para 87). #incluir 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.<=argc; i++) printf(" argv[%d]: %s\n",i,argv[i]); printf("Среда содержит следующие строки:\n"); for (i=0; env[i] != NULL; i++) printf(" env[%d]: %s\n",i,env[i]); return 0; } Предположим, что вы запускаете программу ARGS.EXE со следующей командной строкой: C:> args first_arg "arg con espacios en blanco" 3 4 "penúltimo" ¡para! Comentario. Si desea que el procesamiento de caracteres de escape ocurra siempre, es decir Para que el editor de enlaces vincule automáticamente WILDARGS.OBJ, debe modificar su biblioteca C?.LIB estándar para incluir el archivo WILDARGS.OBJ. Para hacer esto, elimine SETARGV de la biblioteca y agregue WILDARGS. Esto se puede hacer con los siguientes comandos (asumimos que las bibliotecas estándar y WILDARGS.OBJ están contenidas en el directorio actual): TLIB se describe en el Capítulo 7, Utilidades, de la Guía del usuario tlib cs -setargv +wildargs tlib cc -. setargv +wildargs tlib cm -setargv +wildargs tlib cl -setargv +wildargs tlib ch -setargv +wildargs Compilación usando el modificador -p (convención de llamadas de Pascal) Si compila su programa usando la convención de llamadas de Pascal (descrita en detalle en Convención de llamadas de Pascal) ). Capítulo 9 "Interfaz con lenguaje ensamblador", "Guía del programador"), debe recordar que la función principal debe declararse explícitamente como una función C. Esto se puede hacer usando la palabra clave cdecl algo como esto: cdecl main(int argc). , char *argv, char *env) El valor devuelto por la función principal.


Edición del proyecto