Introducció:

En la programació en C, a prototip de funció s'utilitza per declarar el signatura d'una funció, que inclou la seva nom, tipus de retorn , i paràmetres . Els prototips de funció són importants perquè informen el compilador de la interfície de la funció abans de ser cridada, permetent una correcta comprovació de tipus i tractament d'errors. En aquest article, parlarem de la importància dels prototips de funcions en la programació C i com s'utilitzen.

Per què utilitzar prototips de funció?

Prototips de funció són importants en la programació en C per diverses raons. Una de les raons més importants és que permeten compilador per comprovar si hi ha errors abans que el programa s'executi realment. Si es crida una funció amb el nombre o el tipus d'arguments incorrectes, el compilador generarà un missatge d'error , evitant que el programa es bloquegi o es comporti de manera inesperada en temps d'execució.

Un altre motiu important per utilitzar prototips de funció és habilitar la programació modular. En C, les funcions es defineixen normalment en fitxers separats del programa principal i estan enllaçats entre si en temps de compilació. En declarar prototips de funció en fitxers de capçalera que s'inclouen tant al programa principal com als fitxers de definició de funció, la funció es pot cridar des de qualsevol part del programa sense necessitat d'accés als detalls d'implementació de la funció.

Prototips de funció també facilitar la lectura i la comprensió del codi. En incloure la signatura de la funció al codi font, altres desenvolupadors poden veure fàcilment què fa la funció, els seus arguments i el tipus de retorn. Fa que el codi sigui més autodocumentat i redueix la probabilitat d'errors causats per malentesos o interpretacions errònies del codi.

np punt

Sintaxi del prototip de funció:

La sintaxi d'un prototip de funció en programació C és la següent:

 return_type function_name(parameter_list); 

El tipus_retorn és el tipus de dades que el retorna la funció , tal com int, flotar , o char . El nom_funció és el nom de la funció , i la llista_paràmetres és una llista separada per comes paràmetres que pren la funció. Cada paràmetre en el llista_paràmetres consisteix en un tipus de dades seguit de nom del paràmetre .

Per exemple, el següent és un prototip de funció per a una funció que en pren dos nombres enters com a arguments i retorna la seva suma:

 int add(int num1, int num2); 

En aquest exemple, el tipus de retorn és int , el nom de la funció és afegir , i la llista de paràmetres consta de dos nombres enters anomenats núm1 i num2 .

Prototips de funció per defecte:

En programació en C, si una funció es crida abans que ho sigui definit o declarada , el compilador assumirà un prototip de funció predeterminat. El prototip de funció per defecte suposa que la funció retorna an int i pren qualsevol nombre d'arguments de qualsevol tipus.

Per exemple, considereu el codi següent:

 #include int main() { printf('The sum is %d
', add(2, 3)); return 0; } int add(int num1, int num2) { return num1 + num2; } 

Sortida:

 The sum is 5 

Explicació:

En aquest codi, el afegir funció es diu abans que sigui declarada o definit . Tanmateix, com que el compilador assumeix un prototip de funció predeterminat, el programa compila sense error i produeix la sortida correcta.

Tot i que els prototips de funcions per defecte de vegades són convenients, generalment no es recomanen perquè poden provocar errors i errors subtils. La millor pràctica és declarar els prototips de funcions de manera explícita per evitar possibles problemes.

Prototips de funció i fitxers de capçalera:

En la programació en C, prototips de funció sovint s'inclouen als fitxers de capçalera, que després s'inclouen tant al programa principal com als fitxers de definició de funcions. Permet cridar funcions des de qualsevol part del programa sense necessitat d'accés als detalls d'implementació de la funció.

Els fitxers de capçalera solen tenir un Extensió .h , i incloure només prototips de funció , definicions de tipus , i una altra declaracions que necessiten el programa principal o altres fitxers. Aquí teniu un exemple d'un fitxer de capçalera que declara la funció d'afegir d'anterior:

 #ifndef ADD_H #define ADD_H int add(int num1, int num2) 

