C++ Funkciók programpéldákkal

⚡ Okos összefoglaló

Funkciók be C++ A kapcsolódó utasításokat újrafelhasználható, elnevezett blokkokba csoportosítja, amelyek bemenetet fogadnak, feldolgozzák azt és kimenetet adnak vissza. A programok beépített könyvtári függvényeket és felhasználó által definiált függvényeket kombinálnak, mindegyiket deklarálják, definiálják és meghívják, hogy elkerüljék a kód ismétlődését.

  • 🧩 Ami: Egy függvény olyan utasításokat csoportosít, amelyek paramétereket fogadnak, feldolgozzák azokat és értéket adnak vissza, így egy közös feladatot futtatva egyetlen blokkból.
  • ???? Beépített függvények: Az C++ A standard könyvtár olyan kész függvényeket tartalmaz, mint az sqrt(), amelyeket közvetlenül meghívhatsz anélkül, hogy megírnád őket.
  • 🇧🇷 Felhasználó által definiált függvények: A programozók létrehozzák a saját függvényeiket, egyedi nevet adnak nekik, és ezt a kódot a program bármely pontjáról meghívják.
  • 📝 Nyilatkozat és definíció: Egy prototípus deklarálja a visszatérési típust, a nevet és az argumentumtípust; a definíció adja meg a függvény törzsét.
  • 📞 Hívás és argumentumok: Egy függvény meghívásakor lefuttatjuk a függvény törzsét; az argumentumoknak szám és típus szerint kell megegyezniük a paraméterekkel, és az alapértelmezett értékek megengedettek.
  • 🤖 AI segítség: GitHub Copilot és hasonló asszisztensek állványzata C++ függvényszignatúrák, törzsek és hívások egy rövid megjegyzésből.

C++ Funkciók

Miben van egy funkció C++?

Egy funkció benne C++ utasítások egy csoportjára utal, amely bemenetet vesz, feldolgoz, és kimenetet ad vissza. A funkciók mögött meghúzódó ötlet az, hogy egyesítse az ismétlődő közös feladatokat. Ha különböző bemenetek vannak, akkor nem írja be újra ugyanazt a kódot. Egyszerűen hívja meg a függvényt egy másik, paramétereknek nevezett adatkészlettel.

Minden C++ programnak van legalább egy függvénye, a main() függvény. A kódot különböző függvényekre oszthatja fel. Ennek a felosztásnak olyannak kell lennie, hogy minden függvény egy adott feladatot lát el.

Számos beépített funkció található a C++ szabványos könyvtár. Ezeket a függvényeket meghívhatja a programon belül.

Miért használjunk függvényeket?

A funkciók használatának számos előnye van. Ezek tartalmazzák:

  • Minden függvény összerakja a kapcsolódó kódot. Ez megkönnyíti a programozók számára a kód megértését.
  • A funkciók megkönnyítik a programozást a kódismétlés kiküszöbölésével.
  • A funkciók megkönnyítik a kód újrafelhasználását. Ugyanazt a függvényt meghívhatja egy feladat végrehajtásához a program különböző szakaszaiban, vagy akár a programon kívül is.

Beépített funkciók

In C++, a könyvtári függvények beépítettek C++ funkciókat. Ezeknek a függvényeknek a használatához egyszerűen meg kell hívnia őket közvetlenül. Nem kell saját kezűleg megírnia a függvényeket.

Példa 1:

#include <iostream>
#include <cmath>
using namespace std;
int main() {
	double num, squareRoot;
	cout << "Enter number: ";
	cin >> num;
	squareRoot = sqrt(num);
	cout << "The square root of " << num << " is: " << squareRoot;
	return 0;
}

output:

Kimenet a C++ beépített sqrt() függvény példa

Itt van egy képernyőkép a kódról:

C++ kód, ami meghívja a cmath beépített sqrt() függvényét

Code Magyarázat:

  1. Szerelje be az iostream fejlécfájlt a programunkba a funkcióinak használatához.
  2. Tartalmazza a cmath könyvtárat a funkcióinak használatához. A benne definiált sqrt() függvényt szeretnénk használni.
  3. Szerelje be az std névteret a kódunkba, hogy az osztályait hívás nélkül használhassa.
  4. Hívja meg a main() függvényt. A program logikáját hozzá kell adni a függvény törzséhez.
  5. Deklaráljon két kettős változót, a számot és a négyzetgyököt.
  6. Nyomtasson szöveget a konzolra. A szöveg arra kéri a felhasználót, hogy írjon be egy számot.
  7. Felhasználói bevitel olvasása a billentyűzetről. A bemenet a num változó értéke lesz.
  8. Hívja meg az sqrt() függvénykönyvtárat, amely kiszámolja egy szám négyzetgyökét. A num paramétert átadtuk a függvénynek, ami azt jelenti, hogy kiszámolja a num négyzetgyökét. Ez a függvény a cmath könyvtárban van definiálva.
  9. Nyomtassa ki a felhasználó által beírt számot, annak négyzetgyökét és más szöveget a konzolon.
  10. A programnak értéket kell visszaadnia a sikeres befejezés után.
  11. A main() függvény törzsének vége.

