K&R C-ում կամ C89-ում ներդիրը լեզվի մաս չէր: Շատ կոմպիլյատորներ այն իրականացրել են որպես ընդլայնում, սակայն դրա աշխատանքի վերաբերյալ հստակ իմաստաբանություն չկար: GCC-ն առաջիններից էր, ով ներդրեց ինլինինգը և ներկայացրեց inline, static inline և extern inline կառուցվածքները; C99-ից առաջ կոմպիլյատորների մեծ մասը հիմնականում հետևում է իր օրինակին:

GNU89:

• inline. ֆունկցիան կարող է գծված լինել (թեև դա պարզապես հուշում է): Արտահերթ տարբերակը միշտ արտանետվում է և արտաքինից տեսանելի: Հետևաբար, դուք կարող եք ունենալ միայն մեկ կոմպիլյատորային միավորում սահմանված այդպիսի ներդիր, և յուրաքանչյուր մյուսը պետք է այն դիտի որպես գծից դուրս ֆունկցիա (կամ հղման ժամանակ դուք կստանաք կրկնօրինակ նշաններ):
• extern inline-ը չի ստեղծի գծից դուրս տարբերակ, այլ կարող է կանչել այն (որը, հետևաբար, դուք պետք է սահմանեք որևէ այլ կոմպիլյատորական միավորում: Այնուամենայնիվ, կիրառվում է մեկ սահմանման կանոնը. գծից դուրս տարբերակը պետք է ունենա նույն կոդը, ինչ այստեղ առաջարկվող inline-ը, այն դեպքում, երբ կոմպիլյատորը դրա փոխարեն կանչի:
• static inline-ը չի ստեղծի արտաքին տեսանելի գծից դուրս տարբերակ, թեև այն կարող է ստեղծել ստատիկ ֆայլ: Մեկ սահմանման կանոնը չի կիրառվում, քանի որ երբեք չի լինում արտանետվող արտաքին խորհրդանիշ կամ զանգ մեկին:

C99 (կամ GNU99):

• inline՝ ինչպես GNU89 «արտաքին ներդիր»; ոչ մի արտաքին տեսանելի ֆունկցիա չի արտանետվում, բայց մեկը կարող է կանչվել և այդպես պետք է գոյություն ունենա
• extern inline. ինչպես GNU89 «inline»-ը. արտանետվում է արտաքին տեսանելի կոդը, ուստի առավելագույնը մեկ թարգմանական միավոր կարող է օգտագործել սա:
• static inline՝ ինչպես GNU89 «ստատիկ ներդիրում»: Սա միակ շարժականն է gnu89-ի և c99-ի միջև

C++:

Գործառույթը, որը ներգծված է ցանկացած վայրում, պետք է լինի ներդիր ամենուր՝ նույն սահմանմամբ: Կոմպիլյատորը/կցորդը կդասավորի խորհրդանիշի բազմաթիվ օրինակներ: static inline կամ extern inline-ի սահմանում չկա, չնայած շատ կոմպիլյատորներ ունեն դրանք (սովորաբար հետևում են gnu89 մոդելին):

Կարծում եմ, որ դուք սխալ եք հասկանում __FILE__-ը և __LINE__-ը՝ հիմնվելով այս հայտարարության վրա.

քանի որ այն օգտագործում է __FILE__ և __LINE__ մակրոները, որոնք պետք է լուծվեն զանգահարողի համար, բայց ոչ այս կոչվող գործառույթը

Կազմման մի քանի փուլ կա, և նախնական մշակումն առաջինն է: __FILE__-ը և __LINE__-ը փոխարինվում են այդ փուլում: Այսպիսով, մինչ կոմպիլյատորը կարող է դիտարկել ներկառուցման գործառույթը, դրանք արդեն փոխարինված են:

Թվում է, թե դուք փորձում եք գրել այսպիսի բան.

inline void printLocation()
{
  cout <<"You're at " __FILE__ ", line number" __LINE__;
}

{
...
  printLocation();
...
  printLocation();
...
  printLocation();

և հուսալով, որ ամեն անգամ տարբեր արժեքներ կստանաք: Ինչպես ասում է Դոնը, դուք չեք անի, քանի որ __FILE__-ը և __LINE__-ն իրականացվում են նախապրոցեսորի կողմից, իսկ inline-ն իրականացվում է կոմպիլյատորի կողմից: Այսպիսով, որտեղից էլ զանգահարեք printLocation, դուք կստանաք նույն արդյունքը:

միակ միջոցը, որով դուք կարող եք դա գործի դնել, printLocation-ը մակրո դարձնելն է: (Այո ես գիտեմ...)

#define PRINT_LOCATION  {cout <<"You're at " __FILE__ ", line number" __LINE__}

...
  PRINT_LOCATION;
...
  PRINT_LOCATION;
...

Փոխանակ պատասխանելու, թե ինչ է դա անում, ես պատասխանում եմ, թե ինչպես անեմ այն, ինչ ուզում եմ: Գոյություն ունեն ներդիրների 5 տեսակ, բոլորը հասանելի են GNU C89-ում, ստանդարտ C99-ում և C++-ում: MSVC-ն ունի դրանցից որոշ (նշեք, որ ես չեմ փորձարկել MSVC կոդը)

always inline, unless the address is taken

Ցանկացած հայտարարության մեջ ավելացրեք __attribute__((always_inline)), այնուհետև օգտագործեք ստորև բերված դեպքերից մեկը՝ դրա հասցեի ընդունման հնարավորությունը կարգավորելու համար:

Դուք, հավանաբար, երբեք չպետք է օգտագործեք սա, եթե դրա իմաստաբանությունը ձեզ հարկավոր չէ (օրինակ՝ որոշակի ձևով ազդելու ժողովի վրա կամ օգտագործել alloca): Կոմպիլյատորը սովորաբար ձեզնից լավ գիտի, արդյոք արժե այն:

MSVC-ն ունի __forceinline, որը հիմնականում նույնն է թվում, բայց, ըստ երևույթին, այն հրաժարվում է ներդնել բավականին սովորական հանգամանքներում (օրինակ, երբ օպտիմիզացումն անջատված է), որտեղ մյուս կոմպիլյատորները լավ են աշխատում:

inline and emit a weak symbol (like C++, aka "just make it work")

__attribute__((weak))
void foo(void);
inline void foo(void) { ... }

Նկատի ունեցեք, որ դա թողնում է նույն կոդի մի փունջ կրկնօրինակներ, և կապողն ընտրում է մեկը կամայականորեն:

MSVC-ն, ըստ երևույթին, չունի ճշգրիտ համարժեք C ռեժիմում, չնայած կան մի քանի նմանատիպ բաներ: Թվում է, թե __declspec(selectany)-ը խոսում է միայն տվյալների մասին, ուստի մի՞թե չի կիրառվում գործառույթների վրա: Կա նաև կապող աջակցություն թույլ կեղծանունների համար, բայց արդյո՞ք դա աշխատում է այստեղ:

inline, but never emit any symbol (leaving external references)

__attribute__((gnu_inline))
extern inline void foo(void) { ... }

MSVC-ի __declspec(dllimport)-ը, զուգորդված փաստացի սահմանման հետ (այլապես անսովոր), ենթադրաբար դա անում է:

emit always (for one TU, to resolve the preceding)

Ակնարկվող տարբերակը թույլ նշան է հաղորդում C++-ում, բայց ուժեղ խորհրդանիշ C-ի երկու բարբառներում.

void foo(void);
inline void foo(void) { ... }

Կամ դուք կարող եք դա անել առանց ակնարկի, որն արտահայտում է ուժեղ խորհրդանիշ երկու լեզուներով.

void foo(void) { ... }

Ընդհանրապես, դուք գիտեք, թե ինչ լեզվով է ձեր TU-ն, երբ տալիս եք սահմանումները, և, հավանաբար, շատ գծագրման կարիք չունեք:

MSVC-ի __declspec(dllexport)-ն ենթադրաբար դա անում է:

inline and emit in every TU

static inline void foo(void) { ... }

Այս բոլորի համար, բացի static-ից, կարող եք վերևում ավելացնել void foo(void) հայտարարություն: Սա օգնում է մաքուր վերնագրեր գրելու լավագույն պրակտիկային, այնուհետև #includeառանձին ֆայլ ստեղծելու ներկառուցված սահմանումներով: Այնուհետև, եթե օգտագործում եք C ոճի ներդիրներ, #define որոշ մակրո տարբեր կերպ մեկ հատուկ TU-ում՝ տրամադրելու գծից դուրս սահմանումներ:

Մի մոռացեք extern "C"-ը, եթե վերնագիրը կարող է օգտագործվել ինչպես C-ից, այնպես էլ C++-ից:

Կան նաև մի քանի հարակից բաներ.

never inline

Ֆունկցիայի ցանկացած հայտարարությանն ավելացրեք __attribute__((noinline)):

MSVC-ն ունի __declspec(noinline), բայց այն փաստաթղթավորված է, որ աշխատում է միայն անդամի գործառույթների համար: Այնուամենայնիվ, ես տեսել եմ անվտանգության հատկանիշների հիշատակում, որոնք կարող են կանխել ներդիրումը:

force other functions to be inlined into this one if possible.

Ավելացնել __attribute__((flatten)) ֆունկցիայի ցանկացած հայտարարության:

Նկատի ունեցեք, որ noinline-ն ավելի հզոր է, քան սա, ինչպես նաև գործառույթները, որոնց սահմանումը հայտնի չէ կոմպիլյացիայի ժամանակ:

MSVC-ն, ըստ երևույթին, չունի համարժեք: Ես տեսել եմ [[msvc::forceinline_calls]]-ի մեկ հիշատակում (կիրառվել է հայտարարության կամ արգելափակման համար), բայց դա ռեկուրսիվ չէ:

Ներքին, ստատիկ ներգծային և արտաքին ներգծի հետ կապված իրավիճակը բարդ է, հատկապես այն պատճառով, որ gcc-ն և C99-ը մի փոքր տարբեր իմաստներ են սահմանում իրենց վարքագծի համար (և, ենթադրաբար, նաև C++): Դուք կարող եք գտնել որոշ օգտակար և մանրամասն տեղեկություններ այն մասին, թե ինչ են նրանք անում C այստեղ< /ա>.