En aquest exemple, el ifndef directiva comprova si ADD_H ja s'ha definit. Si no ho ha fet, defineix ADD_H i passa a incloure el prototip de funció per afegir.

El definir directiva crea a macro nomenat ADD_H , que es pot utilitzar per assegurar-se que el fitxer de capçalera només s'inclou una vegada a cada fitxer. És important evitar declaracions múltiples de la mateixa funció, que poden provocar errors. El prototip de funció car add simplement declara que la funció pren dos nombres enters com a arguments i retorna un nombre enter. És suficient informació perquè el programa principal i altres fitxers cridin correctament la funció d'afegir sense saber com s'implementa.

Quan s'inclou un fitxer de capçalera a a programa C , el preprocessador substitueix el #incloure directiva amb el contingut de la fitxer de capçalera . Permet que el programa principal i altres fitxers accedeixin als prototips de funcions i altres declaracions del fitxer de capçalera.

Alguns punts importants del prototip de funció en C:

Els prototips de funció ajuden a detectar errors:

Quan un prototip de funció s'inclou en un programa C, el compilador comprova que la funció s'utilitza correctament abans d'executar el programa. Ajuda a detectar errors abans d'executar el programa.

Els prototips de funció són essencials en programes grans:

fer executable un script sh

En programes grans, és important separar clarament les preocupacions entre les diferents funcions. Els prototips de funció permeten aquesta separació ja que permeten que cada funció es desenvolupi de manera independent sense conèixer els detalls d'implementació d'altres funcions.

Els prototips de funció es poden declarar als fitxers de capçalera:

Com s'ha esmentat anteriorment, els prototips de funció normalment es declaren als fitxers de capçalera. Els fitxers de capçalera s'inclouen tant al programa principal com als fitxers de definició de funcions, fent que les funcions siguin accessibles des de qualsevol part del programa.

Els prototips de funcions es poden sobrecarregar:

C no admet la sobrecàrrega de funcions com alguns altres llenguatges de programació, però els prototips de funcions es poden sobrecarregar utilitzant diferents tipus d'arguments i números. Permet utilitzar el mateix nom de funció per a diferents finalitats.

Els prototips de funció poden incloure valors d'argument predeterminats:

C no admet valors d'argument predeterminats com alguns altres llenguatges de programació, però els prototips de funció poden incloure arguments opcionals mitjançant una sintaxi especial. Permet utilitzar la mateixa funció amb o sense certs arguments.

Els prototips de funció es poden declarar endavant:

En alguns casos, pot ser necessari declarar un prototip de funció abans que la seva implementació estigui disponible. Es diu declaració endavant i pot ser útil en programes complexos on la implementació d'una funció pot no ser coneguda en el moment de la seva declaració.

Aquí hi ha alguns exemples més de prototips de funcions en programació C:

Exemple 1:

 #include float calculate_average(int arr[], int size); int main() { int arr[] = {1, 2, 3, 4, 5}; int size = 5; float average = calculate_average(arr, size); printf(&apos;The average is: %.2f&apos;, average); return 0; } float calculate_average(int arr[], int size) { float sum = 0.0; for (int i = 0; i<size; i++) { sum +="arr[i];" } return size; < pre> <p> <strong>Output:</strong> </p> <pre> The average is: 3.00 </pre> <p> <strong>Explanation:</strong> </p> <p>In this example, we first declare the <strong> <em>calculate_average</em> </strong> function prototype at the beginning of our program before the main function. After that, inside the main function, we declare an integer array <strong> <em>arr</em> </strong> with some values and a size of <strong> <em>5</em> </strong> . After that, we call the <strong> <em>calculate_average function</em> </strong> , passing in the <strong> <em>arr array</em> </strong> and its size, and store the result in a <strong> <em>float variable</em> </strong> named <strong> <em>average</em> </strong> . Finally, we print out the result using printf.</p> <p>The <strong> <em>calculate_average</em> </strong> function takes in the integer <strong> <em>array arr</em> </strong> and its size as arguments and returns the average value of the array as a <strong> <em>float</em> </strong> . We first declare a float variable named <strong> <em>sum</em> </strong> inside the function and initialize it to <strong> <em>0.0</em> </strong> . After that, we loop through each element in the array using a <strong> <em>for loop</em> </strong> , adding each element to the sum variable. Finally, we return the result of dividing the sum variable by the array size.</p> <p>Its average is <strong> <em>3.00</em> </strong> because the <strong> <em>arr</em> </strong> array contains the values <strong> <em>{1, 2, 3, 4, 5}</em> </strong> , and the average of these values is <strong> <em>(1+2+3+4+5)/5 = 3.00</em> </strong> . The <strong> <em>printf</em> </strong> statement in the main function uses the <strong> <em>%f format specifier</em> </strong> to print out the average value as a floating-point number. The <strong> <em>.2 modifier</em> </strong> specifies that we want to print only two decimal places.</p> <p> <strong>Example 2:</strong> </p> <pre> #include void print_message(char *msg); int main() { char *msg = &apos;Hello, world!&apos;; print_message(msg); return 0; } void print_message(char *msg) { printf(&apos;%s