Felhasználó által meghatározott funkciók

C++ lehetővé teszi a programozók számára, hogy meghatározzák saját funkcióikat. A funkció célja a kapcsolódó kódok csoportosítása. A kód ezután egyedi azonosítót, a függvény nevét kapja.

A függvény a program bármely más részéből hívható/meghívható. Ezután végrehajtja a törzsében meghatározott kódot.

Példa 2:

#include <iostream>
using namespace std;

void sayHello() {
	cout << "Hello!";
}

int main() {

	sayHello();

	return 0;
}

output:

Kimenet a C++ felhasználó által definiált sayHello() függvény

Itt van egy képernyőkép a kódról:

C++ felhasználó által definiált függvények definiálása és meghívása kódban

Code Magyarázat:

  1. Szerelje be az iostream fejlécfájlt a programunkba a funkcióinak használatához.
  2. Szerelje be az std névteret a kódunkba, hogy az osztályait hívás nélkül használhassa.
  3. Hozzon létre egy felhasználó által definiált függvényt sayHello() néven.
  4. Nyomtasson szöveget a konzolra a sayHello() függvény meghívásakor.
  5. A sayHello() függvény törzsének vége.
  6. Hívja meg a main() függvényt. A program logikáját hozzá kell adni a függvény törzséhez.
  7. Hívja/indálja meg a sayHello() nevű függvényt.
  8. A programnak értéket kell visszaadnia a sikeres befejezés után.
  9. A main() függvény törzsének vége.

A fordítónak ismernie kell egy függvényt, mielőtt azt használná.

Funkciónyilatkozat/Prototípus

Ha a main() függvény után egy felhasználó által definiált függvényt definiál, a C++ fordítóprogram hibát ad vissza. Ennek az az oka, hogy a fordító nem ismeri a felhasználó által definiált függvény részleteit. A részletek közé tartozik a neve, az argumentumok típusai és azok visszatérési típusai.

In C++, a függvény deklaráció/prototípus törzs nélküli függvényt deklarál. Ez megadja a felhasználó által definiált függvény fordítójának részleteit.

A deklarációban/prototípusban megadjuk a visszatérési típust, a függvény nevét és az argumentumtípusokat. Az argumentumok nevei nincsenek hozzáadva. Az argumentumnevek hozzáadása azonban nem okoz hibát.

C++ függvénydeklaráció/prototípus szintaxisdiagram

Funkció meghatározása

A függvénydeklaráció célja, hogy megmondja a C++ fordítóprogram a függvény nevéről, a visszatérési típusról és a paraméterekről. A függvénydefiníció megmondja a C++ fordítóprogram a függvénytörzsről.

C++ függvénydefiníciós szerkezeti ábra

Szintaxis

return_datatype function_name( parameters) {
   function body 
}

A fentiekből kiindulva egy függvénydefiníciónak van a függvény fejléce és törzse. Íme a paraméterek magyarázata:

  • return_datatype – Néhány függvény értéket ad vissza. Ez a paraméter a visszatérési érték adattípusát jelöli. Néhány függvény nem ad vissza értéket. Ebben az esetben a paraméter értéke érvénytelenné válik.
  • függvény_neve- Ez a függvény neve. A függvény neve és paraméterei alkotják a függvény aláírását.
  • Paraméterek – Ez a függvényparaméterek típusa, sorrendje és száma. Néhány függvénynek nincsenek paraméterei.
  • függvénytest – ezek olyan utasítások, amelyek meghatározzák, hogy a függvény mit fog tenni.

Funkcióhívás

Ahhoz, hogy egy függvény végrehajtsa a megadott feladatot és visszaadja a kimenetet, meg kell hívni. Amikor meghívunk egy függvényt, az végrehajtja a törzsébe hozzáadott utasításokat.

Egy függvényt a nevén hívunk meg. Ha a függvény paramétereket fogad el, akkor azok értékét át kell adni a hívás során. Ha a függvény nem fogad el paramétereket, akkor ne adjon át semmilyen értéket a hívás során.

C++ függvényhívás szintaxisdiagramja

Érvek átadása

In C++, az argumentum/paraméter a függvénynek a hívása során átadott adat. Az értékeket a megfelelő változókra kell inicializálni.

Egy függvény meghívásakor az argumentumok számának meg kell egyeznie. Ez azt jelenti, hogy az átadott értékeknek meg kell egyezniük a paraméterek számával. Az értékeknek típusukban is meg kell egyezniük a paraméterekkel. Ha az első paraméter egy egész szám, akkor a neki átadott értéknek is egész számnak kell lennie.

A függvényparaméterekhez alapértelmezett értékek rendelhetők. Ha a függvényhívás során nem adunk meg értéket a paraméternek, akkor a program az alapértelmezett értéket használja.

