C 语言 inline

C 语言中函数调用与返回时会有部分的额外开销，如果在函数需要调用的次数非常多时，这些额外开销就会产生积累效应。

C89 中避免函数额外开销的唯一方式是使用带参数的宏
- 使用宏造成的缺陷：宏定义在形式上类似于一个函数，但在使用时，仅仅只是做简单替换，因此它不能进行参数有效性的检测，无法执行编译器严格类型检查，另外它的返回值也不能被强制转换为可转换的合适的类型。
C99 中提供了更好的一种方式，即内联函数 inline。内联表明编译器将函数的每一次调用都用函数的机器指令来代替，但其只是建议编译器这样做，并不强制，编译器可以选择忽略。

inline 函数是 C99 标准中添加的一个新的特性，非常适合于经常被调用的小函数。

带参数的宏和 inline 区别

不同	inline 函数	带参数的宏
对应的 C 语言版本	C89	C99
展开的时机	在编译的时候展开，因此 inline 关键字是一个编译关键字	在预处理时展开，因此 #define 关键字是一个预处理关键字
参数类型检查	inline() 函数是一中函数，会进行严格的参数类型检查	不会检查参数类型，只是做简单的字符串替换，因此在使用带参数的宏时会有一些副作用，编写程序是要人为预防
是否允许有复杂语句	不允许出现复杂语句，如果出现复杂语句，该函数将不会展开，例如递归，大型循环等	对此不做要求。宏只是做字符串替换操作，而不了解语句的含义
是否一定被展开	不一定，是否展开由编译器决定	一定，只要使用了宏就可以保证被展开

应用场景

在调用子函数时，通常要经过 保存当前的指令位置，程序流跳转到子函数，执行子函数，返回之前的指令位置 这个过程，但对于那些经常被调用的小函数来说，这样的调用过程会影响程序效率。

inline 函数的调用过程与此不同，它会告诉编译器把那些小函数编译后的机器码放到调用函数的地方，这样就节省了函数调用的时间。

使用方法

关键字 inline 必须与函数的定义体放在一起，才能使函数成为内联函数，仅仅将 inline 放在函数声明前面不起作用，如果想把一个函数定义成 inline 函数，只要在函数定义前面添加 inline 关键字。

例如，下面风格的函数 add_func 将不能成为内联函数：

inline int add_func(int a, int b);
int add_func(int a, int b)
{
    
    
    ...
}

如下风格的函数 add_func 则成为内联函数

int add_func(int a, int b);
inline int add_func(int a, int b)
{
    
    
    ...
}

如果有其他函数调用 inline 函数 add_func ，对比普通的函数调用其过程如下

普通函数调用

···
保存当前指令位置
跳转到 add_func
执行 add_func
返回到之前的指令位置
...

inline 函数调用

···
add_func 编译后的机器码
...

代码示例

现代编译器比较智能，有时候会自动将比较短小的函数编译成 inline 了，如果不需要此特性可以使用 __attribute__((noinline))

static int add_func(int a, int b)
{
    
    
    /* 添加循环 nop 是为了防止编译器把这个函数默认 inline 了 当然也可以使用 __attribute__((noinline)) 属性 */
    for (int i = 0; i < 10; i++)
    {
    
    
        asm volatile("nop");
        asm volatile("nop");
        asm volatile("nop");
        asm volatile("nop");
        asm volatile("nop");
    }
    for (int i = 0; i < 10; i++)
    {
    
    
        asm volatile("nop");
        asm volatile("nop");
        asm volatile("nop");
        asm volatile("nop");
        asm volatile("nop");
    }

    for (int i = 0; i < 10; i++)
    {
    
    
        asm volatile("nop");
        asm volatile("nop");
        asm volatile("nop");
        asm volatile("nop");
        asm volatile("nop");
    }

    return a + b;
}

void Software7_IRQn_Handler(void)
{
    
    
    sgi_7_cnt++;
    add_func(2, 3);
    printf("this is a sgi irq %d\r\n", sgi_7_cnt);
}

`未加 inline 修饰 add_func 时`

Software7_IRQn_Handler 的反汇编是这样的

8000024c <Software7_IRQn_Handler>:
8000024c:	f242 42c4 	movw	r2, #9412	; 0x24c4
80000250:	f2c8 0200 	movt	r2, #32768	; 0x8000
80000254:	b508      	push	{
    
    r3, lr}
