（一〇二）内联函数

元旦了，各种打不开博客。元旦结束，博客好了，是因为元旦放假程序员都回家了嘛？

————————————————————————————————

内联函数和普通函数有所区别。

 

普通函数需要①函数定义②函数原型③函数调用，具体调用形式是，先调用时，储存当前函数的内存地址（假设为地址A），然后调用函数，跳到被调用函数的内存地址（地址B），然后在地址B处依次执行，等执行完被调用的函数（或许还有返回值），再返回之前储存的地址A处。

 

内联函数，可以省略②函数原型（也可以不省略），但需要在函数定义和函数原型的函数头之前加上关键字inline（如果省略函数原型的话，则一般将函数定义放在函数原型的地方），

他的机制，是把函数代码，放在函数调用时的内存地址处，这样的话，无需像普通函数那样，从地址A处跳到地址B处，调用完再跳回来，而是地址A处之后的内存位置，就是原本是地址B处函数的代码内容。就像直接将函数命令放在调用处一样。

 

例如：

int main()
{
int a=x(1);

return 0;

}

int x(int m)

{
return m+3;

}

 

在普通函数时，int a的内存地址是地址A，而x函数被储存在地址B处（注意，B和A并不一定相邻，或者说，几乎不会相邻）。于是程序访问内存时的顺序：地址A——地址B——地址A这样。

 

而在内联函数时，在int x(int m)之前加上inline，在main函数中，有点类似于：

int a={ 1 + 3 };

这样的形式。

 

由于内联函数是直接放在main函数中（而不是调用的时候才占用内存），因此，使用内联函数更耗费内存。但相对而言，使用内联函数的优点则是速度更快（因为不用在内存之中跳来跳去）。

 

但，由于在内存地址中跳来跳去速度其实很快，所以节省的时间的绝对值，并不大，除非该函数经常被调用（每次节约0.01秒，100次就是1秒了）。

 

内联函数的优点：速度更快——适合执行代码时间很短的函数；

内联函数的缺点：占用内存更多——不适合较长的函数。

 

 

编译器不允许使用内联函数的两种情况：

①递归函数——内联函数不允许自己调用自己；

②函数过大。

 

 

内联函数的使用方式：

①在函数原型和函数定义的函数头之前加上关键字inline即可；

 

②可省略函数原型，若省略，则将函数定义放置于函数原型处较好；

 

③其他同普通函数。

 

如代码：

#include<iostream>

inline int chengfang(int a)	//函数定义前置于函数原型处，并可省略函数原型
{
	return a*a;
}

int main()
{
	using namespace std;
	int b = chengfang(2);	//像普通函数那样调用内联函数
	int c = chengfang(5);
	cout << "b = " << b << ". c = " << c << endl;
	cin.get();
	return 0;
}

输出：

b = 4. c = 25

与内联函数对应的宏：

在C语言中，使用预处理器语句#define来提供宏——内联代码的原始实现。

例如宏：#define SQUAR(X) X*X;

 

宏的特点是文本替换，而不像内联函数那样是函数调用——也就意味着，没有括号的情况下，结果和内联函数的结果不同。

如define的代码：

#include<iostream>

#define square(x)	x*x;

int main()
{
	using namespace std;
	int a[5];
	a[0] = square(1);	//实质是1*1=1
	a[1] = square(2);	//实质是2*2=4
	a[2] = square(2 * 2);	//实质是2*2 * 2*2=16
	a[3] = square(2 + 2);	//实质是2 + 2*2 + 2=8
	a[4] = square(2 + 0);	//实质是2 + 0*2 + 0=2
	for (int i = 0;i < 5;i++)
		cout << "a[" << i << "] = " << a[i] << endl;
	system("pause");
	return 0;
}

输出：

a[0] = 1
a[1] = 4
a[2] = 16
a[3] = 8
a[4] = 2
请按任意键继续. . .

使用内联函数的代码：

#include<iostream>

inline int square(int x) { return x*x; }

int main()
{
	using namespace std;
	int a[5];
	a[0] = square(1);	//实质是1*1
	a[1] = square(2);	//实质是2*2=4
	a[2] = square(2 * 2);	//实质是(2*2) * (2*2)=16
	a[3] = square(2 + 2);	//实质是(2+2) * (2+2)=4*4=16
	a[4] = square(2 + 0);	//实质是(2+0) * (2+0)=2*2=4
	for (int i = 0;i < 5;i++)
		cout << "a[" << i << "] = " << a[i] << endl;
	system("pause");
	return 0;
}

输出：

a[0] = 1
a[1] = 4
a[2] = 16
a[3] = 16
a[4] = 4
请按任意键继续. . .

由上述两个例子可以看出，#define宏的效果，和inline内联函数的机制完全不同。

 

#define是文本替换，将括号里的内容直接赋值到表达式之中——而不是括号里表达式的结果。

 

inline是像函数调用那样，将表达式的值得出值的结果后，再放入函数内部的表达式之中。

 

特别是比如说：#define MM(m) m*m*m; 这样的宏，

当遇见调用int a=1; int b=MM(a++);时，

在代码中，b=1*2*3=6，

而不是内联函数的b=1*1*1（因为a++是先执行完这行代码之后，a=a+1）；