3. példa: Hogyan írjunk és hívjunk függvényt

#include <iostream>
using namespace std;
int addFunc(int, int);
int main() {
	int x, y, sum;
	cout << "Enter two numbers: ";
	cin >> x >> y;
	sum = addFunc(x, y);
	cout <<"The sum of "<<x<< " and " <<y<<" is: "<<sum;
	return 0;
}
int addFunc(int num1, int num2) {
	int addFunc;
	addFunc = num1 + num2;
	return addFunc;
}

output:

Kimenet a C++ az addFunc() függvény összeget ad vissza

Itt van egy képernyőkép a kódról:

C++ Kód argumentumok átadása az addFunc() függvénynek

Code Magyarázat:

  1. Szerelje be az iostream fejlécfájlt a programunkba a funkcióinak használatához.
  2. Szerelje be az std névteret a kódunkba, hogy az osztályait hívás nélkül használhassa.
  3. Deklaráljon egy addFunc() nevű függvényt, amely két egész paramétert vesz fel. Ezzel létrejön a függvény prototípusa.
  4. Hívja meg a main() függvényt. A program logikáját hozzá kell adni a függvény törzséhez.
  5. Deklaráljunk három egész változót, x, y és sum.
  6. Nyomtasson szöveget a konzolra. A szöveg két szám megadására kéri a felhasználót.
  7. Olvassa el a felhasználói bevitelt a billentyűzetről. A felhasználónak két számot kell beírnia az x és y változókhoz, szóközzel elválasztva.
  8. Hívja meg az addFunc() függvényt, és adja át neki az x és y paramétereket. A funkció ezeken a paramétereken működik, és a kimenetet a változó összeghez rendeli.
  9. Nyomtassa ki az x, y és sum változók értékét a konzolon más szövegek mellé.
  10. A függvénynek értéket kell visszaadnia a sikeres befejezés után.
  11. A main() függvény törzsének vége.
  12. Funkció meghatározása. Meghatározzuk az addFunc() függvényt. Megmondjuk, hogy a függvény mit fog tenni a törzsében, a { }-ban.
  13. AddFunc nevű egész változó deklarálása.
  14. A num1 és num2 paraméterek értékeinek összeadása és az eredmény hozzárendelése az addFunc változóhoz.
  15. Az addFunc() függvénynek vissza kell adnia az addFunc változó értékét.
  16. A függvénytörzs vége, vagyis a függvénydefiníció.

GYIK

Az érték szerinti hívás lemásolja az argumentumot, így a függvényen belüli változtatások nem befolyásolják az eredetit. A hivatkozás szerinti hívás a változót és-jellel adja át, lehetővé téve a függvény számára, hogy közvetlenül módosítsa a hívó értékét. C++ alapértelmezés szerint érték alapján hív.

A függvények túlterhelése lehetővé teszi, hogy több függvény ugyanazt a nevet használja, de a paramétereik számában vagy típusában térjenek el egymástól. A fordító az átadott argumentumok közül választja ki a megfelelő verziót, javítva a kapcsolódó műveletek olvashatóságát.

Egy beágyazott függvény arra kéri a fordítót, hogy minden hívási helyen illessze be a törzsét a normál hívás helyett. Ez csökkentheti az apró függvények terhelését, bár a fordító figyelmen kívül hagyhatja a célzást.

Egy rekurzív függvény meghívja önmagát, egy problémát kisebb részproblémákra bontva. Szüksége van egy alapesetre, amely leállítja a rekurziót; különben a hívások örökké ismétlődnek, és túlcsordulnak a veremben. A faktoriális erre egy klasszikus példa.

A paramétert mutatóként vagy egy méretezett tömbként adjuk át, és általában külön küldjük el a hosszát, mivel a tömb mutatóvá bomlik. Lásd: átadás tömbök C++ funkciók a teljes kidolgozott példákhoz.

Egy függvény közvetlenül egy értéket ad vissza, de többet is visszaadhatunk kimeneti referencia paraméterek, struktúra, std::pair, std::tuple vagy std::vector használatával. A strukturált kötések ezután kicsomagolják a visszaadott tuple-t a hívás helyén.

Igen. A mesterséges intelligencia által fejlesztett kódolóasszisztensek a sima nyelvű megjegyzéseket teljes szöveggé alakítják. C++ függvényt, javasolva az aláírást, a törzset és a visszatérési típust. Emellett a hosszú függvényeket is újrafaktorálják, bár érdemes áttekinteni a generált logikát.

GitHub másodpilóta automatikus kiegészítések C++ függvénydefiníciókat, prototípusokat és a megjegyzéseidből vagy neveidből származó hívásokat készít, túlterheléseket javasol, és egységteszteket tervez. Hivatkozott fejléceket használ a kontextushoz, de minden javaslatot továbbra is felül kell vizsgálni.

Foglald össze ezt a bejegyzést a következőképpen: