Esittely:

C-ohjelmoinnissa a funktion prototyyppi käytetään ilmoittamaan allekirjoitus funktiosta, joka sisältää sen nimi, palautustyyppi , ja parametrit . Funktioiden prototyypit ovat tärkeitä, koska ne ilmoittavat kääntäjälle funktion käyttöliittymän ennen sen kutsumista, mikä mahdollistaa oikean tyyppitarkistuksen ja virheiden käsittelyn. Tässä artikkelissa keskustelemme funktioprototyyppien merkityksestä C-ohjelmoinnissa ja miten niitä käytetään.

Miksi käyttää funktioprototyyppejä?

Toimintojen prototyypit ovat tärkeitä C-ohjelmoinnissa useista syistä. Yksi tärkeimmistä syistä on, että ne sallivat kääntäjä tarkistaaksesi virheet ennen ohjelman suorittamista. Jos funktiota kutsutaan väärällä määrällä tai väärällä argumentilla, kääntäjä luo arvon virheviesti , joka estää ohjelmaa kaatumasta tai toimimasta odottamatta ajon aikana.

Toinen tärkeä syy toimintoprototyyppien käyttöön on modulaarisen ohjelmoinnin mahdollistaminen. C:ssä funktiot määritellään tyypillisesti pääohjelmasta erillisiin tiedostoihin ja linkitetään yhteen käännösvaiheessa. Ilmoittamalla funktion prototyypit otsikkotiedostoissa, jotka sisältyvät sekä pääohjelmaan että funktion määritystiedostoihin, funktiota voidaan kutsua mistä tahansa ohjelman osasta ilman, että vaaditaan pääsyä funktion toteutustietoihin.

Toimintojen prototyypit helpottaa myös koodin lukemista ja ymmärtämistä. Sisällyttämällä funktion allekirjoituksen lähdekoodiin muut kehittäjät näkevät helposti, mitä funktio tekee, sen argumentit ja palautustyypin. Se tekee koodista paremmin itsedokumentoivan ja vähentää virheiden todennäköisyyttä, jotka johtuvat koodin väärinkäsityksistä tai väärintulkinnoista.

zip-komento linuxissa

Funktioprototyypin syntaksi:

Funktioprototyypin syntaksi C-ohjelmoinnissa on seuraava:

 return_type function_name(parameter_list); 

The palautustyyppi on tietotyyppi, joka funktio palauttaa , kuten int, kellua , tai hiiltyä . The funktion_nimi on nimi toiminto , ja parametriluettelo on pilkuilla eroteltu luettelo parametrit jonka toiminto ottaa. Jokainen parametri parametriluettelo koostuu tietotyypistä, jota seuraa parametrin nimi .

Esimerkiksi seuraava on funktion prototyyppi funktiolle, joka vaatii kaksi kokonaislukuja argumentteina ja palauttaa niiden summan:

 int add(int num1, int num2); 

Tässä esimerkissä palautustyyppi on int , funktion nimi on lisätä , ja parametriluettelo koostuu kahdesta nimetystä kokonaisluvusta numero1 ja numero2 .

Oletustoimintojen prototyypit:

C-ohjelmoinnissa, jos funktiota kutsutaan ennen sitä määritelty tai julisti , kääntäjä olettaa oletusfunktion prototyypin. The oletustoiminnon prototyyppi olettaa, että funktio palauttaa an int ja ottaa minkä tahansa määrän minkä tahansa tyyppisiä argumentteja.

Harkitse esimerkiksi seuraavaa koodia:

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

Lähtö:

 The sum is 5 

Selitys:

Tässä koodissa lisää toiminto kutsutaan ennen sitä julisti tai määritelty . Koska kääntäjä kuitenkin olettaa oletusfunktion prototyypin, ohjelma kääntää ilman sitä virhe ja tuottaa oikean tuloksen.

Vaikka oletustoimintojen prototyypit ovat joskus käteviä, niitä ei yleensä suositella, koska ne voivat johtaa hienovaraisiin virheisiin. Paras käytäntö on ilmoittaa toimintojen prototyypit nimenomaisesti mahdollisten ongelmien välttämiseksi.

