C++宏,普通函数,内联函数的运行速度以及三者的差异

</pre>下面论证一下:c/c++中 运行速度对比,宏>内联函数>普通函数   以及3者的差异<p></p><p></p><p>首先简单的代码验证下:</p><p>#include <iostream></p><pre name="code" class="cpp">
#include <boost/timer.hpp>


#define  _SUM(x,y) x+y
using std::cout;
using std::endl;
using boost::timer;

const int MAX_ARR_SIZE = 50000;

int sum1(int a,int b)
{
    return a + b;
}

inline int sum2(int a,int b)
{
    return a + b;
}

int main(void)
{
    long iarray1[MAX_ARR_SIZE];
    long iarray2[MAX_ARR_SIZE];

    timer t1;
    cout<<t1.elapsed()<<endl;
    for (size_t star1(0); star1 < MAX_ARR_SIZE;++star1)
    {
        iarray1[star1] = star1;
    }

    for (size_t star1(0); star1 < MAX_ARR_SIZE; ++star1)
    {
        iarray2[star1] = star1;
    }
    double tt1 = t1.elapsed();
    cout << t1.elapsed()<<endl;

    for (size_t star1(0); star1 < MAX_ARR_SIZE; ++star1)
    {
        long result = sum1(iarray1[star1], iarray2[star1]);
        if (star1 == MAX_ARR_SIZE-1)
        {
            cout << "非内联:" << iarray1[star1] << " + " << iarray2[star1]<<" = " << result << endl;
        }
    }
    cout << "执行非内联的sum1的时间为:" << t1.elapsed() - tt1<<endl;

    double tt2 = t1.elapsed();

    for (size_t star1(0); star1 < MAX_ARR_SIZE; ++star1)
    {
        long result = sum2(iarray1[star1], iarray2[star1]);
        if (star1 == MAX_ARR_SIZE - 1)
        {
            cout << "内联:" << iarray1[star1] << " + " << iarray2[star1] << " = " << result << endl;
        }
    }
    cout << "执行内联的sum2的时间为:" << t1.elapsed() - tt2 << endl;

    double tt3 = t1.elapsed();

    for (size_t star1(0); star1 < MAX_ARR_SIZE; ++star1)
    {
        long result = _SUM(iarray1[star1], iarray2[star1]);
        if (star1 == MAX_ARR_SIZE - 1)
        {
            cout << "宏:" << iarray1[star1] << " + " << iarray2[star1] << " = " << result << endl;
        }
    }
    cout << "执行宏的_SUM的时间为:" << t1.elapsed() - tt3 << endl;

    return 0;
}

运行结果为下:

0
0.047
非内联:49999 + 49999 = 99998
执行非内联的sum1的时间为:0.014
内联:49999 + 49999 = 99998
执行内联的sum2的时间为:0.006
宏:49999 + 49999 = 99998
执行宏的_SUM的时间为:0.004


老爷机,性能比较差,但结果比较明显,宏>内联函数>普通函数


原因下面分析:


写个最简单的测试程序:

test1.c    这个测试下宏

#include<stdio.h>

#define _SUM(x,y) x+y

void main()
{
   printf("%d\n",_SUM(5,6));
}


对test1.c执行预编译 :

#gcc -E test1.c -o test1.i

得到下面结果  test1.i

...以上省略啊(包含的头文件加进来)

# 2 "test1.c" 2



void main()
{
   printf("%d\n",5 +6);
}

由此可见,在预编译时期,宏被展开了


再将预编译后的文件test1.i 进行编译

gcc –S test1.i –o test1.s

得到以下结果: test1.S

    .file    "test1.c"
    .section    .rodata
.LC0:
    .string    "%d\n"
    .text
.globl main
    .type    main, @function
main:
    pushl    %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $16, %esp
    movl    $.LC0, %eax
    movl    $11, 4(%esp)       #在这里我们的表达式在编译时期计算出来,并转换为了立即数
    movl    %eax, (%esp)
    call    printf
    leave
    ret
    .size    main, .-main
    .ident    "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
    .section    .note.GNU-stack,"",@progbits


宏表达式被转换成了立即数


下面是测试代码2:普通函数的

test2.c

#include<stdio.h>

int sum(int x,int y)
{
   return x+y;
}

void main()
{
    printf("%d\n",sum(5,6));
}


同样将其预编译:

gcc -E test2.c -o test2.i

得到下面代码:

....

# 2 "test2.c" 2

int sum(int x,int y)
{
   return x+y;
}

void main()
{
    printf("%d\n",sum(5,6));
}

再将其编译:

gcc -S test2.i -o test2.S

得到下面代码:

    .file    "test2.c"
    .text
.globl sum
    .type    sum, @function
sum:
    pushl    %ebp
    movl    %esp, %ebp
    movl    12(%ebp), %eax
    movl    8(%ebp), %edx
    leal    (%edx,%eax), %eax
    popl    %ebp
    ret
    .size    sum, .-sum
    .section    .rodata
.LC0:
    .string    "%d\n"
    .text
.globl main
    .type    main, @function
main:
    pushl    %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $16, %esp
    movl    $6, 4(%esp)
    movl    $5, (%esp)
    call    sum                             #在这个地方产生了函数调用,也是使程序运行速度下降的原因
    movl    $.LC0, %edx
    movl    %eax, 4(%esp)
    movl    %edx, (%esp)
    call    printf
    leave
    ret
    .size    main, .-main
    .ident    "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
    .section    .note.GNU-stack,"",@progbits


可见上面程序产生了函数掉用,即参数的压栈


下面是测试代码3:测试内联函数的

test3.c


#include<stdio.h>

inline int sum(int x, int y) __attribute__((always_inline)); //注意这里加上编译属性,让编译器始终展开此内联函数,否则编译出来后跟普通函数没啥区别

inline int sum(int x, int y)
{
    return x + y;
}

void main()
{
    printf("%d\n",sum(5,6));
}


同样先预编译:

gcc -E test3.c -o test3.i

得到下面代码: test3.i

....

# 2 "test3.c" 2

inline int sum(int x, int y) __attribute__((always_inline));

inline int sum(int x, int y)
{
    return x + y;
}

void main()
{
    printf("%d\n",sum(5,6));
}

由此可见,内联函数的展开不管预编译的事情,明显是在编译时展开的


下面将 test3.i编译

gcc -S tets3.i -o test3.S

得到下面的代码 test3.S:

    .file    "test4.c"
    .text
.globl sum
    .type    sum, @function
sum:
    pushl    %ebp
    movl    %esp, %ebp
    movl    12(%ebp), %eax
    movl    8(%ebp), %edx
    leal    (%edx,%eax), %eax
    popl    %ebp
    ret
    .size    sum, .-sum
    .section    .rodata
.LC0:
    .string    "%d\n"
    .text
.globl main
    .type    main, @function
main:
    pushl    %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $32, %esp
    movl    $5, 28(%esp)
    movl    $6, 24(%esp)
    movl    24(%esp), %eax
    movl    28(%esp), %edx
    leal    (%edx,%eax), %eax  #这里可以看出,没有产生函数调用,而是将sum的代码展开在此
    movl    %eax, %edx
    movl    $.LC0, %eax
    movl    %edx, 4(%esp)
    movl    %eax, (%esp)
    call    printf
    leave
    ret
    .size    main, .-main
    .ident    "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
    .section    .note.GNU-stack,"",@progbits

上面可以清楚的看到,编译器将内联函数展开到了函数的调用出,并减少了函数调用产生的效率和压栈操作,所以效率比普通函数调用要高一些

但是比起宏直接转换为立即数肯定还是要低点,毕竟内联函数展开后,代码量都比宏展开的多,很明显。而宏的话在预编译的时候就已经被展开了,在编译时期就是

当成一个普通表达式处理,而无关任何函数调用的事情。


好,现在已经论证完,宏,普通函数,内联函数的差异,以及三者的运行速度问题了。关于三者什么时候用,什么情况下用,后面再讨论吧。

展开阅读全文

没有更多推荐了,返回首页