Bevezetés a C függvényekbe

Lehet, hogy egyszerű példákkal foglalkozott az alapvető C szintaxissal, és most azon töpreng, hogyan hozzon létre nagyobb, valós programokat. Kezdetben érdemes a kódot hatékony részekre rendezni, minimális ismétlés mellett. A C nyelvben, mint a legtöbb nyelvben, a probléma megoldása a függvény.

A függvények létrehozása és használata C nyelven egyszerű, és számos előnnyel jár. A funkciók lehetővé teszik az összetett programok kisebb részekre bontását. Újrafelhasználhatóságot biztosítanak mind az eredeti programon belül, mind a kapcsolódó könyvtárakban vagy más különálló programokban.

A kezdéshez meg kell tanulnia a függvénydeklarációkat, a prototípusokat, a paramétereket és a return utasításokat.

Mik a függvények C-ben?

C programozásban, a függvény a kód egy elnevezett szakasza, amely végrehajt valamit, amikor Ön kéri. Segít rendszerezetten tartani a kódot, és lehetővé teszi ugyanazt a műveletet többször is anélkül, hogy megismételné magát.

A legegyszerűbb példa az, amelyet már használt: a main() függvény. A fő funkció különösen különleges, mert minden C program fő belépési pontjaként működik. Használhat olyan könyvtári függvényeket is, amelyeket valaki más már írt, vagy írhat saját, felhasználó által definiált függvényeket.

Funkciók: Deklaráció, Meghatározás és Hívás

Ez a három szempont alapvető a függvények használatában.

Funkciónyilatkozat

Ez információt nyújt a függvény nevéről, visszatérési típusáról és paramétereiről, lehetővé téve a funkció használatát a teljes definíció előtt. Funkció prototípusnak is nevezik. Ezt az egyszerű szintaxist követi:

return_type function_name(parameters);

Ahol:

• return_type a függvény által visszaadott érték adattípusa. Lehet bármilyen érvényes C adattípus ill üres ha a függvény nem ad vissza értéket.
• függvény_neve az a név, amelyet a függvénynek adsz. Ezzel később meghívhatja a függvényt.
• paramétereket a függvény által elfogadott bemeneti paraméterek listája, ha vannak ilyenek. Minden paraméter egy adattípusból áll, amelyet egy paraméternév követ vesszővel elválasztva.

Például itt van egy egyszerű függvénydeklaráció:

intadd(int a, int b);

Funkció meghatározása

Amikor meghív egy függvényt, az a definíciójában megadott kódot futtatja. Tartalmazza a függvény nevét, visszatérési típusát, paraméterlistáját és a működését meghatározó utasításokat. Íme a szintaxis:

return_type function_name(parameters){
// Function body - code that defines what the function does
// Return a value if applicable
return value;
}

Bontsuk fel a szintaxis részeit:

Funkciótest: Ez a kapcsos zárójelek közé zárt kódblokk {}. Tartalmazza azokat az utasításokat, amelyek meghatározzák, hogy a függvény mit csináljon, amikor meghívásra kerül.

Visszáru nyilatkozat: Ha a függvénynek más visszatérési típusa van, mint üres, a Visszatérés utasítás értéket küld vissza a hívónak. Ennek az értéknek meg kell egyeznie a megadott visszatérési típussal.

Íme egy egyszerű példa egy függvénydefinícióra:

intadd(int a, int b){
int sum = a + b;
return sum;
}

Funkcióhívás

Csakúgy, mint a főzéshez, előfordulhat, hogy receptje (a funkció meghatározása) és néhány összetevője (érvei) van, de az eredmény eléréséhez továbbra is követnie kell az utasításokat. A függvényhívás adott argumentumokkal futtatja a függvényt; itt a szintaxis:

return_type result = function_name(arguments);

érvek: Ezek azok az értékek vagy kifejezések, amelyeket bemenetként ad át a függvénynek. Az egyes argumentumokat vesszővel válassza el. Az argumentumok számának, sorrendjének és adattípusának meg kell egyeznie a függvény paraméterlistájával.

eredmény: Ha a függvénynek más visszatérési típusa van, mint üres, a visszaadott értéket a megfelelő adattípusú változó segítségével rögzítheti.

Íme egy példa egy függvényhívásra:

#include
// Function prototype
intadd(int a, int b);
intmain(){
int x = 5, y = 3;
// Call the function and store the result in 'sum'
int sum = add(x, y);
printf("The sum of %d and %d is %d\n", x, y, sum);
return0;
}
// Function definition
intadd(int a, int b){
return a + b;
}

