विषय पर बढ़ें

अंतिम अद्यतन：2026-10-12

C++ inline फ़ंक्शन

लेखक के बारे में:

व्यक्तिगत WeChat सार्वजनिक अकाउंट:

wechat

1.क्लास में inline

हेडर फ़ाइल में मेथड declaration

class A
{
public:
    void f1(int x); 

    /**
     * @brief 类中定义了的函数是隐式内联函数,声明要想成为内联函数，必须在实现处(定义处)加inline关键字。
     *
     * @param x
     * @param y
     */
    void Foo(int x,int y) ///< 定义即隐式内联函数！
    {

    };
    void f2(int x); ///< 声明后，要想成为内联函数，必须在定义处加inline关键字。  
};

implementation फ़ाइल में inline फ़ंक्शन की परिभाषा:

#include <iostream>
#include "inline.h"

using namespace std;

/**
 * @brief inline要起作用,inline要与函数定义放在一起,inline是一种“用于实现的关键字,而不是用于声明的关键字”
 *
 * @param x
 * @param y
 *
 * @return 
 */
int Foo(int x,int y);  // 函数声明
inline int Foo(int x,int y) // 函数定义
{
    return x+y;
}

// 定义处加inline关键字，推荐这种写法！
inline void A::f1(int x){

}

int main()
{


    cout<<Foo(1,2)<<endl;

}
/**
 * 编译器对 inline 函数的处理步骤
 * 将 inline 函数体复制到 inline 函数调用点处；
 * 为所用 inline 函数中的局部变量分配内存空间；
 * 将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
 * 如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）。
 */

inline फ़ंक्शन की दक्षता बढ़ा सकता है, लेकिन हर फ़ंक्शन को inline फ़ंक्शन परिभाषित नहीं करना चाहिए! inline का दाम code expansion (copy) है, यह केवल फ़ंक्शन कॉल का ओवरहेड बचाकर फ़ंक्शन की निष्पादन दक्षता बढ़ाता है।

  • अगर फ़ंक्शन बॉडी के कोड के निष्पादन का समय फ़ंक्शन कॉल के ओवरहेड से ज़्यादा है, तो दक्षता का लाभ और कम होगा!

  • दूसरी ओर, हर inline फ़ंक्शन कॉल पर कोड copy होता है, जिससे प्रोग्राम का कुल कोड बढ़ता है और ज़्यादा मेमोरी स्पेस खपत होती है।

निम्नलिखित स्थितियों में inline उपयुक्त नहीं:

(1) अगर फ़ंक्शन बॉडी का कोड काफ़ी लंबा है, तो inline करने से मेमोरी खपत का दाम ज़्यादा होगा।

(2) अगर फ़ंक्शन बॉडी में लूप है, तो फ़ंक्शन बॉडी के कोड के निष्पादन का समय फ़ंक्शन कॉल के ओवरहेड से बड़ा होगा।

2.क्या वर्चुअल फ़ंक्शन (virtual), inline फ़ंक्शन (inline) हो सकता है?

  • वर्चुअल फ़ंक्शन inline फ़ंक्शन हो सकता है, inline वर्चुअल फ़ंक्शन को qualify कर सकता है, लेकिन जब वर्चुअल फ़ंक्शन पॉलीमॉर्फ़िज़्म दिखाता है तब inline नहीं हो सकता।
  • inline प्रोग्रामर की ओर से कंपाइलर को inline करने का सुझाव है, जबकि वर्चुअल फ़ंक्शन का पॉलीमॉर्फ़िज़्म रनटाइम में होता है, कंपाइलर नहीं जानता कि रनटाइम में कौन-सा कोड कॉल होगा, इसलिए जब वर्चुअल फ़ंक्शन पॉलीमॉर्फ़िज़्म दिखाता है (रनटाइम) तब inline नहीं हो सकता।
  • inline virtual केवल तब inline हो सकता है जब कंपाइलर जानता हो कि कॉल किया गया ऑब्जेक्ट किस क्लास का है (जैसे Base::who()), यह केवल तब होता है जब कंपाइलर के पास वास्तविक ऑब्जेक्ट हो, ऑब्जेक्ट का पॉइंटर या रेफ़रेंस नहीं।
#include <iostream>  
using namespace std;
class Base
{
public:
    inline virtual void who()
    {
        cout << "I am Base\n";
    }
    virtual ~Base() {}
};
class Derived : public Base
{
public:
    inline void who()  // 不写inline时隐式内联
    {
        cout << "I am Derived\n";
    }
};

int main()
{
    // 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。 
    Base b;
    b.who();

    // 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。  
    Base *ptr = new Derived();
    ptr->who();

    // 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。
    delete ptr;
    ptr = nullptr;


    return 0;
}

संबंधित विषय

टिप्पणियाँ