Nilalaman

• Tsart ng paghahambing
• Kahulugan ng Inline
• Kahulugan ng Macro
• Konklusyon:

Ang Macro ay isang tagubilin na nagpapalawak sa oras ng pananakop nito. Ang mga pag-andar ay maaari ding matukoy, tulad ng macros. Katulad nito, ang mga pag-andar ng inline ay nagpapalawak din sa punto ng pananakop nito. Isang pangunahing pagkakaiba sa pagitan ng inline at macro function na ang pag-andar ng inline ay pinalawak habang pagsasama-sama, at ang macros ay pinalawak kapag ang programa ay pinoproseso ng preprocessor.

Pag-aralan natin ang pagkakaiba sa pagitan ng inline at macro sa tulong ng tsart ng paghahambing.

1. Tsart ng paghahambing
2. Kahulugan
3. Pangunahing Pagkakaiba
4. Konklusyon

Tsart ng paghahambing

Batayan para sa Paghahambing	Nasa linya	Macro
Pangunahing	Ang mga pag-andar ng inline ay naka-parse ng tagatala.	Ang Macros ay pinalawak ng preprocessor.
Syntax	inline return_type funct_name (mga parameter) {. . . }	#define macro_name char_sequence
Ginamit ang mga Keyword	nasa linya	#define
Tinukoy	Maaari itong matukoy sa loob o labas ng klase.	Ito ay palaging tinukoy sa pagsisimula ng programa.
Pagsusuri	Sinusuri nito ang argumento nang isang beses lamang.	Sinusuri nito ang argumento sa bawat oras na ginagamit ito sa code.
Pagpapalawak	Ang tagagawa ay hindi maaaring mag-inline at palawakin ang lahat ng mga pag-andar.	Ang Macros ay palaging pinalawak.
Pag-aautomat	Ang mga maikling pag-andar, na tinukoy sa loob ng klase ay awtomatikong ginagawa sa mga pag-andar ng inline.	Ang Macros ay dapat na tiyak na tinukoy.
Pag-access	Ang pag-andar ng miyembro ng inline ay maaaring ma-access ang mga miyembro ng data ng klase.	Ang Macros ay hindi maaaring maging mga miyembro ng klase at hindi ma-access ang mga miyembro ng data ng klase.
Pagwawakas	Ang kahulugan ng pag-andar ng inline ay nagtatapos sa mga kulot na braket sa dulo ng pag-andar ng inline.	Ang kahulugan ng macro ay nagtatapos sa bagong linya.
Pag-debit	Ang pag-debug ay madali para sa isang pag-andar ng inline habang ang pagsuri ng error ay ginagawa sa panahon ng pag-iipon.	Ang pag-debug ay nagiging mahirap para sa mga macros dahil ang pagsuri ng error ay hindi nangyayari sa panahon ng pag-iipon.
Nagbubuklod	Ang isang inline na function ay nagbubuklod ng lahat ng mga pahayag sa katawan ng pag-andar nang maayos pati na rin ang katawan ng pag-andar magsisimula at nagtatapos sa mga kulot na bracket.	Ang isang macro ay nahaharap sa problemang nagbubuklod kung mayroon itong higit sa isang pahayag, dahil wala itong simbolo ng pagtatapos.

Kahulugan ng Inline

Ang isang pag-andar ng inline ay mukhang isang regular na pag-andar ngunit, nauna sa keyword na "nasa linya". Ang mga pag-andar ng inline ay mga maikling pag-andar ng haba na pinalawak sa punto ng pananakop nito, sa halip na tinawag. Unawain natin ang mga inline na function na may isang halimbawa.

#nagsama gamit ang namespace std; halimbawa ng klase {int a, b; pampubliko: inline na walang pasimula (int x, int y) {a = x; b = y} walang bisa display () {cout << a << "" <

Sa itaas na programa, ipinahayag at tinukoy ko, ang pagpapaandar na nagsisimula (), bilang isang inline na function sa klase na "halimbawa". Ang code ng inisyal na () function ay lalawak kung saan ito ay hinihimok ng bagay ng klase "halimbawa" .Ang pagpapakita ng function (), na tinukoy sa halimbawa ng klase ay hindi ipinahayag na inline ngunit maaari itong isaalang-alang na inline ng tagatala, bilang sa C ++ ang function na tinukoy sa loob ng klase ay awtomatikong ginawa inline ng compiler na isinasaalang-alang ang haba ng pag-andar.

