The differences between Define and Inline

define：在代码处不加任何验证的简单替换

定义预编译时处理的宏；

只进行简单的字符替换，无类型检测

inline: 将代码插入到调用处，会做参数类型检查

内联函数对编译器提出建议，是否进行宏替换，编译器有权拒绝，即向编译器提出申请来内联，但编译器会根据实际情况来决定是否做内联。

内联函数在可读性方面与函数是相同的，而在编译时是将函数直接嵌入调用程序的主体，省去了调用/返回指令，这样在运行时速度更快。

内联函数可以调试，而宏定义是不可以调试的。内联函数与宏本质上是两个不同的概念如果程序编写者对于既要求快速，又要求可读的情况下，则应该将函数冠以inline。

备注：

typedef：定义类型别名 用于处理复杂类型

  例： typedef int A；

  则：A a；//定义a为int

下面详细介绍一下探讨一下宏定义与内联函数。

一、宏定义

1.相信大家都用过预处理宏，我们会经常定义一些宏，如

#defineTABLE_COMP(x) ((x)>0?(x):0)

　就定义了一个宏。

　　为什么要使用宏呢？因为函数的调用必须要将程序执行的顺序转移到函数所存放在内存中的某个地址，将函数的程序内容执行完后，再返回到执行该函数前的地方。这种转移操作要求在转去执行前要保存现场并记忆执行的地址，转回后要恢复现场，并按原来保存地址继续执行。因此，函数调用要有一定的时间和空间方面的开销，于是将影响其效率。而宏只是在预处理的地方把代码展开，不需要额外的空间和时间方面的开销，所以调用一个宏比调用一个函数更有效率。

2.但是宏也有很多的不尽人意的地方。

　　1）宏不能访问对象的私有成员。

　　2）宏的定义很容易产生二义性。

　　我们举个例子：

#defineTABLE_MULTI(x) (x*x)

　　我们用一个数字去调用它,TABLE_MULTI(10)，这样看上去没有什么错误，结果返回100,是正确的，但是如果我们用TABLE_MULTI(10+10)去调用的话，我们期望的结果是４００，而宏的调用结果是(10+10*10+10),结果是120，这显然不是我们要得到的结果。避免这些错误的方法，一是给宏的参数都加上括号。

#defineTABLE_MULTI(x) ((x)*(x))

 

3.这样可以确保不会出错，但是，即使使用了这种定义，这个宏依然有可能出错，例如使用TABLE_MULTI(a++)调用它，他们本意是希望得到(a+1)*(a+1)的结果，而实际上呢？我们可以看看宏的展开结果: (a++)*(a++)，如果a的值是４，我们得到的结果是5*6=30。而我们期望的结果是5*5=25,这又出现了问题。事实上，在一些C的库函数中也有这些问题。例如:Toupper(*pChar++)就会对pChar执行两次++操作，因为Toupper实际上也是一个宏。

 

4.我们可以看到宏有一些难以避免的问题，怎么解决呢？

　　下面就是用我要介绍的内联函数来解决这些问题，我们可以使用内联函数来取代宏的定义。而且事实上我们可以用内联函数完全取代预处理宏。

　　内联函数和宏的区别在于，宏是由预处理器对宏进行替代，而内联函数是通过编译器控制来实现的。而且内联函数是真正的函数，只是在需要用到的时候，内联函数像宏一样的展开，所以取消了函数的参数压栈，减少了调用的开销。你可以像调用函数一样来调用内联函数，而不必担心会产生于处理宏的一些问题。

二、内联函数

　　我们可以用inline来定义内联函数，不过，任何在类的说明部分定义的函数都会被自动的认为是内联函数。

　　下面我们来介绍一下内联函数的用法。

　　内联函数必须是和函数体声明在一起，才有效。像这样的声明inlineTablefunction(int I)是没有效果的，编译器只是把函数作为普通的函数声明，我们必须定义函数体。

inlinetablefunction(int I) {return I*I};

这样我们才算定义了一个内联函数。我们可以把它作为一般的函数一样调用。但是执行速度确比一般函数的执行速度要快。

　　我们也可以将定义在类的外部的函数定义为内联函数，比如：

ClassTableClass{

　Private:

　　Int I,j;

　Public:

　　Int add() { return I+j;};

　　inline int dec() { return I-j;}

　　Int GetNum();

}

 

inline inttableclass::GetNum(){

return I;

}

      上面声明的三个函数都是内联函数。在C++中，在类的内部定义了函数体的函数，被默认为是内联函数。而不管你是否有inline关键字。

 

