Tartalom

• Összehasonlító táblázat
• Az Inline meghatározása
• A makró meghatározása
• Következtetések:

A makró olyan utasítás, amely kibővül a meghívásakor. Funkciók is meghatározhatók, mint például a makrók. Hasonlóképpen, a beépített funkciók szintén kibővülnek hívásuk pillanatában. Az elsődleges különbség az inline és a makrofunkció között az, hogy a inline funkciók kibővítés alatt összeállítás, és a makrók kibővülnek, amikor a program feldolgozza a preprocessor.

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

1. Összehasonlító táblázat
2. Meghatározás
3. Főbb különbségek
4. Következtetés

Összehasonlító táblázat

Az összehasonlítás alapja	Sorban	Macro
Alapvető	A belső funkciókat a fordító elemzi.	A makrókat az előfeldolgozó bővíti.
Szintaxis	inline return_type funct_name (paraméterek) {. . . }	#define macro_name char_sequence
Használt kulcsszavak	Sorban	#define
Meghatározott	Meg lehet határozni az osztályon belül vagy kívül.	Ezt mindig a program elején definiálják.
Értékelés	Az érvet csak egyszer értékeli.	Az argumentumot minden egyes alkalommal kiértékeli, amikor azt a kódban felhasználják.
Terjeszkedés	Lehet, hogy a fordító nem vonja be és bővíti az összes funkciót.	A makrók mindig bővülnek.
Automatizálás	Az osztályon belül meghatározott rövid funkciók automatikusan beépülnek az inline funkciókba.	A makrókat külön meg kell határozni.
Hozzáférés	Az inline tag funkció hozzáférhet az osztály adattagjaihoz.	A makrók soha nem lehetnek az osztály tagjai, és nem férhetnek hozzá az osztály adatainak.
befejezés	Az inline funkció meghatározása a göndör zárójelekkel az inline funkció végén ér véget.	A makró meghatározása az új sorral befejeződik.
Hibakeresés	A hibakeresés a beépített funkciók számára egyszerű, mivel a hibaellenőrzést az összeállítás során hajtják végre.	A hibakeresés a makrók számára nehezebbé válik, mivel a hibaellenőrzés nem fordul elő a fordítás során.
Kötés	A beépített függvény nagyon jól összekapcsolja a függvény testében szereplő összes állítást, a függvény törzse pedig a göndör zárójelekkel kezdődik és végződik.	A makró akkor néz szembe a kötési problémával, ha egynél több utasításból áll, mivel nincs befejezési szimbóluma.

Az Inline meghatározása

Az inline függvény úgy néz ki, mint egy normál függvény, de ezt megelőzi a „Sorban„. Az inline függvények rövid hosszúságú függvények, amelyek meghívásuk helyén kibővülnek, és nem hívják őket. Megértjük a beépített funkciókat egy példával.

#include névtér std; osztálypélda {int a, b; public: inline void inicializálás (int x, int y) {a = x; b = y} void display () {cout << a << "" <

A fenti programban az inicializáló () függvényt deklaráltam és definiáltam, mint egy inline függvényt a „példa” osztályban. Az inicializáló () függvény kódja kibővül, ahol ráhívja a „példa” osztály tárgya. Az osztálypéldában meghatározott funkciókijelzőt () nem deklarálják inline-ként, de a fordító úgy tekintheti inline-ra, mint a C ++ kategóriában az osztályon belül definiált függvényt a fordító automatikusan sorba hozza, figyelembe véve a függvény hosszát.

• Az inline funkció csökkenti a hívás és a visszatérés függvényét, ami viszont csökkenti a program végrehajtásának idejét.Ezen túlmenően az érveket a veremre helyezik, és a regiszterek mentésre kerülnek, amikor egy függvényt meghívnak, és alaphelyzetbe állnak, amikor a függvény visszatér, ami időbe telik, ezt elkerüli a beépített funkciók, mivel nincs szükség helyi változók és formális paraméterek létrehozására minden alkalommal. .
• Az inline függvények tagjai lehetnek az osztálynak, és hozzáférhetnek az osztály adatainak is.
• Az Inline funkció lerövidíti a program végrehajtásának idejét, de néha, ha az inline függvény hossza nagyobb, akkor a program mérete a duplikált kód miatt is növekszik. Ezért jó gyakorlat a nagyon kicsi funkciók beépítése.
• Az inline függvény argumentuma csak egyszer kerül kiértékelésre.

A makró meghatározása

A makró egy „előfeldolgozókról szóló irányelv”. Az összeállítás előtt a programot megvizsgálja az előfeldolgozó, és ha megtalálja a makrót a programban, akkor helyettesíti azt a definícióval. Ezért a makrót „pótlásnak” tekintik. Vizsgáljuk meg a makrót egy példával.

#include #define NAGYABB (a, b) ((a <b)? b: a) int main (érvénytelen) {cout << "10 és 20 közül nagyobb a következő:" << nagyobb ("20", "10") << " n"; visszatérés 0; }

A fenti kódban egy GREATER () makrofunkciót deklaráltam, amely összehasonlítja és megtalálja mindkét paraméter nagyobb számát. Megfigyelheti, hogy nincs pontosvessző a makró lezárására, mivel a makrót csak az új sor végzi. Mivel a makró csak pótlás, kibővíti a makró kódját, ahol meghívják.

• A makrókat mindig nagybetűkkel definiálják, hogy a programozók megkönnyítsék az olvasás közben a programban található összes makró azonosítását.
• A makró soha nem lehet osztály tagfüggvénye, és nem is férhet hozzá bármely osztály adatainak.
• A makrofunkció minden alkalommal értékeli az argumentumot, amikor a definíciójában megjelenik, ami váratlan eredményt eredményez.
• A makrónak kisebb méretűnek kell lennie, mivel a nagyobb makrók szükségtelenül növelik a kód méretét.

1. Az alapvető különbség az inline és a makró között az, hogy az inline függvényeket a fordító elemzi, míg a program makróit az előfeldolgozó bővíti.
2. A beépített függvény meghatározásához használt kulcsszó:Sorban"Mivel a makró meghatározásához használt kulcsszó:#define“.
3. Miután az inline funkció decalre lett az osztályon belül, meghatározható az osztályon belül vagy az osztályon kívül is. Másrészt a makro mindig a program kezdetén van meghatározva.
4. Az inline függvényeknek átadott argumentum összeállításakor csak egyszer kerül kiértékelésre, míg a makró argumentumot minden alkalommal ki kell értékelni, amikor egy makrót használnak a kódban.
5. A fordító előfordulhat, hogy nem vonja be és nem bővíti az osztályban meghatározott összes funkciót. Másrészt a makrók mindig bővülnek.
6. A rövid funkció, amelyet egy osztályon belül definiálnak inline kulcsszó nélkül, automatikusan inline függvényvé válik. Másrészt a makrót külön meg kell határozni.
7. A beépített funkció hozzáférhet az osztály tagjaihoz, míg a makró soha nem fér hozzá az osztály tagjaihoz.
8. Az inline funkció befejezéséhez zárt göndör tartóra van szükség, míg a makrót egy új sor kezdete után fejezik be.
9. A hibakeresés egyszerűvé válik az inlne függvénynél, mivel a fordítás során ellenőrzik, hogy nincs-e hiba. Másrészt a makrót nem ellenőrzik a fordítás során, így a makró hibakeresése megnehezedik.
10. Funkcióként egy inline funkció köti tagjait a kezdő és a zárt göndör tartókon belül. Másrészt a makrónak nincs végződési szimbóluma, így a kötés megnehezedik, ha a makró egynél több állítást tartalmaz.

Következtetések:

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