Toimintojen prototyypit ja otsikkotiedostot:

C-ohjelmoinnissa, toimintojen prototyyppejä sisällytetään usein otsikkotiedostoihin, jotka sitten sisältyvät sekä pääohjelmaan että funktionmääritystiedostoihin. Se mahdollistaa funktioiden kutsumisen mistä tahansa ohjelman osasta ilman, että vaaditaan pääsyä funktion toteutustietoihin.

Otsikkotiedostoissa on yleensä a .h laajennus ja sisältää vain toimintojen prototyyppejä , tyypin määritelmät , ja muut ilmoituksia joita pääohjelma tai muut tiedostot tarvitsevat. Tässä on esimerkki otsikkotiedostosta, joka ilmoittaa aiemman lisäystoiminnon:

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

Tässä esimerkissä ifndef direktiivi tarkistaa, onko ADD_H on jo määritelty. Jos ei ole, se määrittelee ADD_H ja lisää toiminnon prototyypin lisäämistä varten.

The määritellä direktiivi luo a makro nimetty ADD_H , jonka avulla voidaan varmistaa, että otsikkotiedosto sisällytetään vain kerran kuhunkin tiedostoon. On tärkeää estää useat saman funktion ilmoitukset, jotka voivat aiheuttaa virheitä. The funktion prototyyppi for add ilmoittaa yksinkertaisesti, että funktio ottaa kaksi kokonaislukua argumenteiksi ja palauttaa kokonaisluvun. Riittää, että pääohjelma ja muut tiedostot voivat kutsua lisäystoiminnon oikein tietämättä kuinka se on toteutettu.

Kun otsikkotiedosto sisältyy a C ohjelma , esiprosessori korvaa #sisältää direktiivin sisällön kanssa otsikkotiedosto . Sen avulla pääohjelma ja muut tiedostot voivat käyttää funktioprototyyppejä ja muita otsikkotiedoston ilmoituksia.

Joitakin tärkeitä kohtia funktion prototyypistä C:ssä:

Toimintojen prototyypit auttavat havaitsemaan virheet:

Kun funktion prototyyppi on mukana C-ohjelmassa, kääntäjä tarkistaa, että funktiota käytetään oikein ennen ohjelman suorittamista. Se auttaa havaitsemaan virheet varhaisessa vaiheessa ennen ohjelman suorittamista.

Toimintojen prototyypit ovat välttämättömiä suurissa ohjelmissa:

java ohjelmoinnin alkuluvut

Suurissa ohjelmissa on tärkeää erottaa huolenaiheet eri toimintojen välillä selvästi. Toimintojen prototyypit mahdollistavat tämän erottamisen mahdollistamalla kunkin toiminnon kehittämisen itsenäisesti ilman, että tiedät muiden toimintojen toteutusyksityiskohtia.

Toimintojen prototyypit voidaan ilmoittaa otsikkotiedostoissa:

Kuten aiemmin mainittiin, funktion prototyypit ilmoitetaan tyypillisesti otsikkotiedostoissa. Otsikkotiedostot sisällytetään sitten sekä pääohjelmaan että funktionmääritystiedostoihin, jolloin funktiot ovat käytettävissä mistä tahansa ohjelman osasta.

Toimintojen prototyypit voivat ylikuormittua:

C ei tue funktion ylikuormitusta kuten jotkin muut ohjelmointikielet, mutta funktion prototyyppejä voidaan ylikuormittaa käyttämällä erilaisia ​​argumenttityyppejä ja numeroita. Se mahdollistaa saman funktion nimen käytön eri tarkoituksiin.

Funktioiden prototyypit voivat sisältää oletusargumentteja:

C ei tue oletusargumentteja kuten jotkut muut ohjelmointikielet, mutta funktion prototyypit voivat sisältää valinnaisia ​​argumentteja käyttämällä erityistä syntaksia. Se mahdollistaa saman funktion käytön tiettyjen argumenttien kanssa tai ilman niitä.

Toimintojen prototyypit voidaan ilmoittaa eteenpäin:

Joissakin tapauksissa voi olla tarpeen ilmoittaa funktion prototyyppi ennen kuin sen toteutus on saatavilla. Sitä kutsutaan ilmoitus eteenpäin ja se voi olla hyödyllinen monimutkaisissa ohjelmissa, joissa funktion toteutusta ei ehkä tiedetä sen ilmoittamishetkellä.

Tässä on vielä muutama esimerkki C-ohjelmoinnin funktioprototyypeistä:

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

Selitys:

käy kassalla

Tässä esimerkissä julistamme ensin laske_keskiarvo funktion prototyyppi ohjelmamme alussa ennen päätoimintoa. Sen jälkeen julistamme pääfunktion sisällä kokonaislukutaulukon arr joillain arvoilla ja koolla 5 . Sen jälkeen soitamme n laske_keskiarvo-funktio , kulkee sisään arr array ja sen koko ja tallenna tulos a kelluva muuttuja nimetty keskiverto . Lopuksi tulostamme tuloksen printf:llä.

The laske_keskiarvo funktio ottaa kokonaisluvun array arr ja sen koon argumentteina ja palauttaa taulukon keskiarvon muodossa a kellua . Ilmoitamme ensin float-muuttujan nimeltä summa funktion sisällä ja alusta se 0,0 . Tämän jälkeen käymme läpi jokaisen taulukon elementin käyttämällä a silmukalle , lisäämällä jokaisen elementin summamuuttujaan. Lopuksi palautetaan tulos jakamalla summamuuttuja taulukon koolla.

Sen keskiarvo on 3.00 koska arr matriisi sisältää arvot {1, 2, 3, 4, 5} , ja näiden arvojen keskiarvo on (1+2+3+4+5)/5 = 3,00 . The printf lauseke pääfunktiossa käyttää %f muotomäärittäjä tulostaa keskiarvon liukulukuna. The .2 muuntaja määrittää, että haluamme tulostaa vain kaksi desimaalin tarkkuutta.

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

Lähtö:

 Hello, world! 

Selitys:

Tässä esimerkissä julistamme ensin print_message funktion prototyyppi ohjelmamme alussa, ennen päätoimintoa. Sitten pääfunktion sisällä julistamme merkkiosoittimen viesti ja alusta se osoittamaan merkkijonoliteraaliin 'Hei maailma!' . Sen jälkeen soitamme n print_message toiminto, kulkee sisään viesti osoitin .

The print_message toiminto ottaa merkkiosoittimen viesti argumenttina, eikä palauta mitään (tyhjä) . Käytämme funktion sisällä printf-toiminto tulostaaksesi merkkijonon, johon osoitti viesti , jota seuraa a rivinvaihtomerkki ( ) . The %s muotomääritystä käytetään merkkijonon tulostamiseen.

Lähtö on Hei maailma! . Koska print_message toiminto tulostaa merkkijonon, johon viesti osoitin , mikä tässä tapauksessa on 'Hei maailma!' , jota seuraa rivinvaihtomerkki.

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

Selitys:

Tässä esimerkissä julistamme ensin tekijäfunktio prototyyppi ohjelmamme alussa, ennen päätoimintoa. Sitten pääfunktion sisällä julistamme kokonaislukumuuttujan n ja alusta se 5 . Tämän jälkeen kutsumme tekijäfunktiota, joka kulkee sisään n , ja tallenna tulos kokonaislukumuuttujaan nimeltä tulos . Lopuksi tulostamme tuloksen käyttämällä printf .

Tekijäfunktio ottaa kokonaisluvun n argumenttina ja palauttaa faktoriaalinsa an kokonaisluku . Toiminnon sisällä tarkistamme ensin, onko n on yhtä suuri kuin 0 . Jos on, palaamme takaisin 1 , siitä asti kun 0! = 1 määritelmän mukaan. Muuten palaamme n * tekijä(n-1) , joka on tekijä n lasketaan rekursiivisesti tuotteena n ja faktoriaali n-1 .

Koodin tulos on:

java int merkkijonoon

 5! = 120 

Tämä johtuu siitä, tekijäfunktio laskee 5! kuten 5 * 4 * 3 * 2 * 1 = 120 , ja tämä tulos tulostetaan käyttämällä printf .

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

