Inline内联函数的总结贴

内联函数是一种编译机制，优点从代码上是看不出来的，但是程序的执行效率上有差别，通常，编译器对函数调用的处理是一种类似中断的方式，即当执行到函数调用语句时，程序把当前所有的状态信息比如CPU所有寄存器（其中一个很重要的就是指令指针寄存器）的值保存起来，然后放心大胆地转去执行那个函数的代码，执行完后再返回原来的地方，恢复原先保存过的状态信息，于是也就可以接着原来被中断的指令继续往下执行。这样，就很容易实现代码的结构化，因为可以把一些独立的功能模块写成函数，函数内部的变量和外部的变量互不影响，而且函数执行完后就可以释放这个函数内部变量的所使用的内存空间（这就是为什么函数退出后，其内部变量不再有效），对内存的使用也是很经济的（否则，如果一个大的程序全部由一个函数组成，那么所有的变量都得自始至终地占用内存空间），当然，还有其他优点，比如可以实现递归，总之是好处多多。
可是，任何事情往往都有两方面，这样做虽然好处多多，但也是有代价的，那就是前面所说的，任何一次函数调用，程序都得进行保存和恢复状态信息的动作，用数据结构的术语说就是进栈和退栈，当然，还有内存分配的过程，如果函数的代码非常少，这种代价并不是可忽略的，比如说，你编写一个类，里面有个记录状态的成员变量：
Class   MyClass
{
private:
int   m_iState;
}
按照面向对象的思想，函数的属性应尽量的私有化，但外部怎么获得这个属性值呢？一般的方法就是加一个共有函数，这就实现的面向对象思想中所谓“通过公用接口操作对象的私有属性”。于是就变成了：
Class   MyClass
{
public:
int   GetState();
private:
int   m_iState;
}

int   MyClass::GetState()
{
return   m_iState;
}
这样一来，面向对象思想倒是体现出来了，但你的CPU会恨你：“你丫一个鸟函数就返回一个整数却让老子进一次栈、弹一次栈”，内存也会埋怨：“兄弟也得跟着分配内存！”
但对你来说，也很委屈，怎么办，把所有的属性都改成public？让外部内码直接访问？况且，那样也不解决所有问题，因为有时候即使不是为了面向对象，我们也需要把独立的功能模块做成函数，比如说产生随机数的函数。我想
int   iRand=rand();
总比：
int   iRand=((int)(MULTIPLIER   *   Seed   +   INCREMENT)> > 16)&0x7fff;
看起来舒服吧？（我这里只是打个比方，VC的rand函数并不是内联函数）
而内联函数就是解决这个问题了，对于程序员，他还是把独立功能写成函数的形式，但只要声明为内联，编译器就不把它编译成一次函数调用，而只是类似于把函数的代码拷贝到被调用的地方，而且这完全是编译器私下里完成的，原来的访问权限等问题丝毫不受影响。这不是两全齐美了吗：在保证代码的面向对象性和结构化不受损失的条件下，程序的效率也没有损失，比如上面那个类，就变成了：
Class   MyClass
{
public:
inline   int   GetState();
private:
int   m_iState;
}

int   inline   MyClass::GetState()
{
return   m_iState;
}
有一点要注意，内联函数要跟类的声明写在同一个文件中，否则编译会出错。按照VC管理源文件的风格来说，就是内联函数最好写在声明类的.h文件中，而不是像一般函数那样写在实现类的.cpp文件中。
当然，内联函数还有另外一种写法，就是直接写在类中，此时，不必使用“inline”关键字。
Class   MyClass
{
public:
int   GetState(){   return   m_iState;   }
private:
int   m_iState;
}
最后，还要注意，内联函数只是一种编译机制，用上面两种形式声明的函数仅仅是建议编译器进行内联，而编译器是否内联不一定。正如前面所说，函数调用的开销只是对小的函数不可忽略，对于重量级的函数还是可以忽略的，而且在绝大多数的场合，函数调用才是人间正道，才是解决问题的最佳。所以大多数编译器并不把带有循环、递归等或者代码比较多的函数进行内联编译，有的甚至不允许声明成内联的。

是空间换时间的一种做法，直接把调用的函数复制到调用处，而不是采用普通的函数调用方法，减小了开销。

一般的函数调用，相关参数需要入栈，出栈，如果仔细考虑的话，这些都是费时间的。内联函数的作用，主要是把一些短小的函数，直接嵌入到调用者当中，省去一般函数调用的麻烦。（个人认为函数的作用，就是为了把一些重复使用的代码提取出来，共使用。内联函数具有这个好处，同时也节省的资源）