　　内联函数在C++类中，应用最广的，应该是用来定义存取函数。我们定义的类中一般会把数据成员定义成私有的或者保护的，这样，外界就不能直接读写我们类成员的数据了。对于私有或者保护成员的读写就必须使用成员接口函数来进行。如果我们把这些读写成员函数定义成内联函数的话，将会获得比较好的效率。

Class sample{

　Private:

　　Int nTest;

　Public:

　　Int readtest(){ return nTest;}

　Void settest(int I) {nTest=I;}

}

 

　　当然，内联函数也有一定的局限性。就是函数中的执行代码不能太多了，如果，内联函数的函数体过大，一般的编译器会放弃内联方式，而采用普通的方式调用函数。这样，内联函数就和普通函数执行效率一样了。

 

关于内联函数的一些问题：

1.内联函数是什么？

内联函数是代码被插入到调用者代码处的函数。如同 #define 宏（但并不等同，原因见下文），内联函数通过避免被调用的开销来提高执行效率，尤其是它能够通过调用（“过程化集成”）被编译器优化。

 

2.内联函数是如何在安全和速度上取得折衷？

在 C 中，你可以通过在结构中设置一个 void* 来得到“封装的结构”，在这种情况下，指向实际数据的 void* 指针对于结构的用户来说是未知的。因此结构的用户不知道如何解释void*指针所指内容，但是存取函数可以将 void* 转换成适当的隐含类型。这样给出了封装的一种形式。

 

不幸的是这样做丧失了类型安全，并且也将繁琐的对结构中的每个域的访问强加于函数调用。（如果你允许直接存取结构的域，那么对任何能直接存取的人来说，了解如何解释void* 指针所指内容就是必要的了；这样将使改变底层数据结构变的困难）。

 

虽然函数调用开销是很小的，但它会被累积。C++类允许函数调用以内联展开。这样让你在得到封装的安全性时，同的时得到直接存取速度。此外，内联函数的参数类型由编译器检查，这是对 C的 #define 宏的一个改进。

 

 

3.为什么我应该用内联函数？而不是原来清晰的 #define 宏？

因为#define宏定义函数是在四处是有害的：

和 #define 宏不同的是，内联函数总是对参数只精确地进行一次求值，从而避免了那声名狼藉的宏错误。换句话说，调用内联函数和调用正规函数是等价的，差别仅仅是更快：

复制代码 代码如下:

 

// 返回 i 的绝对值的宏

#defineunsafe(i) \

         ( (i) >= 0 ? (i) : -(i) )

 

// 返回 i 的绝对值的内联函数

inline

int safe(inti)

{

   return i >= 0 ? i : -i;

}

 

int f();

 

voiduserCode(int x)

{

   int ans;

 

   ans = unsafe(x++);   // 错误！x 被增加两次

   ans = unsafe(f());   // 危险！f()被调用两次

 

   ans = safe(x++);     // 正确！ x 被增加一次

   ans = safe(f());     // 正确！ f() 被调用一次

}

 

和宏不同的，还有内联函数的参数类型被检查，并且被正确地进行必要的转换。宏定义复杂函数是有害的；非万不得已不要用。

 

4.如何告诉编译器使非成员函数成为内联函数？

声明内联函数看上去和普通函数非常相似：

void f(int i,char c);

当你定义一个内联函数时，在函数定义前加上 inline 关键字，并且将定义放入头文件：inline　void f(int i, char c){   // ...}

注意：将函数的定义（{...}之间的部分）放在头文件中是强制的，除非该函数仅仅被单个 .cpp 文件使用。尤其是，如果你将内联函数的定义放在 .cpp 文件中并且在其他 .cpp文件中调用它，连接器将给出 “unresolvedexternal” 错误。

 

5.如何告诉编译器使一个成员函数成为内联函数？

声明内联成员函数看上去和普通函数非常类似：

class Fred{public:  

void f(int i,char c);};

但是当你定义内联成员函数时，在成员函数定义前加上 inline 关键字，并且将定义放入头文件中：inline void Fred::f(int i, char c){   // ...}通常将函数的定义（{...}之间的部分）放在头文件中是强制的。如果你将内联函数的定义放在.cpp 文件中并且在其他.cpp 文件中调用它，连接器将给出“unresolvedexternal”错误。

 

6.有其它方法告诉编译器使成员函数成为内联吗？

有： 在类体内定义成员函数：class Fred {public:   void f(int i, char c)     {      // ...     }};尽管这对于写类的人来说很容易，但由于它将类是“什么”(what)和类“如何”(how)工作混在一起.

其他相关信息：

inline

1) 产生背景

inline这个关键字的引入原因和const十分相似，inline 关键字用来定义一个类的内联函数，引入它的主要原因是用它替代C中表达式形式的宏定义。

表达式形式的宏定义一例：

　　　#define ExpressionName(Var1,Var2)(Var1+Var2)*(Var1-Var2)

       这种表达式形式宏形式与作用跟函数类似，但它使用预编译器，没有堆栈，使用上比函数高效。但它只是预编译器上符号表的简单替换，不能进行参数有效性检测及使用C++类的成员访问控制。

inline 推出的目的，也正是为了取代这种表达式形式的宏定义，它消除了它的缺点，同时又很好地继承了它的优点。inline代码放入预编译器符号表中，高效；它是个真正的函数，调用时有严格的参数检测；它也可作为类的成员函数。

2) 具体作用

直接在class类定义中定义各函数成员，系统将他们作为内联函数处理；成员函数是内联函数，意味着：每个对象都有该函数一份独立的拷贝。

在类外，如果使用关键字inline定义函数成员，则系统也会作为内联函数处理；

 

static

一、产生背景

引出原因：函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，大家知道，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？

最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此函数控制）。类的静态成员也是这个道理。

解决方案：因此C++ 中引入了static，用它来修饰变量，它能够指示编译器将此变量在程序的静态存储区分配空间保存，这样即实现了目的，又使得此变量的存取范围不变。

二、具体作用

Static 作用分析总结：static总是使得变量或对象的存储形式变成静态存储，连接方式变成内部连接，对于局部变量（已经是内部连接了），它仅改变其存储方式； 对于全局变量（已经是静态存储了），它仅改变其连接类型。(1 连接方式：成为内部连接；2 存储形式：存放在静态全局存储区)

 

const

一、产生背景

1.C++有一个类型严格的编译系统，这使得C++程序的错误在编译阶段即可发现许多，从而使得出错率大为减少，因此，也成为了C++与C相比，有着突出优点的一个方面。

2.C中很常见的预处理指令 #define VariableName VariableValue 可以很方便地进行值替代，这种值替代至少在三个方面优点突出：

1）避免了意义模糊的数字出现，使得程序语义流畅清晰，如下例：

　　#define USER_NUM_MAX 107 这样就避免了直接使用107带来的困惑。

2）可以很方便地进行参数的调整与修改， 如上例，当人数由107变为201时，改动此处即可；

3）提高了程序的执行效率，由于使用了预编译器进行值替代，并不需要为这些常量分配存储空间，所以执行的效率较高。

然而，预处理语句虽然有以上的许多优点，但它有个比较致命的缺点，即，预处理语句仅仅只是简单值替代，缺乏类型的检测机制。这样预处理语句就不能享受C++严格类型检查的好处，从而可能成为引发一系列错误的隐患。

const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。

现在它的形式变成了：

constDataType VariableName = VariableValue ;

二、具体作用

1.const 用于指针的两种情况分析：

　   int const *A; 　//A可变，*A不可变

　   int *const A; 　//A不可变，*A可变

　分析：const 是一个向左结合的类型修饰符，它与其左侧的类型修饰符和为一个类型修饰符，所以，intconst 限定*A,不限定A。int *const 限定A,不限定*A。

2.const 限定函数的传递值参数：

　   void Fun(const int Var);

　    分析：上述写法限定参数在函数体中不可被改变。

3.const 限定函数的值型返回值：

const intFun1();

const MyClassFun2();

　    分析:上述写法限定函数的返回值不可被更新，当函数返回内部的类型时（如Fun1），已经是一个数值，当然不可被赋值更新，所以，此时const无意义，最好去掉，以免困惑。当函数返回自定义的类型时（如Fun2），这个类型仍然包含可以被赋值的变量成员，所以，此时有意义。

4. 传递与返回地址： 此种情况最为常见，由地址变量的特点可知，适当使用const，意义昭然。

5.　const 限定类的成员函数：

classClassName {

　public:

　　int Fun() const;

　.....

}

　　注意：采用此种const 后置的形式是一种规定，亦为了不引起混淆。在此函数的声明中和定义中均要使用const,因为const已经成为类型信息的一部分。

获得能力：可以操作常量对象。

失去能力：不能修改类的数据成员，不能在函数中调用其他不是const的函数。