C-ohjelmoinnin toiminnot esimerkein: Rekursiivinen & Inline

Mikä on funktio C:ssä?

Toiminto C-ohjelmoinnissa on uudelleenkäytettävä koodilohko, jonka avulla ohjelma on helpompi ymmärtää, testata ja sitä voidaan helposti muokata muuttamatta kutsuvaa ohjelmaa. Toiminnot jakavat koodin ja moduloivat ohjelman parempien ja tehokkaampien tulosten saavuttamiseksi. Lyhyesti sanottuna suurempi ohjelma on jaettu useisiin aliohjelmiin, joita kutsutaan funktioiksi

Kun jaat suuren ohjelman useisiin toimintoihin, on helppoa hallita jokaista toimintoa erikseen. Aina kun ohjelmassa tapahtuu virhe, voit helposti tutkia vialliset toiminnot ja korjata vain ne virheet. Voit helposti soittaa ja käyttää toimintoja aina kun niitä tarvitaan, mikä säästää automaattisesti aikaa ja tilaa.

Kirjasto vs. Käyttäjän määrittämät toiminnot

Jokaisessa C-ohjelmassa on ainakin yksi funktio, joka on päätoiminto, mutta ohjelmalla voi olla mikä tahansa määrä toimintoja. C:n pääfunktio () on ohjelman aloituspiste.

C-ohjelmoinnissa funktiot jaetaan kahteen tyyppiin:

Kirjaston toiminnot
Käyttäjän määrittämät toiminnot

Ero kirjaston ja käyttäjän määrittämien funktioiden välillä C:ssä on, että meidän ei tarvitse kirjoittaa koodia kirjastofunktiolle. Se on jo olemassa otsikkotiedostossa, jonka sisällytämme aina ohjelman alkuun. Sinun tarvitsee vain kirjoittaa funktion nimi ja käyttää sitä oikean syntaksin kanssa. Printf, scanf ovat esimerkkejä kirjastotoiminnoista.

Sen sijaan käyttäjän määrittämä funktio on eräänlainen funktio, jossa meidän on kirjoitettava funktion runko ja kutsuttava funktiota aina, kun vaadimme funktiota suorittamaan jonkin toiminnon ohjelmassamme.

Käyttäjän määrittämä funktio C:ssä on aina käyttäjän kirjoittama, mutta myöhemmin se voi olla osa 'C'-kirjastoa. Se on C-ohjelmoinnin suuri etu.

C-ohjelmointitoiminnot on jaettu kolmeen toimintoon, kuten

Toimintoilmoitus
Toiminnon määritelmä
Toimintakutsu

Toimintoilmoitus

Funktiomäärittely tarkoittaa ohjelman nimen kirjoittamista. Se on pakollinen osa funktioiden käyttöä koodissa. Funktiomäärityksessä määritämme vain funktion nimen, jota aiomme käyttää ohjelmassamme muuttujan ilmoituksen tavoin. Emme voi käyttää funktiota, ellei sitä ole ilmoitettu ohjelmassa. Funktioilmoitusta kutsutaan myös nimellä "Function prototyyppi"

Funktioilmoitukset (kutsutaan prototyypiksi) tehdään yleensä pääfunktion () yläpuolelle ja ovat yleisessä muodossa:

return_data_type function_name (data_type arguments);

- paluutietotyyppi: on kutsuvaan lauseeseen palautetun arvofunktion tietotyyppi.
- funktion_nimi: seuraa sulkeet
argumentit nimet ja niiden tietotyyppimääritykset sijoitetaan valinnaisesti sulkeisiin.

Tarkastellaan seuraavaa ohjelmaa, joka näyttää kuinka kuutiofunktio määritellään kokonaislukumuuttujan kuutioarvon laskemiseksi