80000256:	2103      	movs	r1, #3
80000258:	2002      	movs	r0, #2
8000025a:	6813      	ldr	r3, [r2, #0]
8000025c:	3301      	adds	r3, #1
8000025e:	6013      	str	r3, [r2, #0]
80000260:	f7ff ffdc 	bl	8000021c <add_func>
80000264:	f242 3038 	movw	r0, #9016	; 0x2338
80000268:	f2c8 0000 	movt	r0, #32768	; 0x8000
8000026c:	6811      	ldr	r1, [r2, #0]
8000026e:	e8bd 4008 	ldmia.w	sp!, {
    
    r3, lr}
80000272:	f000 bac7 	b.w	80000804 <printf>
80000276:	bf00      	nop

可以看到代码中有一条 bl 8000021c <add_func> 跳转指令，跳转到 add_func 函数

`加 inline 修饰 add_func 时`

Software7_IRQn_Handler 的反汇编是这样的

8000021c <Software7_IRQn_Handler>:
8000021c:	f242 42ec 	movw	r2, #9452	; 0x24ec
80000220:	f2c8 0200 	movt	r2, #32768	; 0x8000
80000224:	230a      	movs	r3, #10
80000226:	6811      	ldr	r1, [r2, #0]
80000228:	3101      	adds	r1, #1
8000022a:	6011      	str	r1, [r2, #0]
8000022c:	bf00      	nop
8000022e:	bf00      	nop
80000230:	bf00      	nop
80000232:	3b01      	subs	r3, #1
80000234:	d1fa      	bne.n	8000022c <Software7_IRQn_Handler+0x10>
80000236:	230a      	movs	r3, #10
80000238:	bf00      	nop
8000023a:	bf00      	nop
8000023c:	bf00      	nop
8000023e:	bf00      	nop
80000240:	3b01      	subs	r3, #1
80000242:	d1f9      	bne.n	80000238 <Software7_IRQn_Handler+0x1c>
80000244:	230a      	movs	r3, #10
80000246:	bf00      	nop
80000248:	bf00      	nop
8000024a:	bf00      	nop
8000024c:	bf00      	nop
8000024e:	bf00      	nop
80000250:	3b01      	subs	r3, #1
80000252:	d1f8      	bne.n	80000246 <Software7_IRQn_Handler+0x2a>
80000254:	f242 3060 	movw	r0, #9056	; 0x2360
80000258:	f2c8 0000 	movt	r0, #32768	; 0x8000
8000025c:	6811      	ldr	r1, [r2, #0]
8000025e:	f000 bad5 	b.w	8000080c <printf>
80000262:	bf00      	nop

可以看到代码中没有跳转指令，而是将 add_func 函数展开放在了对应的位置

强制 inline

inline 关键字只是对编译器的建议，如果编译器认为需要 inline 的函数太复杂，使用 inline 关键字修饰的函数可能在编译的时候可能并不会真正 inline。

这时可以使用 __attribute__((always_inline)) 属性来强制 inline。

static __attribute__((always_inline)) inline int add_func(int a, int b)
{
    
    
    ......
}

需要注意的是，使用 __attribute__((always_inline)) 强制 inline 时，函数最好还要加上 inline，否则也可能没有 inline 成功。

特点

inline 函数中不能定义可改变的 static 变量
inline 函数中不能引用具有内部链接的变量

与普通函数区别

nline 函数除了调用方式不同外，它和一般的函数没有区别，它也有自己的地址。如果 inline 函数中用到了宏，宏会被预处理器展开。

不构成外部定义

inline 定义特别针对翻译单元，不构成外部定义，别的翻译单元可以包含这个 inline 函数的外部定义。但是如果一个已经被定义成 inline 函数的函数被存储类修饰符 extern 修饰，那么它就会具有外部链接属性。

头文件定义

翻译单元只要用到某个 inline 函数，必须重复定义此 inline 函数，因此，inline 函数的定义常常被放在头文件中。

因为内联函数要在调用点展开，所以编译器必须随处可见内联函数的定义，要不然就成了非内联函数的调用了。所以，这要求每个调用了内联函数的文件都出现了该内联函数的定义。

因此，将内联函数的定义放在头文件里实现是合适的，省却你为每个文件实现一次的麻烦。

声明跟定义要一致：如果在每个文件里都实现一次该内联函数的话，那么，最好保证每个定义都是一样的，否则，将会引起未定义的行为。如果不是每个文件里的定义都一样，那么，编译器展开的是哪一个，那要看具体的编译器而定。所以，最好将内联函数定义放在头文件中。

不能包含复杂结构

一般来说，不应该将包含循环的函数定义成 inline 函数
inline 只适合函数体内代码比较简单的函数使用，不能包含复杂的结构控制语句，例如 while、switch，并且内联函数本身不能是直接递归函数（函数内部调用自己的函数）

对编译器的建议

inline 函数仅仅是一个对编译器的建议，所以最后能否真正内联，看编译器的意思，它如果认为函数不复杂，能在调用点展开，就会真正内联，并不是说声明了内联就会内联，声明内联只是一个建议而已

代码膨胀

内联能提高函数的执行效率，为什么不把所有的函数都定义成内联函数？如果所有的函数都是内联函数，还用得着 内联 这个关键字吗？
内联是以代码膨胀（复制）为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。

所以，inline 函数一般只会用在函数内容非常简单的时候，这是因为内联函数的代码会在任何调用它的地方展开，如果函数太复杂，代码膨胀带来的恶果很可能会大于效率的提高带来的益处

static 和 inline 联合使用

static 是静态修饰符，由其关键字修饰的变量会保存到全局数据区，对于普通的局部变量或者全局变量，都是由系统自动分配内存的，并且当变量离开作用域的时候释放掉，而使用 static 关键字来修饰，只有当程序结束时候才会释放掉，

使用 static inline 修饰时，函数仅在文件内部可见，不会污染命名空间。

另外，函数在运行过程中也会分配内存空间，但是由于 static 的存在，就和修饰变量类似，它只会开辟一块内存空间。

inline 和 #define 的区别

inline 由编译器一起处理，直接将函数体插入调用的地方。
#define 由预处理器处理，进行简单的文本替换，没有任何编译过程。

参考链接

https://blog.csdn.net/weaiken/article/details/88085360
https://zhuanlan.zhihu.com/p/448262183

【C语言】- inline

文章目录