类的成员函数如果定义在类内部，不要加inline关键字，编译器通常会将它作为内联处理。

如果定义在类外面，就要加inline关键字。重申：inline只是一种请求。

内联函数是一种编译机制，优点从代码上是看不出来的，但是程序的执行效率上有差别，通常，编译器对函数调用的处理是一种类似中断的方式，即当执行到函数调用语句时，程序把当前所有的状态信息比如CPU所有寄存器（其中一个很重要的就是指令指针寄存器）的值保存起来，然后放心大胆地转去执行那个函数的代码，执行完后再返回原来的地方，恢复原先保存过的状态信息，于是也就可以接着原来被中断的指令继续往下执行。这样，就很容易实现代码的结构化，因为可以把一些独立的功能模块写成函数，函数内部的变量和外部的变量互不影响，而且函数执行完后就可以释放这个函数内部变量的所使用的内存空间（这就是为什么函数退出后，其内部变量不再有效），对内存的使用也是很经济的（否则，如果一个大的程序全部由一个函数组成，那么所有的变量都得自始至终地占用内存空间），当然，还有其他优点，比如可以实现递归，总之是好处多多。 
可是，任何事情往往都有两方面，这样做虽然好处多多，但也是有代价的，那就是前面所说的，任何一次函数调用，程序都得进行保存和恢复状态信息的动作，用数据结构的术语说就是进栈和退栈，当然，还有内存分配的过程，如果函数的代码非常少，这种代价并不是可忽略的，比如说，你编写一个类，里面有个记录状态的成员变量： 
Class MyClass 
{ 
private: 
int m_iState; 
} 
按照面向对象的思想，函数的属性应尽量的私有化，但外部怎么获得这个属性值呢？一般的方法就是加一个共有函数，这就实现的面向对象思想中所谓“通过公用接口操作对象的私有属性”。于是就变成了： 
Class MyClass 
{ 
public: 
int GetState(); 
private: 
int m_iState; 
} 

int MyClass::GetState() 
{ 
return m_iState; 
} 
这样一来，面向对象思想倒是体现出来了，但你的CPU会恨你：“你丫一个鸟函数就返回一个整数却让老子进一次栈、弹一次栈”，内存也会埋怨：“兄弟也得跟着分配内存！” 
但对你来说，也很委屈，怎么办，把所有的属性都改成public？让外部内码直接访问？况且，那样也不解决所有问题，因为有时候即使不是为了面向对象，我们也需要把独立的功能模块做成函数，比如说产生随机数的函数。我想 
int iRand=rand(); 
总比： 
int iRand=((int)(MULTIPLIER * Seed + INCREMENT)>>16)&0x7fff; 
看起来舒服吧？（我这里只是打个比方，VC的rand函数并不是内联函数） 
而内联函数就是解决这个问题了，对于程序员，他还是把独立功能写成函数的形式，但只要声明为内联，编译器就不把它编译成一次函数调用，而只是类似于把函数的代码拷贝到被调用的地方，而且这完全是编译器私下里完成的，原来的访问权限等问题丝毫不受影响。这不是两全齐美了吗：在保证代码的面向对象性和结构化不受损失的条件下，程序的效率也没有损失，比如上面那个类，就变成了： 
Class MyClass 
{ 
public: 
inline int GetState(); 
private: 
int m_iState; 
} 

int inline MyClass::GetState() 
{ 
return m_iState; 
} 
有一点要注意，内联函数要跟类的声明写在同一个文件中，否则编译会出错。按照VC管理源文件的风格来说，就是内联函数最好写在声明类的.h文件中，而不是像一般函数那样写在实现类的.cpp文件中。 
当然，内联函数还有另外一种写法，就是直接写在类中，此时，不必使用“inline”关键字。 
Class MyClass 
{ 
public: 
int GetState(){ return m_iState; } 
private: 
int m_iState; 
} 
最后，还要注意，内联函数只是一种编译机制，用上面两种形式声明的函数仅仅是建议编译器进行内联，而编译器是否内联不一定。正如前面所说，函数调用的开销只是对小的函数不可忽略，对于重量级的函数还是可以忽略的，而且在绝大多数的场合，函数调用才是人间正道，才是解决问题的最佳。所以大多数编译器并不把带有循环、递归等或者代码比较多的函数进行内联编译，有的甚至不允许声明成内联的。