Įvadas:

Programuojant C, a funkcijos prototipas naudojamas deklaruoti parašas funkcijos, kuri apima jos pavadinimas, grąžinimo tipas , ir parametrus . Funkcijų prototipai yra svarbūs, nes jie informuoja kompiliatorių apie funkcijos sąsają prieš ją iškviečiant, kad būtų galima tinkamai patikrinti tipą ir tvarkyti klaidas. Šiame straipsnyje aptarsime funkcijų prototipų svarbą programuojant C ir kaip jie naudojami.

Kodėl verta naudoti funkcijų prototipus?

Funkcijų prototipai yra svarbūs C programuojant dėl ​​kelių priežasčių. Viena iš svarbiausių priežasčių yra ta, kad jie leidžia kompiliatorius patikrinti, ar nėra klaidų, prieš iš tikrųjų paleidžiant programą. Jei funkcija iškviečiama su neteisingu argumentų skaičiumi ar tipu, kompiliatorius sugeneruos klaidos pranešimas , neleidžianti programai užstrigti arba netikėtai veikti vykdymo metu.

Kita svarbi priežastis naudoti funkcijų prototipus – įjungti modulinį programavimą. C kalboje funkcijos paprastai apibrėžiamos atskiruose failuose iš pagrindinės programos ir yra susietos kompiliavimo metu. Deklaruojant funkcijų prototipus antraštės failuose, kurie yra įtraukti į pagrindinę programą ir funkcijos apibrėžimo failus, funkcija gali būti iškviesta iš bet kurios programos dalies, nereikalaujant prieigos prie funkcijos įgyvendinimo detalių.

Funkcijų prototipai taip pat lengviau skaityti ir suprasti kodą. Į šaltinio kodą įtraukę funkcijos parašą, kiti kūrėjai gali lengvai pamatyti, ką funkcija veikia, jos argumentus ir grąžinimo tipą. Tai daro kodą labiau savarankišką dokumentaciją ir sumažina klaidų tikimybę, atsiradusias dėl nesusipratimų ar klaidingų kodo interpretacijų.

java spausdinimas

Funkcijos prototipo sintaksė:

Funkcijos prototipo sintaksė programuojant C yra tokia:

 return_type function_name(parameter_list); 

The grąžinimo_tipas yra duomenų tipas, kurį funkcija grįžta , toks kaip int, plūduriuoti , arba char . The funkcijos_pavadinimas yra pavadinimas funkcija , ir parametrų_sąrašas yra kableliais atskirtas sąrašas parametrus kad funkcija užima. Kiekvienas parametras parametrų_sąrašas susideda iš duomenų tipo, po kurio seka parametro pavadinimas .

Pavyzdžiui, toliau pateikiamas funkcijos prototipas, skirtas funkcijai, kuriai reikia dviejų sveikieji skaičiai kaip argumentus ir grąžina jų sumą:

 int add(int num1, int num2); 

Šiame pavyzdyje grąžinimo tipas yra tarpt , funkcijos pavadinimas yra papildyti , o parametrų sąrašą sudaro du pavadinti sveikieji skaičiai skaičius1 ir skaičius2 .

Numatytų funkcijų prototipai:

C programuojant, jei funkcija iškviečiama anksčiau apibrėžta arba deklaravo , kompiliatorius priims numatytąjį funkcijos prototipą. The numatytosios funkcijos prototipas daro prielaidą, kad funkcija grąžina an tarpt ir priima bet kokį skaičių bet kokio tipo argumentų.

Pavyzdžiui, apsvarstykite šį kodą:

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

Išvestis:

 The sum is 5 

Paaiškinimas:

Šiame kode, pridėti funkciją yra vadinamas anksčiau deklaravo arba apibrėžta . Tačiau, kadangi kompiliatorius prisiima numatytąjį funkcijos prototipą, programa kompiliuoja be jo klaida ir sukuria tinkamą produkciją.

Nors numatytųjų funkcijų prototipai kartais yra patogūs, jie paprastai nerekomenduojami, nes gali sukelti subtilių klaidų ir klaidų. Geriausia praktika yra aiškiai deklaruoti funkcijų prototipus, kad būtų išvengta galimų problemų.

Funkcijų prototipai ir antraštės failai:

C programuojant, funkcijų prototipai dažnai įtraukiami į antraštės failus, kurie vėliau įtraukiami ir į pagrindinę programą, ir į funkcijų apibrėžimo failus. Tai leidžia iškviesti funkcijas iš bet kurios programos dalies, nereikalaujant prieigos prie funkcijos įgyvendinimo informacijos.

Antraštės failai paprastai turi a .h pratęsimas ir apima tik funkcijų prototipai , tipo apibrėžimai , ir kita deklaracijas kurių reikia pagrindinei programai ar kitiems failams. Čia yra antraštės failo, kuris deklaruoja ankstesnę funkciją, pavyzdys:

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

Šiame pavyzdyje ifndef direktyva tikrina, ar ADD_H jau buvo apibrėžtas. Jei ne, tai apibrėžia ADD_H ir pajamas įtraukiant funkcijos prototipą, skirtą pridėti.

The apibrėžti direktyva sukuria a makrokomandą pavadintas ADD_H , kurį galima naudoti norint užtikrinti, kad antraštės failas būtų įtrauktas tik vieną kartą į kiekvieną failą. Svarbu užkirsti kelią kelioms tos pačios funkcijos deklaracijoms, kurios gali sukelti klaidų. The funkcijos prototipas for add tiesiog deklaruoja, kad funkcija kaip argumentus paima du sveikuosius skaičius ir grąžina sveikąjį skaičių. Pakanka informacijos, kad pagrindinė programa ir kiti failai galėtų teisingai iškviesti pridėjimo funkciją, nežinant, kaip ji įgyvendinama.

Kai antraštės failas įtrauktas į a C programa , pirminis procesorius pakeičia #įtraukti direktyvą su jos turiniu antraštės failą . Tai leidžia pagrindinei programai ir kitiems failams pasiekti funkcijų prototipus ir kitas antraštės failo deklaracijas.

Kai kurie svarbūs funkcijos prototipo punktai C:

Funkcijų prototipai padeda sugauti klaidas:

Kada funkcijos prototipas yra įtraukta į C programą, kompiliatorius prieš paleisdamas programą patikrina, ar funkcija naudojama teisingai. Tai padeda pastebėti klaidas anksti prieš paleidžiant programą.

Funkcijų prototipai yra būtini didelėse programose:

tat pilna forma

Didelėse programose svarbu aiškiai atskirti skirtingų funkcijų problemas. Funkcijų prototipai leidžia atskirti kiekvieną funkciją atskirai, nežinant kitų funkcijų įgyvendinimo detalių.

Funkcijų prototipus galima deklaruoti antraštės failuose:

Kaip minėta anksčiau, funkcijų prototipai paprastai deklaruojami antraštės failuose. Tada antraštės failai įtraukiami ir į pagrindinę programą, ir į funkcijų apibrėžimo failus, todėl funkcijas galima pasiekti iš bet kurios programos dalies.

Funkcijų prototipai gali būti perkrauti:

C nepalaiko funkcijų perkrovimo, kaip ir kai kurios kitos programavimo kalbos, tačiau funkcijų prototipus galima perkrauti naudojant skirtingus argumentų tipus ir skaičius. Tai leidžia naudoti tą patį funkcijos pavadinimą įvairiems tikslams.

Funkcijų prototipai gali apimti numatytąsias argumentų reikšmes:

C nepalaiko numatytųjų argumentų reikšmių, kaip ir kai kurios kitos programavimo kalbos, tačiau funkcijų prototipai gali įtraukti pasirenkamus argumentus naudojant specialią sintaksę. Tai leidžia naudoti tą pačią funkciją su tam tikrais argumentais arba be jų.

Funkcijų prototipai gali būti deklaruojami į priekį:

Kai kuriais atvejais gali prireikti deklaruoti funkcijos prototipą prieš jį įgyvendinant. Tai vadinama išankstinė deklaracija ir gali būti naudinga sudėtingose ​​programose, kuriose funkcijos įgyvendinimas jos deklaravimo metu gali būti nežinomas.

Čia yra dar keli C programavimo funkcijų prototipų pavyzdžiai:

1 pavyzdys:

 #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;>

Paaiškinimas:

Šiame pavyzdyje pirmiausia deklaruojame apskaičiuoti_vidurkį funkcijos prototipas mūsų programos pradžioje prieš pagrindinę funkciją. Po to pagrindinės funkcijos viduje deklaruojame sveikųjų skaičių masyvą arr su tam tikromis reikšmėmis ir dydžiu 5 . Po to skambiname į apskaičiuoti_vidutinį funkciją , einantis į arr masyvas ir jo dydį, o rezultatą išsaugokite a plūduriuojantis kintamasis pavadintas vidutinis . Galiausiai išspausdiname rezultatą naudodami printf.

The apskaičiuoti_vidurkį funkcija paima sveikąjį skaičių masyvas arr ir jo dydį kaip argumentus ir grąžina vidutinę masyvo reikšmę kaip a plūdė . Pirmiausia deklaruojame plūduriuojantį kintamąjį pavadinimu suma funkcijos viduje ir inicijuokite ją 0,0 . Po to mes apsukame kiekvieną masyvo elementą naudodami a už kilpą , pridedant kiekvieną elementą prie sumos kintamojo. Galiausiai grąžiname rezultatą, padalydami sumos kintamąjį iš masyvo dydžio.

Jo vidurkis yra 3.00 val nes arr masyve yra reikšmės {1, 2, 3, 4, 5} , o šių verčių vidurkis yra (1+2+3+4+5)/5 = 3,00 . The printf pagrindinėje funkcijoje naudojamas teiginys %f formato specifikatorius norėdami išspausdinti vidutinę vertę kaip slankiojo kablelio skaičių. The .2 modifikatorius nurodo, kad norime spausdinti tik du skaitmenis po kablelio.

2 pavyzdys:

 #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); } 

Išvestis:

 Hello, world! 

Paaiškinimas:

Šiame pavyzdyje pirmiausia deklaruojame print_message funkcijos prototipas mūsų programos pradžioje, prieš pagrindinę funkciją. Tada pagrindinėje funkcijoje paskelbiame simbolio žymeklį žinutė ir inicijuokite jį, kad nurodytumėte eilutės literalą 'Labas pasauli!' . Po to skambiname į print_message funkcija, perduodama į žinutės rodyklė .

The print_message funkcija paima simbolių žymeklį žinutė kaip argumentą ir nieko negrąžina (tuštuma) . Funkcijos viduje naudojame printf funkcija norėdami išspausdinti nurodytą eilutę žinutė , po kurio seka a naujos eilutės simbolis ( ) . The %s formato specifikatorius naudojamas eilutei spausdinti.

Išvestis yra Labas pasauli! . Nes print_message funkcija išspausdina eilutę, į kurią nukreipta žinutės rodyklė , kuris šiuo atveju yra 'Labas pasauli!' , po kurio yra naujos eilutės simbolis.

3 pavyzdys:

 #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); } } 

Paaiškinimas:

Šiame pavyzdyje pirmiausia deklaruojame faktorinė funkcija prototipas mūsų programos pradžioje, prieš pagrindinę funkciją. Tada pagrindinės funkcijos viduje deklaruojame sveikąjį kintamąjį n ir inicijuokite jį 5 . Po to mes vadiname faktorių funkciją, perėjimą n , ir išsaugokite rezultatą sveikajame kintamajame, pavadintame rezultatas . Galiausiai išspausdiname rezultatą naudodami printf .

serialas postgres

Faktorinė funkcija įgauna sveikąjį skaičių n kaip argumentą ir grąžina savo faktorialą kaip an sveikasis skaičius . Funkcijoje pirmiausia patikriname, ar n yra lygus 0 . Jei taip, grįšime 1 , nuo 0! = 1 pagal apibrėžimą. Priešingu atveju grįšime n * faktorialus (n-1) , kuris yra faktorialas n apskaičiuojamas rekursyviai kaip sandauga n ir faktorialas n-1 .

Kodo išvestis bus tokia:

 5! = 120 

Taip yra todėl, faktorinė funkcija skaičiuoja 5! kaip 5 * 4 * 3 * 2 * 1 = 120 , ir šis rezultatas išspausdinamas naudojant printf .

