普通函数和内联函数区别验证

最新推荐文章于 2024-07-08 21:23:20 发布
最新推荐文章于 2024-07-08 21:23:20 发布
阅读量112 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43904540/article/details/128981918
版权

本篇文章主要验证普通函数和内联函数的区别

Inline_function.cpp

__attribute__((always_inline))
inline void func() {
    int j = 0;
    for (int i = 0; i < 2; i++) {
        j++;
        if (j == 20) j *= 2;
    }
}

int main() {
    func();
    func();
    func();
    func();
    func();
    return 0;
}

__attribute__((always_inline))告诉编译器强制内联。

outline_function.cpp

void func() __attribute__((noinline));
void func() {
    int j = 0;
    for (int i = 0; i < 2; i++) {
        j++;
        if (j == 20) j *= 2;
    }
}

int main() {
    func();
    func();
    func();
    func();
    func();
    return 0;
}

__attribute__((noinline))告诉编译器一定不要内联

让我们分别编译下并反汇编一下可执行文件：

$ g++ -O0 inline_function.cpp -o inline_out_file.app
$ g++ -O0 outline_function.cpp -o outline_out_file.app
$ objdump -d inline_out_file.app | less
0000000100003e50 <_main>:
100003e50: 55                          	pushq	%rbp
100003e51: 48 89 e5                    	movq	%rsp, %rbp
100003e54: c7 45 d4 00 00 00 00        	movl	$0, -44(%rbp)
100003e5b: c7 45 dc 00 00 00 00        	movl	$0, -36(%rbp)
100003e62: c7 45 d8 00 00 00 00        	movl	$0, -40(%rbp)
100003e69: 83 7d d8 02                 	cmpl	$2, -40(%rbp)
100003e6d: 0f 8d 2a 00 00 00           	jge	0x100003e9d <_main+0x4d>
100003e73: 8b 45 dc                    	movl	-36(%rbp), %eax
100003e76: 83 c0 01                    	addl	$1, %eax
100003e79: 89 45 dc                    	movl	%eax, -36(%rbp)
100003e7c: 83 7d dc 14                 	cmpl	$20, -36(%rbp)
100003e80: 0f 85 09 00 00 00           	jne	0x100003e8f <_main+0x3f>
100003e86: 8b 45 dc                    	movl	-36(%rbp), %eax
100003e89: c1 e0 01                    	shll	$1, %eax
100003e8c: 89 45 dc                    	movl	%eax, -36(%rbp)
100003e8f: 8b 45 d8                    	movl	-40(%rbp), %eax
100003e92: 83 c0 01                    	addl	$1, %eax
100003e95: 89 45 d8                    	movl	%eax, -40(%rbp)
100003e98: e9 cc ff ff ff              	jmp	0x100003e69 <_main+0x19>
100003e9d: c7 45 fc 00 00 00 00        	movl	$0, -4(%rbp)
100003ea4: c7 45 f8 00 00 00 00        	movl	$0, -8(%rbp)
100003eab: 83 7d f8 02                 	cmpl	$2, -8(%rbp)
100003eaf: 0f 8d 2a 00 00 00           	jge	0x100003edf <_main+0x8f>
100003eb5: 8b 45 fc                    	movl	-4(%rbp), %eax
100003eb8: 83 c0 01                    	addl	$1, %eax
100003ebb: 89 45 fc                    	movl	%eax, -4(%rbp)
100003ebe: 83 7d fc 14                 	cmpl	$20, -4(%rbp)
100003ec2: 0f 85 09 00 00 00           	jne	0x100003ed1 <_main+0x81>
100003ec8: 8b 45 fc                    	movl	-4(%rbp), %eax
100003ecb: c1 e0 01                    	shll	$1, %eax
100003ece: 89 45 fc                    	movl	%eax, -4(%rbp)
100003ed1: 8b 45 f8                    	movl	-8(%rbp), %eax
100003ed4: 83 c0 01                    	addl	$1, %eax
100003ed7: 89 45 f8                    	movl	%eax, -8(%rbp)
100003eda: e9 cc ff ff ff              	jmp	0x100003eab <_main+0x5b>
100003edf: c7 45 f4 00 00 00 00        	movl	$0, -12(%rbp)
100003ee6: c7 45 f0 00 00 00 00        	movl	$0, -16(%rbp)
100003eed: 83 7d f0 02                 	cmpl	$2, -16(%rbp)
100003ef1: 0f 8d 2a 00 00 00           	jge	0x100003f21 <_main+0xd1>
100003ef7: 8b 45 f4                    	movl	-12(%rbp), %eax
100003efa: 83 c0 01                    	addl	$1, %eax
100003efd: 89 45 f4                    	movl	%eax, -12(%rbp)
100003f00: 83 7d f4 14                 	cmpl	$20, -12(%rbp)
100003f04: 0f 85 09 00 00 00           	jne	0x100003f13 <_main+0xc3>
100003f0a: 8b 45 f4                    	movl	-12(%rbp), %eax
100003f0d: c1 e0 01                    	shll	$1, %eax
100003f10: 89 45 f4                    	movl	%eax, -12(%rbp)
100003f13: 8b 45 f0                    	movl	-16(%rbp), %eax
100003f16: 83 c0 01                    	addl	$1, %eax
100003f19: 89 45 f0                    	movl	%eax, -16(%rbp)
100003f1c: e9 cc ff ff ff              	jmp	0x100003eed <_main+0x9d>
100003f21: c7 45 ec 00 00 00 00        	movl	$0, -20(%rbp)
100003f28: c7 45 e8 00 00 00 00        	movl	$0, -24(%rbp)
100003f2f: 83 7d e8 02                 	cmpl	$2, -24(%rbp)
100003f33: 0f 8d 2a 00 00 00           	jge	0x100003f63 <_main+0x113>
100003f39: 8b 45 ec                    	movl	-20(%rbp), %eax
100003f3c: 83 c0 01                    	addl	$1, %eax
100003f3f: 89 45 ec                    	movl	%eax, -20(%rbp)
100003f42: 83 7d ec 14                 	cmpl	$20, -20(%rbp)
100003f46: 0f 85 09 00 00 00           	jne	0x100003f55 <_main+0x105>
100003f4c: 8b 45 ec                    	movl	-20(%rbp), %eax
100003f4f: c1 e0 01                    	shll	$1, %eax
100003f52: 89 45 ec                    	movl	%eax, -20(%rbp)
100003f55: 8b 45 e8                    	movl	-24(%rbp), %eax
100003f58: 83 c0 01                    	addl	$1, %eax
100003f5b: 89 45 e8                    	movl	%eax, -24(%rbp)
100003f5e: e9 cc ff ff ff              	jmp	0x100003f2f <_main+0xdf>
100003f63: c7 45 e4 00 00 00 00        	movl	$0, -28(%rbp)
100003f6a: c7 45 e0 00 00 00 00        	movl	$0, -32(%rbp)
100003f71: 83 7d e0 02                 	cmpl	$2, -32(%rbp)
100003f75: 0f 8d 2a 00 00 00           	jge	0x100003fa5 <_main+0x155>
100003f7b: 8b 45 e4                    	movl	-28(%rbp), %eax
100003f7e: 83 c0 01                    	addl	$1, %eax
100003f81: 89 45 e4                    	movl	%eax, -28(%rbp)
100003f84: 83 7d e4 14                 	cmpl	$20, -28(%rbp)
100003f88: 0f 85 09 00 00 00           	jne	0x100003f97 <_main+0x147>
100003f8e: 8b 45 e4                    	movl	-28(%rbp), %eax
100003f91: c1 e0 01                    	shll	$1, %eax
100003f94: 89 45 e4                    	movl	%eax, -28(%rbp)
100003f97: 8b 45 e0                    	movl	-32(%rbp), %eax
100003f9a: 83 c0 01                    	addl	$1, %eax
100003f9d: 89 45 e0                    	movl	%eax, -32(%rbp)
100003fa0: e9 cc ff ff ff              	jmp	0x100003f71 <_main+0x121>
100003fa5: 31 c0                       	xorl	%eax, %eax
100003fa7: 5d                          	popq	%rbp
100003fa8: c3                          	retq

$ objdump -d outline_out_file.app | less
0000000100003f80 <_main>:
100003f80: 55                           pushq   %rbp
100003f81: 48 89 e5                     movq    %rsp, %rbp
100003f84: 48 83 ec 10                  subq    $16, %rsp
100003f88: c7 45 fc 00 00 00 00         movl    $0, -4(%rbp)
100003f8f: e8 9c ff ff ff               callq   0x100003f30 <__Z4funcv>
100003f94: e8 97 ff ff ff               callq   0x100003f30 <__Z4funcv>
100003f99: e8 92 ff ff ff               callq   0x100003f30 <__Z4funcv>
100003f9e: e8 8d ff ff ff               callq   0x100003f30 <__Z4funcv>
100003fa3: e8 88 ff ff ff               callq   0x100003f30 <__Z4funcv>
100003fa8: 31 c0                        xorl    %eax, %eax
100003faa: 48 83 c4 10                  addq    $16, %rsp
100003fae: 5d                           popq    %rbp
100003faf: c3                           retq

可以看出来普通函数都是用call来调用函数，生成的可执行文件比较小。而内联函数则是把函数体复制粘贴，生成的可执行文件比较大

weixin_43904540
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【C/C++】宏函数与内联函数的区别
Sunnyside_
10-16 1837
知识点：宏函数与内联函数 文章目录知识点：宏函数与内联函数一、概念二、特性三、优缺点四、笔试题五、总结 一、概念   以inline修饰的函数就叫做内联函数，C++编译器在编译时会在调用内联函数时地方展开，没有函数压栈的开销，内联函数提升程序的运行效率。   内联函数在调用时不是像一般函数那样要转去执行被调用函数的函数体，执行完成后在转回调用函数中，执行其后的语句；而是在调用处 用内联函数体 的代码来替换，以这样的方式结婚时呢个调用开销，提高运行效率。 #include<iostream> u
宏定义函数-普通函数-内联函数区别
DLililiDengDaa~~
07-04 592
宏定义函数VS普通函数VS内联函数 宏定义函数VS普通函数 宏定义函数 要点：变量都用括号括起来，防止出错，结尾不需要;。在实际编程中，不推荐把复杂的函数使用宏，不容易调试。多行用\ 例子: 单行: #define MAX(a, b) ((a) > (b) ? (a):(b)) 多行: #define MALLOC(n, type) \ ((type *) malloc((n)*...
内联函数与普通函数
weixin_40775703的博客
03-17 217
内联函数写法： inline int func(int a) { } 内联函数与普通函数区别： 普通函数调用时需要跳转到另一个地方执行，执行完毕再跳回； 内联函数调用时不用跳转到另一个地方执行，直接把该函数的代码拷贝到程序中需要调用的位置，时间开销较小但空间开销更大。 ...
测内联函数的效率
Richard___Chen的博客
10-27 252
#include #include using namespace std; inline int comp1(int a,int b) { return (a>b)?a:b; } int comp2(int a,int b) { return (a>b)?a:b; } main() { double t1,t2; t1=(double)clock(); for(i
第6课 内联函数分析
lzg2011的博客
02-16 183
本文内容取自于对狄泰学院 唐佐林老师 C++深度解析 课程的学习总结 常量与宏回顾 C++中的const常量可以替代宏常数定义，如： 宏代码在预处理时直接拷贝，虽然节省了栈的开销，但不会做语法检查，为了解决这一问题，C++中引入了内联函数 内联函数 C++中推荐使用内联函数替代宏代码片段 C++中使用inline关键字声明内联函数 inline int func(int...
内联函数(inline 函数)详解
wangyx1234的博客
04-26 6579
inline 函数详解 内联函数和普通函数一样，区别仅仅是在被调用处使用机器码的形式。 采用机器码的目的是：减少因调用而造成的开销，加速执行效率。 适用场景：经常调用的小函数。可以在头文件中定义这些内联函数。 不适合的场景：包含大循环、递归的函数。 使用内联时的调用方法： 不使用内联时的调用方法： 测试程序：
一文搞懂内联函数！
热门推荐
Linux猿
08-14 2万+
???? 作者：Linux猿 ???? 简介：CSDN博客专家????，C/C++、面试、刷题、算法尽管咨询我，关注我，有问题私聊！ ???? 关注专栏：C/C++面试通关集锦（优质好文持续更新中……）???? 目录 一、什么是内敛函数？ 二、为什么要使用内联函数 ？ 三、哪些函数不能是内联函数？ 四、使用内联函数的缺点 五、总结 内敛函数想必大家都很熟悉，适当的使用内敛函数可以提高程序的执行效率。本篇文章就来讲解下内敛函数，赶紧来看下吧！ 一、什么是内敛函数？ 内敛函数是在 C++
友元函数,内联函数
ZJQ的博客
10-13 1162
类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。 友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。 如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字friend， 代码...
kotlin内联函数
MirkoWug的博客
06-23 2114
今天的主角是 inline ，这不是一个 Kotlin 特有的概念，大多数编程语言都支持内联。 内联函数 的语义很简单：把函数体复制粘贴到函数调用处 。使用起来也毫无困难，用 inline关键字修饰函数即可。 然而问题的关键并不是如何使用 inline ，而是什么时候使用  inline ?  既然 Kotlin 提供了内联，它肯定是为了性能优化而存在的，那么，它又真的是包治百病的性能良药吗？ ...
内部函数intrins.h应用举例-综合文档
05-23
在编程领域，内部函数（ Intrinsics）是一种特殊的函数，它们被编译器直接转换为特定的机器指令，以提供比普通函数调用更高的性能。在Windows SDK中，`intrins.h`头文件提供了对这些内部函数的访问。这篇文章将深入...
TeamViewer_Permissions_Hook_V1：可注入C ++ dll的概念证明，它使用裸露的内联挂钩和直接内存修改来更改您的TeamViewer权限
02-02
在这个项目中，`TeamViewer_Permissions_Hook_V1` 是一个C++编写的DLL注入概念验证，它的目标是演示如何利用内联挂钩（inline hooking）和直接内存修改技术来改变TeamViewer应用的权限设置。下面我们将深入探讨这个...
js-quiz:这是一个用于显示测验的普通javascript项目
03-30
在js-quiz-master这个压缩包文件中，我们可以找到项目的所有源代码，包括HTML文件（可能包含基本的页面结构和JavaScript内联代码）、CSS文件（用于样式定义）以及JavaScript文件（包含主要的逻辑代码）。通过查看和...
eval的两组性能测试数据
09-05
**用例A5**：将`eval`替换为另一个空函数`f`，结果显示，非`eval`的函数调用比`eval`更快，表明`eval`的解析和执行过程比普通函数更复杂。 **用例A6**：通过将`eval`赋值给另一个变量`f`，然后调用`f`，我们看到...
asp源码—asp鱼X小论坛源码 v1.01.zip
02-07
6. **权限管理**：设定不同用户角色（如管理员、普通用户）的权限，控制他们可以访问和操作的功能。 7. **错误处理**：编写错误处理代码，捕获和报告运行时错误，保证系统的稳定性和用户体验。 【ASP编程细节】 - ...
C++初学者指南-3.自定义类型(第一部分)-析构函数
silencestarsky的博客
07-02 629
本文介绍了C++初学者指南中关于自定义类型和析构函数的重要内容。主要涵盖了特殊的成员函数如构造函数和析构函数的作用，RAII资源管理的重要性以及避免编写特殊成员函数的建议。
c++习题08-计算星期几
码到成龚的博客
07-03 597
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
Android 开发中 C++ 和Java 日志调试
小羊子的技术专栏
07-04 914
Android 开发中 C++ 和Java 日志调试方法小结
机器人运动范围检测 c++
m0_61862494的博客
07-02 764
地上有一个m行n列的方格，一个机器人从坐标（0，0）的格子开始移动，它每次可以向上下左右移动一个格子，但不能进入行坐标和列坐标的位数之和大于k的格子，请问机器人能够到达多少个格子。这个算法的时间复杂度为O(mn)，其中m和n分别是网格的行数和列数。空间复杂度也是O(mn)，主要用于存储visited数组和BFS队列。这个实现使用了广度优先搜索（BFS）算法来解决问题。
数学系C++ 继承派生多态 （十四十三）
最新发布
m0_68339197的博客
07-08 216
可以使得派生类具有父类的各种属性和功能，而不需要再次编写相同的代码。类的继承：派生类继承了父类的特性（数据和函数）► 继承是可传递的：从父类继承的特性可以传递给新的子类► 继承方式：规定了如何访问从父类继承的成员► 继承方式有三种：public、protected、private► 派生类成员：从父类继承的成员+新增加的成员继承方式不同，访问控制不同 父类成员函数访问父类成员：正常访问 派生类成员函数访问派生类新增成员：正常访问 父类成员函数访问派生类新增成员：不能访问。
引进内联函数与普通函数区别
05-26
内联函数和普通函数最大的区别在于编译器处理方式不同。 普通函数在程序运行时，每次调用都会产生一定的函数调用开销，包括参数压栈、函数调用、返回值等操作。这些操作会占用一定的CPU时间和内存空间。如果一个函数被频繁调用，这些开销会影响程序的性能。 而内联函数在编译时会被直接展开到调用处，不会产生函数调用开销，因此可以有效提高程序的执行效率。内联函数适用于函数体较小，且被频繁调用的情况。 此外，内联函数在使用时需要注意以下几点： 1. 内联函数定义必须在调用处之前，否则编译器无法展开函数。 2. 内联函数不能包含复杂的控制结构，如循环、递归等。 3. 内联函数的代码会被直接插入到调用处，因此会增加代码的大小，可能会影响程序的内存占用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值