#include <stdio.h>
/*Function declaration*/
int add(int a,b);
/*End of Function declaration*/
int main() {

Muista, että funktio ei välttämättä palauta arvoa. Tässä tapauksessa käytetään avainsanaa void.

Esimerkiksi funktion output_message ilmoitus osoittaa, että funktio ei palauta arvoa: void output_message();

Toiminnon määritelmä

Funktiomäärittely tarkoittaa vain funktion rungon kirjoittamista. Toiminnon runko koostuu lauseista, jotka suorittavat tietyn tehtävän. Funktiorunko koostuu yhdestä lauseesta tai lausekkeesta. Se on myös pakollinen osa toimintoa.

int add(int a,int b)	//function body	
{
	int c;
	c=a+b;
	return c;
}

Toimintakutsu

Funktiokutsu tarkoittaa funktion kutsumista aina, kun sitä vaaditaan ohjelmassa. Aina kun kutsumme funktiota, se suorittaa toiminnon, jota varten se on suunniteltu. Funktiokutsu on valinnainen osa ohjelmaa.

  result = add(4,5);

Tässä on täydellinen koodi:

#include <stdio.h>
int add(int a, int b);	//function declaration
int main()
{
	int a=10,b=20;
	int c=add(10,20); 	//function call
	printf("Addition:%d\n",c);
	getch();
}
int add(int a,int b)	//function body
{
	int c;
	c=a+b;
	return c;
}

lähtö:

Addition:30

Funktion argumentit

Funktion argumentteja käytetään tarvittavien arvojen vastaanottamiseen funktiokutsulla. Ne ovat yhteensopivia sijainnin mukaan; ensimmäinen argumentti välitetään ensimmäiselle parametrille, toinen toiselle parametrille ja niin edelleen.

Oletusarvoisesti argumentit välitetään arvon mukaan jossa kopio tiedoista annetaan kutsutulle funktiolle. Todellisuudessa välitetty muuttuja ei muutu.

Tarkastelemme seuraavaa ohjelmaa, joka näyttää arvon kautta välitetyt parametrit:

int add (int x, int y); 
int main() {
  int a, b, result;
  a = 5;
  b = 10;
  result = add(a, b);
  printf("%d + %d\ = %d\n", a, b, result);
return 0;}
int add (int x, int y) { 
x += y;
  return(x);}

Ohjelman tulos on:

5 + 10 = 15

Muista, että a:n ja b:n arvoja välitettiin lisätoimintoon, koska sitä ei muutettu, koska vain sen arvo välitettiin parametriin x.

Vaihteleva soveltamisala

Muuttujan laajuus tarkoittaa muuttujien näkyvyyttä ohjelman koodissa.

C:ssä funktion sisällä ilmoitetut muuttujat ovat paikallisia kyseiselle koodilohkolle, eikä niihin voi viitata funktion ulkopuolella. Kaikkien funktioiden ulkopuolelle ilmoitetut muuttujat ovat kuitenkin globaaleja ja niihin pääsee käsiksi koko ohjelmasta. Vakiot, jotka on ilmoitettu a:lla #määritellä ohjelman yläosassa ovat käytettävissä koko ohjelmasta. Tarkastellaan seuraavaa ohjelmaa, joka tulostaa globaalin muuttujan arvon sekä pää- että käyttäjän määrittämästä funktiosta:

#include <stdio.h>
int global = 1348;
void test();
int main() {
  printf("from the main function : global =%d \n", global);
  test () ;
return 0;}

void test (){
printf("from user defined function : global =%d \n", global);}

Tulos:

from the main function : global =1348
from user defined function : global =1348

Keskustelemme ohjelman yksityiskohdista:

Ilmoitamme kokonaisluvun globaalin muuttujan, jonka alkuarvo on 1348.
Ilmoitamme ja määritämme test()-funktion, joka ei ota argumentteja eikä palauta arvoa. Tämä toiminto tulostaa vain globaalin muuttujan arvon osoittaakseen, että globaaleihin muuttujiin pääsee käsiksi missä tahansa ohjelmassa.
Tulostamme globaalin muuttujan pääfunktion sisällä.
Kutsumme testifunktiota globaalin muuttujan arvon tulostamiseksi.

C:ssä, kun argumentteja välitetään funktion parametreille, parametrit toimivat paikallisina muuttujina, jotka tuhoutuvat funktiosta poistuttaessa.

Kun käytät globaalit muuttujat, käytä niitä varoen, koska ne voivat johtaa virheisiin ja ne voivat muuttua missä tahansa ohjelmassa. Ne tulee alustaa ennen käyttöä.

Staattiset muuttujat

Staattisilla muuttujilla on paikallinen laajuus. Ne eivät kuitenkaan tuhoudu toiminnosta poistuttaessa. Siksi staattinen muuttuja säilyttää arvonsa ikuisesti ja sitä voidaan käyttää, kun funktio syötetään uudelleen. Staattinen muuttuja alustetaan, kun se ilmoitetaan, ja se tarvitsee etuliitettä staattinen.

Seuraava ohjelma käyttää staattista muuttujaa:

#include <stdio.h>
void say_hi();
int main() {    
  int i;
  for (i = 0; i < 5; i++) { say_hi();}
   return 0;}
void say_hi() {
  static int calls_number = 1;
  printf("Hi number %d\n", calls_number);
  calls_number ++; }

Ohjelma näyttää:

Hi number 1
Hi number 2
Hi number 3
Hi number 4
Hi number 5

Rekursiiviset toiminnot

Harkitse luvun tekijää, joka lasketaan seuraavasti 6! =6*5*4*3*2*1.

Tämä laskutoimitus suoritetaan toistuvasti laskemalla tosiasia * (fakta -1), kunnes tosiasia on yhtä kuin 1.

Rekursiivinen funktio on toiminto, joka kutsuu itseään ja sisältää poistumisehdon rekursiivisten kutsujen lopettamiseksi. Tekijälukulaskelman tapauksessa poistumisehto on tosiasia, joka on yhtä suuri kuin 1. Rekursio toimii "pinoamalla" kutsuja, kunnes poistumisehto on tosi.

Esimerkiksi:

#include <stdio.h>
int factorial(int number);
int main() {    
  int x = 6;
  printf("The factorial of %d is %d\n", x, factorial(x)); 
  return 0;}
int factorial(int number) {
 if (number == 1)    return (1); /* exiting condition */
  else
    return (number * factorial(number - 1));
}

Ohjelma näyttää:

 The factorial of 6 is 720

Täällä keskustelemme ohjelman yksityiskohdista:

Ilmoitamme rekursiivisen tekijäfunktiomme, joka ottaa kokonaislukuparametrin ja palauttaa tämän parametrin kertoimen. Tämä toiminto kutsuu itseään ja pienentää numeroa, kunnes poistuminen tai perusehto saavutetaan. Kun ehto on tosi, aiemmin luodut arvot kerrotaan keskenään ja lopullinen tekijäarvo palautetaan.
Ilmoitamme ja alustamme kokonaislukumuuttujan arvolla ”6″ ja tulostamme sitten sen kertoimen arvon kutsumalla tekijäfunktiota.

Tarkastellaan seuraavaa kaaviota ymmärtääksesi paremmin rekursiivista mekanismia, joka koostuu funktion kutsumisesta itsestään, kunnes perustapaus tai pysäytysehto saavutetaan, ja sen jälkeen keräämme edelliset arvot:

Sisäiset toiminnot

C-ohjelmoinnin funktiota käytetään tallentamaan useimmin käytetyt käskyt. Sitä käytetään ohjelman modulointiin.

Aina kun funktiota kutsutaan, käskyosoitin hyppää funktion määritelmään. Toiminnon suorittamisen jälkeen käskyosoitin putoaa takaisin lauseeseen, josta se hyppäsi funktion määritelmään.

Aina kun käytämme toimintoja, vaadimme ylimääräistä osoitin siirry funktion määritelmään ja palaa lauseeseen. Käytämme sisäisiä toimintoja poistaaksemme tällaisten osoitinpäiden tarpeen.

Inline-funktiossa funktiokutsu korvataan suoraan todellisella ohjelmakoodilla. Se ei hyppää mihinkään lohkoon, koska kaikki toiminnot suoritetaan rivifunktion sisällä.

Inline-funktioita käytetään enimmäkseen pieniin laskelmiin. Ne eivät sovellu suuriin tietokoneisiin.

Inline-funktio on samanlainen kuin tavallinen funktio, paitsi että avainsanan teksti on ennen funktion nimeä. Sisäiset funktiot luodaan seuraavalla syntaksilla:

inline function_name ()
{
    //function definition
}

Kirjoitetaan ohjelma inline-funktion toteuttamiseksi.

inline int add(int a, int b)		//inline function declaration
{
	return(a+b);
}
int main()
{
	int c=add(10,20);
	printf("Addition:%d\n",c);
	getch();
}