Ezt a három lépést követve – a függvény deklarálása, megvalósításának biztosítása és meghívása megfelelő érvekkel – hatékonyan használhatja a függvényeket különféle feladatok végrehajtására program.

Funkcióparaméterek és visszatérési értékek

A paraméterek a függvény deklarációjában vagy definíciójában deklarált változók, amelyek híváskor a függvénynek átadott értékek helyőrzőiként működnek. Lehetővé teszik az adatok átadását a függvénynek, lehetővé téve az adatok kezelését és kezelését. A visszatérési értékek azok az értékek, amelyeket egy függvény előállít, és visszaküld a hívónak.

A paraméterek átadásának két módja van.

Pass by Value

Ezzel a megközelítéssel a függvényhívás bemásolja az aktuális argumentum értékét a függvény paraméterébe. A függvényen belül a paraméterben végrehajtott változtatások nem befolyásolják az eredeti argumentumot.

Például:

#include
intsquare(int num){
 num = num * num;
return num;
}
intmain(){
int x = 5;
int y = square(x);
// Output: x and y after function call: 5 25
printf("x and y after function call: %d %d\n", x, y);
return0;
}

• A négyzetfüggvény egy egész szám paramétert vesz fel, sz.
• A négyzetfüggvény kiszámítja a szám négyzetét, frissíti az értékét, és visszaadja ezt az új értéket.
• A fő függvény egy egész változót deklarál, x, és 5 értéket rendel hozzá.
• Ezután meghívja a négyzetfüggvényt, átadva neki x értékét. Az eredményt egy második változóhoz rendeli, y.
• A függvényhívás után a main kiírja x és y értékét. Az x érték változatlan marad, mert a négyzeten belüli num paraméter megváltoztatása nem befolyásolja az eredeti x-et.

Pass by Reference

Ezzel a megközelítéssel átadja egy érték memóriacímét (mutatóját) egy függvénynek. A függvényen belüli paraméterben végrehajtott változtatások a függvényen kívüli eredeti értéket érintik.

A mutatók, beleértve azok paraméterként való használatát, az egyik szempont C, amelyek különböznek egy olyan nyelvtől, mint a Python.

#include
voidsquare(int *num){
 *num = *num * *num;
}
intmain(){
int x = 5;
 square(&x);
// Output: x after function call: 25
printf("x after function call: %d\n", x);
return0;
}

• A négyzet függvény egy egész mutatót vesz fel (int *) paraméter, sz. Nem ad vissza értéket.
• A négyzetfüggvény kiszámítja annak az értéknek a négyzetét, amely sz tartalmazza és frissíti ezt az értéket a mutató hivatkozási operátorával, *.
• A fő- függvény egész változót deklarál, x, és hozzárendeli az értéket 5.
• Ezután hívja a négyzet függvényt egy mutatóval x az operátor címének használatával: &x.
• A függvényhívás után a main kiírja az értékét x, ami most van 25 a változások óta *szám benne négyzet funkció befolyásolja az eredetit x.

Összefoglalva, a fő különbség a két módszer között az, hogy a függvényen belüli paraméter változtatásai hogyan befolyásolják a függvényen kívüli eredeti értéket. Az érték átadása másolatot hoz létre, míg az átadás hivatkozással (mutató) lehetővé teszi az eredeti érték közvetlen manipulálását.

Más nyelvek gyakran rendelkeznek a C mutatóinak megfelelővel, de általában magasabb szinten működnek. Az egyik példa az A C# támogatja az out változókat.

Üres funkciók

Az üres függvények a C programozásban olyan függvények, amelyek nem adnak vissza értéket. Használja őket műveletek vagy feladatok végrehajtására eredmény nélkül. Megváltoztathatják a paramétereiket a pass by reference használatával, de nem kell.

Íme egy példa egy üres függvényre:

#include
// Void function with no parameters
voidgreet(){
printf("Hello, MUO!");
}
intmain(){
// Call the void function, output: "Hello, MUO!"
 greet();
return0;
}

Az érvénytelen funkciók hasznosak műveletek végrehajtásához, üzenetek nyomtatásához, adatok módosításához vagy feladatok végrehajtásához visszatérési érték nélkül.

Fedezze fel a C programozás funkcióit

A függvények létrehozásán keresztüli gyakorlás javítja a C programozás megértésének és alkalmazásának megértését. Ezenkívül javítja a kód olvashatóságát és megkönnyíti a karbantartást. Merüljön el a funkciók különféle alkalmazásaiban, hogy kiaknázhassa előnyeiket.

Ha elsajátította a C függvények alapjait, és kihívást szeretne tenni önmagának, fontolja meg a rekurzióval való elmélyülést.