&apos;, msg); } </pre> <p> <strong>Output:</strong> </p> <pre> Hello, world! </pre> <p> <strong>Explanation:</strong> </p> <p>In this example, we first declare the <strong> <em>print_message</em> </strong> function prototype at the beginning of our program, before the main function. Then, inside the main function, we declare a character pointer <strong> <em>msg</em> </strong> and initialize it to point to a string literal <strong> <em>&apos;Hello, world!&apos;</em> </strong> . After that, we call the <strong> <em>print_message</em> </strong> function, passing in the <strong> <em>msg pointer</em> </strong> .</p> <p>The <strong> <em>print_message</em> </strong> function takes in a character pointer <strong> <em>msg</em> </strong> as an argument, and returns nothing <strong> <em>(void)</em> </strong> . Inside the function, we use the <strong> <em>printf function</em> </strong> to print out the string pointed to by <strong> <em>msg</em> </strong> , followed by a <strong> <em>newline character (
)</em> </strong> . The <strong> <em>%s</em> </strong> format specifier is used to print out a string.</p> <p>The Output is <strong> <em>Hello, world!</em> </strong> . Because the <strong> <em>print_message</em> </strong> function prints out the string pointed to by the <strong> <em>msg pointer</em> </strong> , which in this case is <strong> <em>&apos;Hello, world!&apos;</em> </strong> , followed by a newline character.</p> <p> <strong>Example 3:</strong> </p> <pre> #include int factorial(int n); int main() { int n = 5; int result = factorial(n); printf(&apos;%d! = %d
&apos;, n, result); return 0; } int factorial(int n) { if (n == 0) { return 1; } else { return n * factorial(n-1); } } </pre> <p> <strong>Explanation:</strong> </p> <p>In this example, we first declare the <strong> <em>factorial function</em> </strong> prototype at the beginning of our program, before the main function. Then, inside the main function, we declare an integer variable <strong> <em>n</em> </strong> and initialize it to <strong> <em>5</em> </strong> . After that, we call the factorial function, passing in <strong> <em>n</em> </strong> , and store the result in an integer variable named <strong> <em>result</em> </strong> . Finally, we print out the result using <strong> <em>printf</em> </strong> .</p> <p>The factorial function takes in an integer <strong> <em>n</em> </strong> as an argument, and returns its factorial as an <strong> <em>integer</em> </strong> . Inside the function, we first check if <strong> <em>n</em> </strong> is equal to <strong> <em>0</em> </strong> . If it is, we return <strong> <em>1</em> </strong> , since <strong> <em>0! = 1</em> </strong> by definition. Otherwise, we return <strong> <em>n * factorial(n-1)</em> </strong> , which is the factorial of <strong> <em>n</em> </strong> calculated recursively as the product of <strong> <em>n</em> </strong> and the factorial of <strong> <em>n-1</em> </strong> .</p> <p>The output of the code will be:</p> <pre> 5! = 120 </pre> <p>This is because the <strong> <em>factorial function</em> </strong> calculates <strong> <em>5!</em> </strong> as <strong> <em>5 * 4 * 3 * 2 * 1 = 120</em> </strong> , and this result is printed out using <strong> <em>printf</em> </strong> .</p> <p> <strong>Example 4:</strong> </p> <pre> #include int find_max(int arr[], int size); int main() { int arr[] = {3, 5, 2, 8, 1}; int size = sizeof(arr) / sizeof(int); int max = find_max(arr, size); printf(&apos;The maximum value in the array is: %d
&apos;, max); return 0; } int find_max(int arr[], int size) { int max = arr[0]; for (int i = 1; i max) { max = arr[i]; } } return max; } </pre> <p> <strong>Explanation:</strong> </p> <p>In this example, we first declare the <strong> <em>find_max</em> </strong> function prototype at the beginning of our program, before the main function. Then, inside the main function, we declare an integer <strong> <em>array arr</em> </strong> and initialize it with some values, and a variable size that stores the size of the array. After that, we call the <strong> <em>find_max function</em> </strong> , passing in the <strong> <em>arr array</em> </strong> and <strong> <em>size</em> </strong> , and store the result in an integer variable named <strong> <em>max</em> </strong> . Finally, we print out the result using <strong> <em>printf</em> </strong> .</p> <p>The <strong> <em>find_max function</em> </strong> takes in an integer array <strong> <em>arr</em> </strong> and its size <strong> <em>size</em> </strong> as arguments, and returns the maximum value in the array as an integer. Inside the function, we first initialize a variable max with the first element of the array arr. After that, we loop over the remaining elements of the array using a for loop, comparing each element to the current maximum value using an if statement. If the current element is greater than the current maximum, we update max to the value of the current element. After the loop finishes, we return the final value of max.</p> <p>The <strong> <em>output</em> </strong> of the code will be:</p> <pre> The maximum value in the array is: 8 </pre> <p>This is because the <strong> <em>find_max</em> </strong> function searches through the array <strong> <em>{3, 5, 2, 8, 1}</em> </strong> and finds that the maximum value is <strong> <em>8</em> </strong> , which is then printed out using <strong> <em>printf</em> </strong> .</p> <p>Overall, function prototypes are an essential part of C programming that allow for <strong> <em>modular programming</em> , <em>type checking</em> , <em>error handling</em> </strong> , and <strong> <em>self-documenting code</em> </strong> . By declaring function prototypes, developers can write more robust, maintainable, and error-free code.</p> <p> <strong>Example 5:</strong> </p> <pre> #include void greet_user(char *name); int main() { char name[50]; printf(&apos;What is your name? &apos;); scanf(&apos;%s&apos;, name); greet_user(name); return 0; } void greet_user(char *name) { printf(&apos;Hello, %s! Nice to meet you.
&apos;, name); } </pre> <p> <strong>Explanation:</strong> </p> <p>In this example, we first declare the <strong> <em>greet_user function</em> </strong> prototype at the beginning of our program, before the main function. Then, inside the main function, we declare a character array name with a size of <strong> <em>50</em> </strong> , and use <strong> <em>printf</em> </strong> and <strong> <em>scanf</em> </strong> to ask the user for their name and read it into the name array. After that, we call the <strong> <em>greet_user function</em> </strong> , passing in the name array as an argument.</p> <p>The <strong> <em>greet_user function</em> </strong> takes in a character pointer name as an argument, which is a pointer to the first character of a string. Inside the function, we use <strong> <em>printf</em> </strong> to print out a greeting message that includes the user&apos;s name, and a friendly message.</p> <p>The output of the code will depend on the user&apos;s input. Here&apos;s an example of what the output might look like:</p> <pre> What is your name? suman Hello, suman! Nice to meet you. </pre> <p>In this case, the user enters the name <strong> <em>&apos;suman&apos;</em> </strong> , and the program prints out a greeting message that includes their name.</p> <h2>Conclusion:</h2> <p> <strong> <em>Function prototypes</em> </strong> are an important part of C programming, enabling modular programming, error checking, and self-documenting code. By declaring the signature of a function before it is called, function prototypes allow the compiler to check for errors, enable modular programming, and make code easier to read and understand.</p> <p>In C programming, function prototypes are typically included in <strong> <em>header files</em> </strong> , which are then included in both the main program and the function definition files. It allows functions to be called from any part of the program without requiring access to the function&apos;s implementation details. By understanding the importance of function prototypes and how they are used in C programming, developers can write more robust, maintainable, and error-free code.</p> <hr></size;>

Explicació:

np.concatenar

En aquest exemple, primer declarem el calcula_mitjana prototip de funció al començament del nostre programa abans de la funció principal. Després d'això, dins de la funció principal, declarem una matriu enter arr amb uns valors i una mida de 5 . Després d'això, anomenem el funció calcular_average , passant a la arr matriu i la seva mida, i emmagatzemar el resultat en a variable flotant nomenat mitjana . Finalment, imprimim el resultat amb printf.

El calcula_mitjana la funció pren l'enter array arr i la seva mida com a arguments i retorna el valor mitjà de la matriu com a flotar . Primer declarem una variable flotant anomenada suma dins de la funció i inicialitzar-la 0.0 . Després d'això, recorrem cada element de la matriu mitjançant a per bucle , afegint cada element a la variable suma. Finalment, retornem el resultat de dividir la variable suma per la mida de la matriu.

La seva mitjana és 3.00 perquè el arr array conté els valors {1, 2, 3, 4, 5} , i la mitjana d'aquests valors és (1+2+3+4+5)/5 = 3.00 . El imprimirf La declaració de la funció principal utilitza el especificador de format %f per imprimir el valor mitjà com a nombre de coma flotant. El .2 modificador especifica que volem imprimir només dos decimals.

Exemple 2:

 #include void print_message(char *msg); int main() { char *msg = 'Hello, world!'; print_message(msg); return 0; } void print_message(char *msg) { printf('%s
', msg); } 

Sortida:

 Hello, world! 

Explicació:

En aquest exemple, primer declarem el missatge_imprimir prototip de funció al principi del nostre programa, abans de la funció principal. Aleshores, dins de la funció principal, declarem un punter de caràcter msj i inicialitzeu-lo per apuntar a un literal de cadena 'Hola món!' . Després d'això, anomenem el missatge_imprimir funció, passant en el punter de missatge .

El missatge_imprimir La funció recull un punter de caràcter msj com a argument i no retorna res (buit) . Dins de la funció, fem servir el funció printf per imprimir la cadena assenyalada per msj , seguit d'a caràcter de nova línia ( ) . El %s L'especificador de format s'utilitza per imprimir una cadena.

La sortida és Hola món! . Perquè el missatge_imprimir La funció imprimeix la cadena apuntada per punter de missatge , que en aquest cas és 'Hola món!' , seguit d'un caràcter de nova línia.

Exemple 3:

 #include int factorial(int n); int main() { int n = 5; int result = factorial(n); printf('%d! = %d
', n, result); return 0; } int factorial(int n) { if (n == 0) { return 1; } else { return n * factorial(n-1); } } 

Explicació:

En aquest exemple, primer declarem el funció factorial prototip al començament del nostre programa, abans de la funció principal. Aleshores, dins de la funció principal, declarem una variable entera n i inicialitzar-lo 5 . Després d'això, anomenem la funció factorial, passant-hi n , i emmagatzema el resultat en una variable entera anomenada resultat . Finalment, imprimim el resultat utilitzant imprimirf .

La funció factorial pren un nombre enter n com a argument i retorna el seu factorial com a enter . Dins de la funció, primer comprovem si n és igual a 0 . Si és així, tornem 1 , ja que 0! = 1 per definició. En cas contrari, tornem n * factorial (n-1) , que és el factorial de n calculat recursivament com el producte de n i el factorial de n-1 .

La sortida del codi serà:

 5! = 120 

Això és perquè el funció factorial calcula 5! com 5 * 4 * 3 * 2 * 1 = 120 , i aquest resultat s'imprimeix amb imprimirf .

Exemple 4:

 #include int find_max(int arr[], int size); int main() { int arr[] = {3, 5, 2, 8, 1}; int size = sizeof(arr) / sizeof(int); int max = find_max(arr, size); printf('The maximum value in the array is: %d
', max); return 0; } int find_max(int arr[], int size) { int max = arr[0]; for (int i = 1; i max) { max = arr[i]; } } return max; } 

Explicació:

En aquest exemple, primer declarem el trobar_màx prototip de funció al principi del nostre programa, abans de la funció principal. Aleshores, dins de la funció principal, declarem un nombre enter array arr i inicialitzar-lo amb alguns valors i una mida variable que emmagatzema la mida de la matriu. Després d'això, anomenem el funció find_max , passant a la arr matriu i mida , i emmagatzema el resultat en una variable entera anomenada màx . Finalment, imprimim el resultat utilitzant imprimirf .

El funció find_max incorpora una matriu enter arr i la seva mida mida com a arguments i retorna el valor màxim de la matriu com a nombre enter. Dins de la funció, primer inicialitzem una variable max amb el primer element de la matriu arr. Després d'això, fem un bucle sobre els elements restants de la matriu mitjançant un bucle for, comparant cada element amb el valor màxim actual mitjançant una instrucció if. Si l'element actual és més gran que el màxim actual, actualitzem el màxim al valor de l'element actual. Un cop acaba el bucle, retornem el valor final de màx.

objecte de java

El sortida del codi serà:

 The maximum value in the array is: 8 

Això és perquè el trobar_màx cerques de funcions a través de la matriu {3, 5, 2, 8, 1} i troba que el valor màxim és 8 , que després s'imprimeix amb imprimirf .

En general, els prototips de funcions són una part essencial de la programació C que permeten programació modular , comprovació de tipus , maneig d'errors , i codi d'autodocumentació . En declarar prototips de funcions, els desenvolupadors poden escriure un codi més robust, més fàcil de mantenir i sense errors.

Exemple 5:

 #include void greet_user(char *name); int main() { char name[50]; printf('What is your name? '); scanf('%s', name); greet_user(name); return 0; } void greet_user(char *name) { printf('Hello, %s! Nice to meet you.
', name); } 

Explicació:

En aquest exemple, primer declarem el funció greet_user prototip al començament del nostre programa, abans de la funció principal. A continuació, dins de la funció principal, declarem un nom de matriu de caràcters amb una mida de 50 , i utilitzar imprimirf i escanf per demanar el seu nom a l'usuari i llegir-lo a la matriu de noms. Després d'això, anomenem el funció greet_user , passant la matriu de noms com a argument.

El funció greet_user pren un nom de punter de caràcter com a argument, que és un punter al primer caràcter d'una cadena. Dins de la funció, fem servir imprimirf per imprimir un missatge de salutació que inclogui el nom de l'usuari i un missatge amigable.

La sortida del codi dependrà de l'entrada de l'usuari. Aquí teniu un exemple de com podria semblar la sortida:

 What is your name? suman Hello, suman! Nice to meet you. 

En aquest cas, l'usuari introdueix el nom 'sumen' , i el programa imprimeix un missatge de salutació que inclou el seu nom.

Conclusió:

Prototips de funció són una part important de la programació en C, ja que permeten la programació modular, la comprovació d'errors i el codi d'autodocumentació. En declarar la signatura d'una funció abans de ser cridada, els prototips de funció permeten al compilador comprovar si hi ha errors, habilitar la programació modular i facilitar la lectura i la comprensió del codi.

A la programació en C, normalment s'inclouen prototips de funcions fitxers de capçalera , que s'inclouen tant al programa principal com als fitxers de definició de funcions. Permet cridar funcions des de qualsevol part del programa sense necessitat d'accés als detalls d'implementació de la funció. En entendre la importància dels prototips de funcions i com s'utilitzen en la programació en C, els desenvolupadors poden escriure un codi més robust, fàcil de mantenir i sense errors.