• Ang pag-andar ng inline ay binabawasan ang overhead ng pagtawag sa pag-andar at pagbabalik na kung saan ay binabawasan ang oras ng pagpapatupad ng programa.Gayundin, ang mga argumento ay itinulak sa salansan at ang mga rehistro ay nai-save kapag ang isang function ay tinatawag at i-reset kapag bumalik ang function, na tumatagal ng oras, maiiwasan ito ng mga inline na pag-andar dahil hindi na kailangan ng paglikha ng mga lokal na variable at pormal na mga parameter sa bawat oras .
• Ang mga pag-andar ng inline ay maaaring maging isang miyembro ng klase at maaari ring ma-access ang data ng miyembro ng klase.
• Ang inline function ay binabawasan ang oras ng pagpapatupad ng programa ngunit, kung minsan kung ang haba ng pag-andar ng inline ay mas malaki pagkatapos, ang laki ng programa ay tataas din dahil sa dobleng code. Samakatuwid, ito ay isang mabuting kasanayan na mag-inline ng napakaliit na pag-andar.
• Ang argumento ng inline function ay nasuri ng isang beses lamang.

Kahulugan ng Macro

Ang Macro ay isang "preprocessors na direktoryo". Bago ang compilation, ang programa ay sinuri ng preprocessor at kung saan nahanap nito ang macro sa programa, pinapalitan nito ang macro sa pamamagitan ng kahulugan nito. Samakatuwid, ang macro ay itinuturing na "kapalit". Pag-aralan natin ang macro na may isang halimbawa.

#nagsama #define GREATER (a, b) ((a <b)? b: a) int main (walang bisa) {cout << "Malaking ng 10 at 20 ay" << GUSTO ("20", "10") << " n"; bumalik 0; }

Sa itaas na code, ipinahayag ko ang isang macro function na GREATER (), na naghahambing at nahahanap ang mas malaking bilang ng parehong mga parameter. Maaari mong obserbahan na walang semicolon na wakasan ang macro dahil ang macro ay natatapos lamang sa pamamagitan ng bagong linya. Bilang isang macro ay isang kapalit lamang, palawakin nito ang code ng macro kung saan ito ay hinihimok.

• Ang mga macros ay palaging tinukoy sa mga titik ng kapital upang gawing madali para sa mga programmer na makilala ang lahat ng mga macros sa programa habang binabasa.
• Ang macro ay hindi maaaring maging function ng miyembro ng klase, at hindi mai-access ang mga miyembro ng data ng anumang klase.
• Sinusuri ng macro function ang argumento sa tuwing lilitaw sa kahulugan nito na nagreresulta sa isang hindi inaasahang resulta.
• Ang macro ay dapat na isang mas maliit na sukat dahil ang mas malaking macros ay hindi kinakailangan na madagdagan ang laki ng code.

1. Ang pangunahing pagkakaiba sa pagitan ng inline at macro ay ang isang pag-andar ng inline ay pinagsama ng compiler samantalang, ang mga macros sa isang programa ay pinalawak ng preprocessor.
2. Ang keyword na ginamit upang tukuyin ang isang inline na function ay "nasa linya"Samantalang, ang keyword na ginamit upang tukuyin ang isang macro ay"#define“.
3. Kapag ang pag-andar ng inline ay decalre sa loob ng isang klase, maaari itong matukoy alinman sa loob ng isang klase o sa labas ng isang klase. Sa kabilang banda, ang isang macro ay palaging tinukoy sa pagsisimula ng programa.
4. Ang argumento na naipasa sa mga pag-andar ng inline ay naipalabas nang isang beses habang ang pagsasama, ang pagtatalo ng macros ay nasuri sa bawat oras na ang isang macro ay ginagamit sa code.
5. Ang tagagawa ay hindi maaaring mag-inline at palawakin ang lahat ng mga function na tinukoy sa loob ng isang klase. Sa kabilang banda, ang mga macros ay palaging pinalawak.
6. Ang maikling pagpapaandar na tinukoy sa loob ng isang klase nang walang inline na keyword ay awtomatikong ginagawang mga inline na function. Sa kabilang banda, ang Macro ay dapat na tiyak na tinukoy.
7. Ang isang function na inline ay maaaring ma-access ang mga miyembro ng klase samantalang, ang isang macro ay hindi maaaring ma-access ang mga miyembro ng klase.
8. Upang wakasan ang isang inline na pag-andar ng isang saradong kulot na tirahan ay kinakailangan samantalang, ang isang macro ay natapos sa pagsisimula ng isang bagong linya.
9. Ang pag-debug ay naging madali para sa pag-andar ng inlne dahil nasuri ito sa pag-compile para sa anumang pagkakamali. Sa kabilang banda, ang isang macro ay hindi sinuri habang pinagsama-sama, ang mahirap na pag-debug ng isang macro ay nagiging mahirap.
10. Ang pagiging isang function ng isang inline na function na nagbubuklod sa mga miyembro nito sa loob ng isang panimula at sarado na kulot na mga tirante. Sa kabilang banda, ang macro ay walang anumang simbolo ng pagwawakas kaya, ang paghigpit ay nagiging mahirap kapag ang macro ay naglalaman ng higit pa sa isang pahayag.

Konklusyon:

Ang mga pag-andar ng inline ay mas nakakumbinsi kaysa sa pag-andar ng macro. Nagbibigay din ang C ++ ng isang mas mahusay na paraan sa pagtukoy ng isang pare-pareho, na gumagamit ng isang "const" keyword.