4 pavyzdys:

 #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; } 

Paaiškinimas:

Šiame pavyzdyje pirmiausia deklaruojame rasti_maks funkcijos prototipas mūsų programos pradžioje, prieš pagrindinę funkciją. Tada pagrindinės funkcijos viduje deklaruojame sveikąjį skaičių masyvas arr ir inicijuokite jį su kai kuriomis reikšmėmis ir kintamu dydžiu, kuriame saugomas masyvo dydis. Po to skambiname į Find_max funkcija , einantis į arr masyvas ir dydis , ir išsaugokite rezultatą sveikajame kintamajame, pavadintame maks . Galiausiai išspausdiname rezultatą naudodami printf .

The Find_max funkcija užima sveikųjų skaičių masyvą arr ir jo dydis dydis kaip argumentus ir grąžina maksimalią masyvo reikšmę kaip sveikąjį skaičių. Funkcijoje pirmiausia inicijuojame kintamąjį max su pirmuoju masyvo arr elementu. Po to apjungiame likusius masyvo elementus naudodami for kilpą, lygindami kiekvieną elementą su dabartine maksimalia reikšme naudodami if teiginį. Jei dabartinis elementas yra didesnis už esamą maksimumą, atnaujiname max iki dabartinio elemento vertės. Kai ciklas baigiasi, grąžiname galutinę maks.

The išvestis kodas bus:

 The maximum value in the array is: 8 

Taip yra todėl, rasti_maks funkcija ieško masyve {3, 5, 2, 8, 1} ir nustato, kad didžiausia vertė yra 8 , kuris vėliau atspausdinamas naudojant printf .

Apskritai funkcijų prototipai yra esminė C programavimo dalis, leidžianti modulinis programavimas , tipo tikrinimas , klaidų tvarkymas , ir savidokumentacijos kodas . Deklaruodami funkcijų prototipus, kūrėjai gali parašyti patikimesnį, prižiūrimesnį ir be klaidų kodą.

Pitas Davidsonas

5 pavyzdys:

 #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); } 

Paaiškinimas:

Šiame pavyzdyje pirmiausia deklaruojame greet_user funkcija prototipas mūsų programos pradžioje, prieš pagrindinę funkciją. Tada pagrindinės funkcijos viduje deklaruojame simbolių masyvo pavadinimą, kurio dydis yra penkiasdešimt , ir naudoti printf ir scanf paprašyti vartotojo vardo ir perskaityti jį vardų masyve. Po to skambiname į greet_user funkcija , pateikiant vardų masyvą kaip argumentą.

The greet_user funkcija kaip argumentą įveda simbolio žymeklio pavadinimą, kuris yra žymeklis į pirmąjį eilutės simbolį. Funkcijoje mes naudojame printf atsispausdinti sveikinimo žinutę su vartotojo vardu ir draugiška žinute.

Kodo išvestis priklausys nuo vartotojo įvesties. Štai pavyzdys, kaip gali atrodyti išvestis:

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

Tokiu atveju vartotojas įveda vardą 'sumam' , ir programa išspausdina sveikinimo pranešimą, kuriame nurodomas jų vardas.

Išvada:

Funkcijų prototipai yra svarbi C programavimo dalis, įgalinanti modulinį programavimą, klaidų tikrinimą ir savaiminio kodo dokumentavimą. Deklaruodami funkcijos parašą prieš ją iškviečiant, funkcijų prototipai leidžia kompiliatoriui patikrinti, ar nėra klaidų, įgalina modulinį programavimą ir palengvina kodo skaitymą bei supratimą.

Į C programavimą paprastai įtraukiami funkcijų prototipai antraštės failus , kurios tada įtraukiamos ir į pagrindinę programą, ir į funkcijų apibrėžimo failus. Tai leidžia iškviesti funkcijas iš bet kurios programos dalies, nereikalaujant prieigos prie funkcijos įgyvendinimo informacijos. Suprasdami funkcijų prototipų svarbą ir tai, kaip jie naudojami programuojant C, kūrėjai gali parašyti patikimesnį, prižiūrimesnį ir be klaidų kodą.