A különbség az Inline és a Macro között C ++-ban

2019

A makró olyan utasítás, amely a hívás idején bővül. Funkciók is definiálhatók, mint a makrók. Hasonlóképpen, az inline függvények a meghívás helyén is kiterjednek. Az inline és a makrófunkciók közötti elsődleges különbség az, hogy az inline funkciók kibontakoznak az összeállítás során, és a makrók bővülnek, amikor a programot a preprocesszor feldolgozza .

Vizsgáljuk meg az inline és a makró közötti különbséget az összehasonlító táblázat segítségével.

Összehasonlító táblázat

Az összehasonlítás alapja	Sorban	Macro
Alapvető	Az inline funkciókat a fordító elemzi.	A makrókat az előfeldolgozó bővíti.
Szintaxis	inline return_type funct_name (paraméterek) {. . . }	#define makró_neve char_sequence
Használt kulcsszavak	Sorban	#define
Meghatározott	Meg lehet határozni az osztályon belül vagy kívül.	Mindig a program elején kerül meghatározásra.
Értékelés	Az érvet csak egyszer értékeli.	Minden alkalommal, amikor a kódot használja, értékeli az argumentumot.
Terjeszkedés	Előfordulhat, hogy a fordító nem tartalmaz és nem bővíti az összes funkciót.	A makrókat mindig bővítik.
Automatizálás	Az osztályon belül definiált rövid függvények automatikusan bekerülnek az inline függvényekbe.	A makrókat kifejezetten meg kell határozni.
Hozzáférés	Az inline tagfunkció elérheti az osztály adatainak tagjait.	A makrók soha nem lehetnek az osztály tagjai, és nem férhetnek hozzá az osztály adatainak tagjaihoz.
befejezés	Az inline függvény meghatározása a göndör zárójelekkel zárul az inline funkció végén.	A makró meghatározása az új vonallal végződik.
hibakeresés	A hibakeresés egyszerű a bejövő funkcióhoz, mivel a hibaellenőrzés a fordítás során történik.	A hibakeresés nehéz lesz a makrók számára, mivel a fordítás során nem történik hibaellenőrzés.
Kötés	Az inline függvény nagyon jól köt minden funkciót a függvény testében, mint a függvény teste, és a göndör zárójelekkel végződik.	A makró a kötési problémával szembesül, ha több állítással rendelkezik, mivel nincs terminál szimbólum.

Az Inline meghatározása

A beágyazott függvény rendes funkciónak tűnik, de előzőleg az „ inline ” kulcsszó jelenik meg. Az inline függvények olyan rövid hosszúságú függvények, amelyek meghívásuk helyett a hívás helyett bővülnek. Tegyük fel, hogy egy példával megismerjük az inline funkciókat.

#include std; {int a, b; nyilvános: inline void inicializálás (int x, int y) {a = x; b = y} érvénytelen kijelző () {cout << a << "" <

A fenti programban bejelentettem és definiáltam a függvény inicializálását (), mint egy soros függvényt a „példa” osztályban. Az inicializálási () függvény kódja kibővül, ahol a „példa” osztály tárgya meghívja. Az osztálypéldányban definiált funkciókijelző () nem kerül behelyezésre, hanem a fordító, mivel a C ++-ban az osztályon belül definiált függvényt a fordító automatikusan hozzárendeli a függvény hosszának függvényében.

Az inline funkció csökkenti a függvényhívás és a visszatérés felső értékét, ami viszont csökkenti a program végrehajtásának idejét. Továbbá, az argumentumok a veremre kerülnek, és a regiszterek mentésre kerülnek, amikor egy függvényt hívnak és visszaállítunk, amikor a függvény visszatérés, ami időt vesz igénybe, ezt a soros funkciók elkerülik, mivel nincs szükség helyi változók és formális paraméterek létrehozására. .
Az Inline funkciók az osztály tagjai lehetnek, és hozzáférhetnek az osztály adattagjához is.
Az inline funkció csökkenti a program végrehajtásának idejét, de néha, ha az inline függvény hossza nagyobb, akkor a program mérete is megnő a duplázott kód miatt. Ezért jó gyakorlat a nagyon kis funkciók beillesztése.
Az inline függvény argumentumát csak egyszer értékelik.

A makró meghatározása

A makró egy „előfeldolgozói irányelv”. Az összeállítás előtt a programot az előfeldolgozó vizsgálja meg, és ahol valaha is megtalálja a makró a programban, a makrót a definíciójával helyettesíti. Ezért a makró a „szövegcsere”. Tanuljunk makrót egy példával.

 #include #define GREATER (a, b) ((a <b)? b: a) int main (void) {cout << "A 10-ről és a 20-ról nagyobb" << GREATER ("20", "10") << "n"; vissza 0; }

A fenti kódban a GREATER () makrófüggvényt jelentettem, amely összehasonlítja és megtalálja a két paraméter nagyobb számát. Megfigyelhetjük, hogy nincs pontosvessző a makró befejezéséhez, mivel a makrót csak az új vonal megszünteti. Mivel a makró csak egy szöveges csere, kibővíti a makró kódját, ahová meghívja.

A makrókat mindig a nagybetűk határozzák meg, hogy a programozók könnyedén azonosíthassák az összes makrót a programban olvasás közben.
A makró soha nem lehet osztály tagfunkciója, és nem férhet hozzá semmilyen osztály adat tagjaihoz.
A makrófüggvény minden egyes alkalommal meghatározza az argumentumot, amely váratlan eredményt eredményez.
A makrónak kisebbnek kell lennie, mivel a nagyobb makrók szükségtelenül növelik a kód méretét.

Főbb különbségek az Inline és a Macro között

Az inline és a makró közötti különbség az, hogy egy inline függvényt a fordító elemez, míg a programban lévő makrókat az előfeldolgozó bővíti.
Az inline függvény meghatározásához használt kulcsszó „ inline ”, míg a makró meghatározásához használt kulcsszó „ #define ”.
Ha az inline függvény egy osztályon belül dekaltrálódik, akkor egy osztályon belül vagy egy osztályon kívül is definiálható. Másrészt a makró mindig a program elején kerül meghatározásra.
Az inline függvényekhez átadott argumentum csak egyszer állítható össze, míg a makrók érvelését minden alkalommal kiértékelik, amikor egy makrot használnak a kódban.
Előfordulhat, hogy a fordító nem sorolhatja be és nem bővíti az osztályon belül meghatározott összes funkciót. Másrészt a makrókat mindig bővítik.
Az inline kulcsszó nélküli osztályon belül definiált rövid függvények automatikusan inline funkciók lesznek. Másrészt a makrót kifejezetten meg kell határozni.
A beágyazott függvény elérheti az osztály tagjait, míg a makró soha nem fér hozzá az osztály tagjaihoz.
Egy inline függvény megszüntetéséhez zárt göndör fogantyúra van szükség, míg a makró egy új vonal kezdetével megszűnik.
A hibakeresés egyszerűvé válik az inlne függvényben, mivel az összeállítás során ellenőrzik a hibákat. Másrészt, a makró nem kerül ellenőrzésre a fordítás során, ezért a makró hibakeresése nehezebb lesz.
Funkcióként egy inline függvény a tagjai elkezdéséhez kötődik, és zárt göndör zárójelek. Másrészről, a makrónak nincs olyan termináljelzője, hogy a kötés nehéz lesz, ha a makró több állítást tartalmaz.

Következtetések:

Az inline funkciók sokkal meggyőzőbbek, mint a makró funkció. A C ++ egy jobb módszert biztosít egy konstans meghatározására is, amely „const” kulcsszót használ.