Minden, amit tudnia kell a C funkcióiról?

Ez a cikk egy egyszerű, mégis nagyon alapvető és fontos dolgot mutat be koncepció, amely a Funkciók a C-ben, és ezt követi egy bemutatóval. A következő hivatkozásokkal foglalkozunk ebben a cikkben,

• Mik a függvények a C-ben?
• A funkciók előnyei a C-ben
• Funkciótípusok C-ben
• Funkciónyilatkozat és meghatározás
• Funkció hívása
• A felhasználó által definiált funkciók típusai C-ben
• Nincs argumentum és nincs visszatérési érték
• Nincs argumentum, csak visszatérési érték
• Argumentum átadva, de nincs visszatérési érték
• Átadott argumentum és visszatérési érték
• C Könyvtári funkciók

A függvények bármely programozási nyelv építőelemei. Egyszerű szavakkal, függvény egy utasítássorozatban, amely bemeneteket vesz fel, végrehajt egy adott feladatot, majd visszaadja a kimenetet.
A funkció létrehozásának ideológiája az, hogy összekapcsolja a kapcsolódó állításokat, amelyek egy adott feladatot hajtanak végre. Így nem kell többször megírnia ugyanazt a kódot a különböző bemeneti halmazokhoz. Csak be kell hívnia a függvényt különböző bemenetekre, ez végrehajtja az adott bemenethez tartozó megadott feladatot és visszaadja a kimenetet. A funkciót annyiszor meghívhatja, ahányszor csak akarja. Ebben a blogban megismerjük a C programozási nyelv függvényeinek minden egyes árnyalatát.

Kezdjük a legalapvetőbb kérdéssel.

Mik a függvények a C-ben?

A függvények C-ben megegyeznek más programozási nyelvekkel. Ez egy kódkészlet, amely összekapcsolódik egy adott feladat végrehajtásához. A végrehajtandó kódkészlet göndör zárójelben van megadva, azaz „{}”.

Mielőtt megtanulnánk, hogyan kell C-ben írni egy függvényt, először értsük meg, mi az előnye.

A funkciók előnyei a C-ben

A funkciók előnyei az összes programozási nyelven közösek.
A funkció fő gondolata a redundancia csökkentése a kódban. Tegyük fel, hogy rendelkezik olyan funkcióval, amelyet többször kell végrehajtani egy programban, ezért ahelyett, hogy többször írná, létrehozhat egy függvényt ehhez a feladathoz, és annyiszor meghívhatja, ahányszor csak akarja. Egy másik rejtett előny, ha a funkciók logikája utána megváltozik, akkor nem kell folytatnia és több helyen változtatnia rajta. Csak egy helyen kell megváltoztatnia a kódot (vagyis a függvényben), és ez az egész programban megjelenik.

A modularitás ismét további előnyt jelent. Nagy kódrészlet, minden egyes elem és minden írásával csökkenti a kód olvashatóságát és megnehezíti a kezelését. A kódokat az egyes funkciók szakaszaiban oszthatja fel funkciók használatával, ami egyszerűbb megérteni és könnyebben kezelhető.

A Funkció absztrakciót is biztosít, ahol meghívhatunk egy függvényt és megszerezhetjük a kimenetet a belső megvalósítás ismerete nélkül.

Folytatás a C funkció típusaival

Funkciótípusok C-ben

Kétféle funkció létezik:
Könyvtári funkciók
Felhasználó által definiált funkciók

A könyvtári függvények azok a funkciók, amelyeket már meghatároztak a C könyvtárban, például strcat (), printf (), scanf () stb. Csak a fejlécfájlokat kell beillesztenie a funkciók használatához.
A felhasználó által definiált függvények azok a függvények, amelyeket a felhasználó határoz meg. Ezek a funkciók a kód újrafelhasználhatóságára, valamint az idő és a hely megtakarítására szolgálnak.

Most, hogy ismerjük a függvény létrehozásának előnyeit, értsük meg, hogyan lehet deklarálni a függvényt C-ben.

Funkciónyilatkozat és meghatározás

Funkciónyilatkozat:

A függvény-deklaráció szintaxisa:

return_type függvény_neve (data_type arg1, data_type arg2) int add (int x, int y) // függvény deklaráció

A Funkció deklarációban megadjuk a függvény nevét, a bemeneti paraméter számát, azok adattípusait és a függvény visszatérési típusát. A függvénydeklaráció elmondja a fordítónak az argumentumok listáját, amelyet a függvény vár, az adattípusaikkal és a függvény visszatérési típusával.

A függvénydeklarációban a paraméter nevének megadása nem kötelező, de az adattípusuk megadása kötelező.