Selitys:

Tässä esimerkissä julistamme ensin find_max funktion prototyyppi ohjelmamme alussa, ennen päätoimintoa. Sitten pääfunktion sisällä julistamme kokonaisluvun array arr ja alusta se joillakin arvoilla ja muuttujakoolla, joka tallentaa taulukon koon. Sen jälkeen soitamme n find_max-funktio , kulkee sisään arr array ja koko , ja tallenna tulos kokonaislukumuuttujaan nimeltä max . Lopuksi tulostamme tuloksen käyttämällä printf .

The find_max-funktio ottaa kokonaislukutaulukon arr ja sen koko koko argumentteina ja palauttaa taulukon enimmäisarvon kokonaislukuna. Toiminnon sisällä alustetaan ensin muuttuja max taulukon arr ensimmäisellä elementillä. Tämän jälkeen teemme silmukan taulukon jäljellä olevien elementtien yli käyttämällä for-silmukkaa, vertaamalla jokaista elementtiä nykyiseen maksimiarvoon if-käskyn avulla. Jos nykyinen elementti on suurempi kuin nykyinen maksimi, päivitämme max nykyisen elementin arvoon. Kun silmukka on päättynyt, palautamme lopullisen arvon max.

The ulostulo koodista tulee:

 The maximum value in the array is: 8 

Tämä johtuu siitä, find_max funktio etsii taulukon läpi {3, 5, 2, 8, 1} ja huomaa, että suurin arvo on 8 , joka tulostetaan sitten käyttämällä printf .

Kaiken kaikkiaan toimintoprototyypit ovat olennainen osa C-ohjelmointia, joka mahdollistaa modulaarinen ohjelmointi , tyypin tarkistus , virheiden käsittely , ja itsedokumentoiva koodi . Ilmoittamalla toimintoprototyyppejä kehittäjät voivat kirjoittaa kestävämpää, ylläpidettävämpää ja virheettömämpää koodia.

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

Selitys:

Tässä esimerkissä julistamme ensin greet_user-funktio prototyyppi ohjelmamme alussa, ennen päätoimintoa. Sitten pääfunktion sisällä määritetään merkkijonon nimi, jonka koko on viisikymmentä , ja käytä printf ja scanf kysyä käyttäjältä hänen nimeään ja lukea se nimitaulukkoon. Sen jälkeen soitamme n greet_user-funktio , välittää nimitaulukon argumenttina.

The greet_user-funktio ottaa merkin osoittimen nimen argumenttina, joka on osoitin merkkijonon ensimmäiseen merkkiin. Toiminnon sisällä käytämme printf tulostaa tervehdysviestin, joka sisältää käyttäjän nimen, ja ystävällisen viestin.

Koodin tulos riippuu käyttäjän syötteestä. Tässä on esimerkki siitä, miltä tulos saattaa näyttää:

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

Tässä tapauksessa käyttäjä syöttää nimen 'sumam' , ja ohjelma tulostaa tervehdysviestin, joka sisältää heidän nimensä.

Johtopäätös:

Toimintojen prototyypit ovat tärkeä osa C-ohjelmointia, mikä mahdollistaa modulaarisen ohjelmoinnin, virheentarkistuksen ja itsedokumentoinnin. Ilmoittamalla funktion allekirjoituksen ennen sen kutsumista funktion prototyypit antavat kääntäjälle mahdollisuuden tarkistaa virheet, mahdollistaa modulaarisen ohjelmoinnin ja helpottaa koodin lukemista ja ymmärtämistä.

C-ohjelmointiin sisältyy tyypillisesti funktioprototyyppejä otsikkotiedostot , jotka sisältyvät sitten sekä pääohjelmaan että funktionmääritystiedostoihin. Sen avulla funktioita voidaan kutsua mistä tahansa ohjelman osasta ilman, että vaaditaan pääsyä toiminnon toteutustietoihin. Ymmärtämällä funktioprototyyppien tärkeyden ja sen, kuinka niitä käytetään C-ohjelmoinnissa, kehittäjät voivat kirjoittaa kestävämpää, ylläpidettävämpää ja virheettömämpää koodia.