int add (int, int) // függvénydeklaráció

A fent megadott függvény két egész paramétert vesz fel.

hogyan lehet kettősre konvertálni int

Funkció meghatározása

int add (int, int) // függvény deklaráció return_type függvény_név (paraméterek) {Function body}

Amint a fenti képen látható, a függvénydefiníció két részből áll, azaz a függvény fejlécéből és a függvény törzséből

Funkció fejléc: A függvény fejléce megegyezik a pontosvessző nélküli funkció deklarációjával. A függvény fejléce tartalmazza a függvény nevét, paraméterét és visszatérési típusát.

• Vissza típus: A visszatérés típusa annak az értéknek az adattípusa, amelyet a függvény visszaad. Lehet, hogy a függvény nem ad vissza értéket. Ha igen, akkor meg kell adni az újrabeszélési érték adattípusát, különben a visszatérési típust érvényteleníteni kell.

• Funkció neve: Ez a neve annak a függvénynek, amellyel hívhatjuk a függvényt, amikor és ahol szükséges.

• Paraméterek: A paraméterek azok a bemeneti értékek, amelyeket a függvény továbbít. Elmondja az argumentumok adattípusait, sorrendjét és a függvénynek továbbítandó argumentumok számát. A paraméterek nem kötelezőek. Paraméterek nélkül is rendelkezhet funkciókkal.

Funkciótest: A függvénytest az a utasításkészlet, amely egy adott feladatot hajt végre. Meghatározza, hogy a funkció mit csinál.

Példa:

int add (int x, int y) {int összeg = x + y visszatérés (összeg)}

Javasoljuk, hogy deklaráljon egy függvényt, mielőtt definiálnánk és használnánk. C-ben ugyanott deklarálhatjuk és definiálhatjuk a függvényt.

Példa:

#include int add (int, int) // függvénydeklaráció // függvénydefiníció int add (int x, int y) // függvény fejléc {// függvénytest int összeg = x + y visszatérés (összeg)} // Fő függvény int main () {int összeg = add (23, 31) printf ('% d', összeg) hozam 0}

Amint a fenti példában láthatjuk, hogy a függvényt int sum = add (23, 31) utasítással hívjuk meg. A függvényből kapott értéket az összegváltozó tárolja.

Mielőtt továbblépnénk, még egy fontos fogalmat kell megértenünk a paramentumról. Kétféle paraméter létezik:

Tényleges paraméter : Azok a paraméterek, amelyeket a függvényeknek átadnak hívás közben, tényleges paraméterként ismeretesek. Például a fenti példában a 23 és 31 a tényleges paraméterek.

Formális paraméter : A függvények által kapott paraméterek formális paraméterek. Például az x & y a fenti példában a formális paraméter.

Gyorsan haladjunk előre, és értsük meg a C függvény különböző módjainak hívását.

Funkció hívása

Kétféle módon hívhatunk függvényt:

• Hívás érték szerint
• Hívás referenciával

Hívás érték szerint

Hívás érték módszerrel a tényleges paraméter értékét argumentumként továbbítja a függvénynek. A tényleges paraméter értékét a formális paraméterek nem változtathatják meg.

A call be value módszerben különböző memóriacím kerül kiosztásra a formális és tényleges paraméterekhez. Csak a tényleges paraméter értéke másolódik a formális paraméterbe.

Példa:

parancssori argumentumok átadása java-ban

#include void Hívás_By_Value (int szám1) {num1 = 42 printf ('nBelső funkció, a szám% d', num1)} int main () {int szám num = 24 printf ('n Funkció előtt, Szám:% d', szám ) Call_By_Value (num) printf ('nA függvény után a szám% dn', szám) visszatér 0}

Kimenet

A fenti példában az értékenkénti függvény hívása előtt a num értéke 24. Ezután, ha meghívjuk a függvényt, átadjuk az értéket, és megváltoztatjuk a függvényen belül, akkor 42 lesz. a fő funkcióban a szám 24 lesz.

Hívás referenciával

Hivatkozás útján a tényleges paraméter memóriacímét argumentumként továbbítjuk a függvénynek. Itt a tényleges paraméter értéke megváltoztatható a formális paraméterrel.

Ugyanazt a memóriacímet használja a tényleges és a formális paraméter is. Tehát, ha a formális paraméter értéke módosul, akkor azt a tényleges paraméter is tükrözi.

A C-ben mutatókat használunk hivatkozás útján történő hívás végrehajtására. Amint az alábbi példában láthatja, a Call_By_Reference függvény egész számra mutató mutatót vár.

Ez a num1 változó tárolja a tényleges paraméter memória címét. Tehát a num1 által jelzett memória címben tárolt érték kinyomtatásához a dereference operátort, azaz * kell használnunk. Tehát a * num1 értéke 42.

A & címüzemeltetővel bármilyen adattípusú változó címét megkapjuk. Tehát a ‘Call_By_Reference (& num)’ függvényhívás utasításban a num címe átkerül, hogy a num a címe segítségével módosítható legyen.

Példa

#include // függvénydefiníció void Call_By_Reference (int * num1) {* num1 = 42 printf ('nInside Function, Number is% d', * num1)} // Main Function int main () {int num num = 24 printf ( 'nFunction előtt a szám% d', num) Call_By_Reference (& num) printf ('nFunction után a szám% dn', num) return 0}

Kimenet

Ebben a példában a num értéke kezdetben 24, a fő funkción belül. Miután átadta a Call_By_Reference függvénynek és az értéket a formális paraméter módosította, a tényleges paraméternél is megváltozott. Éppen ezért, amikor a num értékét a függvény után nyomtatjuk, akkor 42.

Folytatás a felhasználó által definiált függvénytípusokkal C-ben

A felhasználó által definiált típusok Funkció a C-ben

Különböző típusú felhasználó által definiált függvények léteznek a visszatérési típus és az átadott argumentumok alapján.

Továbblépés: Nincs argumentum és nincs visszatérési érték

1. Nincs argumentum és nincs visszatérési érték

Szintaxis:

függvény deklaráció:

void function () függvényhívás: function () függvénydefiníció: void function () {utasítások}

Példa

mysql bemutató kezdőknek példákkal

#include void add () void add () {int x = 20 int y = 30 int sum = x + y printf ('sum% d', sum)} int main () {add () return 0}

Továbbhaladva Nincs átadott argumentum, de visszatérési érték

2 Nem adunk át argumentumokat, csak egy visszatérési értéket

Szintaxis:

függvény deklaráció:

int függvény () függvényhívás: függvény () függvény meghatározása: int függvény () {utasítások visszatérnek a}

Példa:

#include int add () int add () {int x = 20 int y = 30 int összeg = x + y visszatérés (összeg)} int main () {int összeg összeg = add () printf ('összeg% d', összeg) hozam 0}

Továbbhaladva az elfogadott argumentumokkal, de nincs visszatérési érték

3 Argumentum átadva, de nincs visszatérési érték

Szintaxis:

függvény deklaráció:

void function (int) függvényhívás: function (a) függvénydefiníció: void function (int a) {utasítások}

Példa:

#include void add (int, int) void add (int x, int y) {int összeg = x + y visszatérés (összeg)} int main () {add (23, 31) return 0}

Továbblépés az átadott argumentummal és egy visszatérési értékkel

4 Megadott argumentum és visszatérési érték

Szintaxis:

függvény deklaráció:

int függvény (int) függvényhívás: függvény (a) függvény meghatározása: int függvény (int a) {utasítások visszatérnek a}

Példa

#include int add (int, int) int add (int x, int y) {int összeg = x + y visszatérés (összeg)} int main () {int összeg = add (23, 31) printf ('% d' , összeg) hozam 0}

Most nézzük meg gyorsan a C könyvtár funkcióit, amelyek fontosak egy program megírásához.

C Könyvtári funkciók

A könyvtári függvények olyan függvények a C-ben, amelyek előre definiáltak és alapértelmezés szerint jelen vannak. Csak be kell illesztenie az adott fejlécfájlt a programba, és használhatja az adott fejlécfájlban meghatározott funkciókat. Minden fejlécfájl meghatározott típusú funkciókat biztosít. A fejlécfájl kiterjesztése .h.

Például a printf / scanf függvények használatához be kell illesztenünk programunkba az stdio.h fájlt, amely a szabványos bemenet / kimenet funkcióit biztosítja.

Az alábbiakban felsoroljuk a fejlécfájlokat.

A fenti C függvények áttekintése után megértette volna a funkció minden egyes árnyalatát és a C nyelven történő megvalósításának módját. Remélem, hogy ez a blog informatív és hozzáadott értéket jelent Önnek.

Így a „Funkciók C-ben” című cikk végéhez érkeztünk. Ha többet szeretne megtudni, nézze meg a , egy megbízható online tanulási társaság. Az Edureka Java J2EE és SOA képzési és tanúsítási tanfolyamát arra tervezték, hogy mind az alapvető, mind a fejlett Java koncepciókra kiképezzen különféle Java keretrendszereket, például a Hibernate & Spring.

Van egy kérdésünk? Kérjük, említse meg a blog megjegyzés rovatában, és a lehető leghamarabb kapcsolatba lépünk Önnel.