C++ 需要更多的开销

匿名网友：现在很少有高级语言能做到C的效率的，这就是C长青的基本保障。JAVA运行需要JVM，PHP,ASP

等需要脚本解释器，.NET需要中间语言转换（这个我不怎么清楚），C++ 需要更多的开销来实现复杂的对

象关系，在很多的低配置的系统里面，只有1K的内存，16K的FLASH，这点资源，不说一个JVM，就连一个

简单的解释器的很难放的下，在这样的环境下，你可以不选择C，但是你能选的就只有汇编了。因此，C虽然

比较繁琐，功能不够强大（就是封装的不够高），没有很多现成的类库或对象支持，但是其用途却是具有不

可替代性。

C++ 需要更多的开销来实现复杂的对象关系

请问各位大哥这句话怎么解释啊？不是说c
是c++的子集吗？

难道c++实现不了c的这样的效果？
还是这句话是个菜鸟说得？
谢谢了。。。。。。。。

38 个解决方案

#1

看《深入探索C++对象模型》

#2

你要是能从底层去剖析C++；还怕不能用;

#3

据个例子，c++为了让你能多态，所以他实际虚函数机制时背着你做了一些需要额外开销的事情。
如虚函数表。

当然这样的事情干了很多。

#4

C++ 需要更多的开销来实现复杂的对象关系
=================
看跟什么比，如果同空气比，的确多了virtual指针等。
但是如果用c来实现面向对象，我想综合起来考虑还是c++好些吧。

#5

OO不是放之四海而皆准的神物，
一些小型应用，OO不会带来什么好处，
例如门禁考勤机，要OO做什么?

#6

c拼　c++?

#7

new delete啊，构造函数，指针，内存堆管理，C++很多特性都需要很大的开销吧。我猜的

#8

如果你真的需要那些“关系”，那C语言实现恐怕开销更大。
如果你不真的需要那些“关系”，那C++代码同样不会要你付出什么额外开销。
关键是太多人不知道自己是否真的需要，而是为了C++而C++的。

#9

c++也可以像C一样高效。
不爱用c++的对象，就用泛型呗。比C灵活效率还高

#10

C++ 需要更多的开销来实现复杂的对象关系
-------------------------------------
这句话指的是C++继承、多态等OOP特性的实现需要比较多的代码量。

另外c与c++是交集，不是子集。对于C与C++的不同，想认真写的话，写一本书出来毫不夸张。

#11

#include <stdio.h>


int main()

{

        puts("AAA");

}

当C程序编译:

        .file   "t.c"

        .section        .rodata

.LC0:

        .string "AAA"

        .text

.globl main

        .type   main, @function

main:

        leal    4(%esp), %ecx

        andl    $-16, %esp

        pushl   -4(%ecx)

        pushl   %ebp

        movl    %esp, %ebp

        pushl   %ecx

        subl    $20, %esp

        movl    $.LC0, (%esp)

        call    puts

        addl    $20, %esp

        popl    %ecx

        popl    %ebp

        leal    -4(%ecx), %esp

        ret 

        .size   main, .-main

        .ident  "GCC: (Debian 4.3.4-6) 4.3.4"

        .section        .note.GNU-stack,"",@progbits

当作C++编译:

        .file   "t.c"

        .section        .rodata

.LC0:

        .string "AAA"

        .text

.globl main

        .type   main, @function

main:

.LFB2:  

        leal    4(%esp), %ecx

.LCFI0: 

        andl    $-16, %esp

        pushl   -4(%ecx)

.LCFI1: 

        pushl   %ebp 

.LCFI2: 

        movl    %esp, %ebp

.LCFI3: 

        pushl   %ecx

.LCFI4: 

        subl    $4, %esp

.LCFI5: 

        movl    $.LC0, (%esp)

        call    puts

        movl    $0, %eax

        addl    $4, %esp

        popl    %ecx

        popl    %ebp

        leal    -4(%ecx), %esp

        ret

.LFE2:

        .size   main, .-main

        .section        .eh_frame,"a",@progbits

.Lframe1:

        .long   .LECIE1-.LSCIE1

.LSCIE1:

        .long   0x0

        .byte   0x1

.globl __gxx_personality_v0

        .string "zP"

        .uleb128 0x1

        .sleb128 -4

        .byte   0x8

        .uleb128 0x5

        .byte   0x0

        .long   __gxx_personality_v0

        .byte   0xc

        .uleb128 0x4

        .uleb128 0x4

        .byte   0x88

        .uleb128 0x1

        .align 4

.LECIE1:

.LSFDE1:

        .long   .LEFDE1-.LASFDE1

.LASFDE1:

        .long   .LASFDE1-.Lframe1

        .long   .LFB2

        .long   .LFE2-.LFB2

        .uleb128 0x0

        .byte   0x4

        .long   .LCFI0-.LFB2

        .byte   0xc

        .uleb128 0x1

        .uleb128 0x0

        .byte   0x9

        .uleb128 0x4

        .uleb128 0x1

        .byte   0x4

        .long   .LCFI1-.LCFI0

        .byte   0xc

        .uleb128 0x4

        .uleb128 0x4

        .byte   0x4

        .long   .LCFI2-.LCFI1

        .byte   0xe

        .uleb128 0x8

        .byte   0x85

        .uleb128 0x2

        .byte   0x4

        .long   .LCFI3-.LCFI2

        .byte   0xd

        .uleb128 0x5

        .byte   0x4

        .long   .LCFI4-.LCFI3

        .byte   0x84

        .uleb128 0x3

        .align 4

.LEFDE1:

        .ident  "GCC: (Debian 4.3.4-6) 4.3.4"

        .section        .note.GNU-stack,"",@progbits

这就是差别

#12

引用 9 楼 macrojj 的回复:

c++也可以像C一样高效。
不爱用c++的对象，就用泛型呗。比C灵活效率还高

帅哥这个效率是运行的效率？不是编程的时间效率吧？

#13

引用 11 楼 do_fork 的回复:

C/C++ code#include<stdio.h>int main()
{
        puts("AAA");
}

当C程序编译:
Assembly code        .file"t.c"
        .section        .rodata
.LC0:
        .string"AAA"
        .text
.globl main
        .type   main, @functionmain:
        leal4(%esp), %ecx
        andl    $-16, %esp
        pushl   -4(%ecx)
        pushl   %ebp
        movl    %esp, %ebp
        pushl   %ecx
        subl    $20, %esp
        movl    $.LC0, (%esp)call    puts
        addl    $20, %esp
        popl    %ecx
        popl    %ebp
        leal    -4(%ecx), %espret
        .size   main, .-main
        .ident"GCC: (Debian 4.3.4-6) 4.3.4"
        .section        .note.GNU-stack,"",@progbits

当作C++编译:
C/C++ code        .file"t.c"
        .section        .rodata
.LC0:
        .string"AAA"
        .text
.globl main
        .type   main, @function
main:
.LFB2:
        leal4(%esp),%ecx
.LCFI0:
        andl    $-16,%esp
        pushl-4(%ecx)
.LCFI1:
        pushl%ebp
.LCFI2:
        movl%esp,%ebp
.LCFI3:
        pushl%ecx
.LCFI4:
        subl    $4,%esp
.LCFI5:
        movl    $.LC0, (%esp)
        call    puts
        movl    $0,%eax
        addl    $4,%esp
        popl%ecx
        popl%ebp
        leal-4(%ecx),%esp
        ret
.LFE2:
        .size   main, .-main
        .section        .eh_frame,"a",@progbits
.Lframe1:
        .long   .LECIE1-.LSCIE1
.LSCIE1:
        .long0x0
        .byte0x1
.globl __gxx_personality_v0
        .string"zP"
        .uleb1280x1
        .sleb128-4
        .byte0x8
        .uleb1280x5
        .byte0x0
        .long   __gxx_personality_v0
        .byte0xc
        .uleb1280x4
        .uleb1280x4
        .byte0x88
        .uleb1280x1
        .align4
.LECIE1:
.LSFDE1:
        .long   .LEFDE1-.LASFDE1
.LASFDE1:
        .long   .LASFDE1-.Lframe1
        .long   .LFB2
        .long   .LFE2-.LFB2
        .uleb1280x0
        .byte0x4
        .long   .LCFI0-.LFB2
        .byte0xc
        .uleb1280x1
        .uleb1280x0
        .byte0x9
        .uleb1280x4
        .uleb1280x1
        .byte0x4
        .long   .LCFI1-.LCFI0
        .byte0xc
        .uleb1280x4
        .uleb1280x4
        .byte0x4
        .long   .LCFI2-.LCFI1
        .byte0xe
        .uleb1280x8
        .byte0x85
        .uleb1280x2
        .byte0x4
        .long   .LCFI3-.LCFI2
        .byte0xd
        .uleb1280x5
        .byte0x4
        .long   .LCFI4-.LCFI3
        .byte0x84
        .uleb1280x3
        .align4
.LEFDE1:
        .ident"GCC: (Debian 4.3.4-6) 4.3.4"
        .section        .note.GNU-stack,"",@progbits

这就是差别

其实我的基础就是花3年时间把c++ primer plus 囫囵吞枣地看一遍呵呵。。。。。。真不好意思

#14

现在我做UGNX编程。。像这种既要效率，又大型的行业软件。。。我觉得除了c++ 应该没其它语言可以胜任吧？

#15

不要看那些个什么什么虚表啊？构造析构啊？他们为什么存在？因为你存要他， C++为什么叫C++。它是C的扩展。C能做他都能做。但C++提供了更多的特性，比如多态？如果有人说多态慢？那么请问你为什么要用多态？因为你需要他。就算用C语言为了实现结构你也要模拟出来一套，还是那句话因为你需要他才存在。没人有说用了G++你就必需用多态。我说C++和C比没有性能损耗，所谓的性能损耗只是人的选择，因为你想实现更好的结构，你要更清晰的好懂的代码。这些个功能是C做起来很麻的。所以C++存在了。有人说：“C++就是没C慢” 你唧唧歪歪个啥？你不会不用啊？你用C写啊？

#16

引用 15 楼 rlxtime 的回复:

不要看那些个什么什么虚表啊？构造析构啊？他们为什么存在？因为你存要他， C++为什么叫C++。它是C的扩展。C能做他都能做。但C++提供了更多的特性，比如多态？如果有人说多态慢？那么请问你为什么要用多态？因为你需要他。就算用C语言为了实现结构你也要模拟出来一套，还是那句话因为你需要他才存在。没人有说用了G++你就必需用多态。我说C++和C比没有性能损耗，所谓的性能损耗只是人的选择?-

你好~还有那么多人使用c是不是就是因为c++规范问题啊？

#17

引用 16 楼 qq121598351 的回复:

引用 15 楼 rlxtime 的回复:
不要看那些个什么什么虚表啊？构造析构啊？他们为什么存在？因为你存要他， C++为什么叫C++。它是C的扩展。C能做他都能做。但C++提供了更多的特性，比如多态？如果有人说多态慢？那么请问你为什么要用多态？因为你需要他。就算用C语言为了实现结构你也要模拟出来一套，还是那句话因为你需要他才存在。没人有说用了G++你就必需用多态。我说C++和C比没有性能损耗，所谓的性能损耗只是人的选择?-

你好~还有那么多人使用c是不是就是因为c++规范问题啊？

还有那么多人使用C是，因为他们真的不需要C++，比如在一个单片机上搞个控制灯的小程序，有毕要用C++么？
当然还有别的搞C的，UNIX是最典型的，纯C写的。这些人不是因为C++有什么问题？要看他们需要什么？
顺便问一句： C++规范有啥问题？

#18

任何C语言程序都是有效的C++程序哦

#19

一个好的C++程序员之比最好的C程序员慢5%

#20

引用 3 楼 freezezdj 的回复:

据个例子，c++为了让你能多态，所以他实际虚函数机制时背着你做了一些需要额外开销的事情。
如虚函数表。

当然这样的事情干了很多。

我觉得你说的很对，就是这样的原因

#21

引用 18 楼 lovesi3344 的回复:

任何C语言程序都是有效的C++程序哦

这个说法有问题，用C++编译器编译不过去的C程序很多的，
C++兼容的只是早期的C语言，C语言后来又有自身的发展。

#22

c++自动帮你做的事情多些，自然会多一点点开销，这个正常得很，仅从代码效率来说，是一样的

#23

相对c++在很多地方提供的便利来说，这么一点点效率是可以忽略的。

#24

看《深入探索C++对象模型》

#25

11楼很强大……

#26

01010010101010101010010101010100000000000000000000000

#27

引用 8 楼 taodm 的回复:

如果你真的需要那些“关系”，那C语言实现恐怕开销更大。
如果你不真的需要那些“关系”，那C++代码同样不会要你付出什么额外开销。
关键是太多人不知道自己是否真的需要，而是为了C++而C++的。

这句话我得好好体会一下

#28

c++内含一个更严格的c

#29

主要看应用场合吧，偏底层的开发，注重效率，很少改动，用c适合，也可结合一定的汇编；偏应用层的，效率要求稍低，经常改动，用c++、java、c#都行。当然c++也能开发出高效的程式，要看对c++的理解有多深了，在底层方面与c比起来，优势就是扩展性好，可重用性好，但是无论做的多出色，效能上还是要稍逊c一筹。

#30

C++中的C子集与标准C的差异，有可能比不同平台的两个C环境的差异更小！

#31

引用 12 楼 qq121598351 的回复:

引用 9 楼 macrojj 的回复:
c++也可以像C一样高效。
不爱用c++的对象，就用泛型呗。比C灵活效率还高

帅哥这个效率是运行的效率？不是编程的时间效率吧？

我建议你看看《提高c++性能的编程技术》
如果为了实现运行时的函数选择，c++需要虚函数表，那么C中需要很多case
你觉得谁要方便些。
讨论开销，要在目的一致的情况下吧。还有，不是每个程序都适合OO的。但是c++ 可以带给你的程序更大的安全性。

#32

怎么又上升到了语言告诉？

#33

请教一下 do_fork～
g++ 在代码后面生成的那一片如同天书的数据是干什么用的啊？
好像 64 位环境下面无论是 C 还是 C++ 编译结果都有这个东西了，看不懂……

#34

引用 18 楼 lovesi3344 的回复:

任何C语言程序都是有效的C++程序哦

这个不对了吧？

#35

good！！！！！！！！！！！！！！！！

#36

>> 现在很少有高级语言能做到C的效率的，这就是C长青的基本保障。

把效率问题归结到语言上,是一些可耻的教科书不负责任的说法.

#37

引用 13 楼 qq121598351 的回复:

引用 11 楼 do_fork 的回复:
C/C++ code#include <stdio.h>int main()
{
        puts("AAA");
}

当C程序编译:
Assembly code        .file"t.c"
        .section        .rodata
.LC0:
        .string"AAA"
        .text
.globl main
        .type  main, @functionmain:
        leal4(%esp), %ecx
        andl    $-16, %esp
        pushl  -4(%ecx)
        pushl  %ebp
        movl    %esp, %ebp
        pushl  %ecx
        subl    $20, %esp
        movl    $.LC0, (%esp)call    puts
        addl    $20, %esp
        popl    %ecx
        popl    %ebp
        leal    -4(%ecx), %espret
        .size  main, .-main
        .ident"GCC: (Debian 4.3.4-6) 4.3.4"
        .section        .note.GNU-stack,"",@progbits

当作C++编译:
C/C++ code        .file"t.c"
        .section        .rodata
.LC0:
        .string"AAA"
        .text
.globl main
        .type  main, @function
main:
.LFB2:
        leal4(%esp),%ecx
.LCFI0:
        andl    $-16,%esp
        pushl-4(%ecx)
.LCFI1:
        pushl%ebp
.LCFI2:
        movl%esp,%ebp
.LCFI3:
        pushl%ecx
.LCFI4:
        subl    $4,%esp
.LCFI5:
        movl    $.LC0, (%esp)
        call    puts
        movl    $0,%eax
        addl    $4,%esp
        popl%ecx
        popl%ebp
        leal-4(%ecx),%esp
        ret
.LFE2:
        .size  main, .-main
        .section        .eh_frame,"a",@progbits
.Lframe1:
        .long  .LECIE1-.LSCIE1
.LSCIE1:
        .long0x0
        .byte0x1
.globl __gxx_personality_v0
        .string"zP"
        .uleb1280x1
        .sleb128-4
        .byte0x8
        .uleb1280x5
        .byte0x0
        .long  __gxx_personality_v0
        .byte0xc
        .uleb1280x4
        .uleb1280x4
        .byte0x88
        .uleb1280x1
        .align4
.LECIE1:
.LSFDE1:
        .long  .LEFDE1-.LASFDE1
.LASFDE1:
        .long  .LASFDE1-.Lframe1
        .long  .LFB2
        .long  .LFE2-.LFB2
        .uleb1280x0
        .byte0x4
        .long  .LCFI0-.LFB2
        .byte0xc
        .uleb1280x1
        .uleb1280x0
        .byte0x9
        .uleb1280x4
        .uleb1280x1
        .byte0x4
        .long  .LCFI1-.LCFI0
        .byte0xc
        .uleb1280x4
        .uleb1280x4
        .byte0x4
        .long  .LCFI2-.LCFI1
        .byte0xe
        .uleb1280x8
        .byte0x85
        .uleb1280x2
        .byte0x4
        .long  .LCFI3-.LCFI2
        .byte0xd
        .uleb1280x5
        .byte0x4
        .long  .LCFI4-.LCFI3
        .byte0x84
        .uleb1280x3
        .align4
.LEFDE1:
        .ident"GCC: (Debian 4.3.4-6) 4.3.4"
        .section        .note.GNU-stack,"",@progbits

这就是差别

其实我的基础就是花3年时间把c++ primer plus 囫囵吞枣地看一遍  呵呵。。。。。。真不好意思

。。。3年，好夸张

#38

引用 28 楼 desd003 的回复:

c++内含一个更严格的c

请问这个更严格的c与c比较一下是怎么样的结果呢？谢谢！！！！！！！！！！！

#1

看《深入探索C++对象模型》

#2

你要是能从底层去剖析C++；还怕不能用;

#3

据个例子，c++为了让你能多态，所以他实际虚函数机制时背着你做了一些需要额外开销的事情。
如虚函数表。

当然这样的事情干了很多。

#4

#5

OO不是放之四海而皆准的神物，
一些小型应用，OO不会带来什么好处，
例如门禁考勤机，要OO做什么?

#6

c拼　c++?

#7

new delete啊，构造函数，指针，内存堆管理，C++很多特性都需要很大的开销吧。我猜的

#8

#9

c++也可以像C一样高效。
不爱用c++的对象，就用泛型呗。比C灵活效率还高

#10

#11

#include <stdio.h>


int main()

{

        puts("AAA");

}

当C程序编译:

        .file   "t.c"

        .section        .rodata

.LC0:

        .string "AAA"

        .text

.globl main

        .type   main, @function

main:

        leal    4(%esp), %ecx

        andl    $-16, %esp

        pushl   -4(%ecx)

        pushl   %ebp

        movl    %esp, %ebp

        pushl   %ecx

        subl    $20, %esp

        movl    $.LC0, (%esp)

        call    puts

        addl    $20, %esp

        popl    %ecx

        popl    %ebp

        leal    -4(%ecx), %esp

        ret 

        .size   main, .-main

        .ident  "GCC: (Debian 4.3.4-6) 4.3.4"

        .section        .note.GNU-stack,"",@progbits

当作C++编译:

        .file   "t.c"

        .section        .rodata

.LC0:

        .string "AAA"

        .text

.globl main

        .type   main, @function

main:

.LFB2:  

        leal    4(%esp), %ecx

.LCFI0: 

        andl    $-16, %esp

        pushl   -4(%ecx)

.LCFI1: 

        pushl   %ebp 

.LCFI2: 

        movl    %esp, %ebp

.LCFI3: 

        pushl   %ecx

.LCFI4: 

        subl    $4, %esp

.LCFI5: 

        movl    $.LC0, (%esp)

        call    puts

        movl    $0, %eax

        addl    $4, %esp

        popl    %ecx

        popl    %ebp

        leal    -4(%ecx), %esp

        ret

.LFE2:

        .size   main, .-main

        .section        .eh_frame,"a",@progbits

.Lframe1:

        .long   .LECIE1-.LSCIE1

.LSCIE1:

        .long   0x0

        .byte   0x1

.globl __gxx_personality_v0

        .string "zP"

        .uleb128 0x1

        .sleb128 -4

        .byte   0x8

        .uleb128 0x5

        .byte   0x0

        .long   __gxx_personality_v0

        .byte   0xc

        .uleb128 0x4

        .uleb128 0x4

        .byte   0x88

        .uleb128 0x1

        .align 4

.LECIE1:

.LSFDE1:

        .long   .LEFDE1-.LASFDE1

.LASFDE1:

        .long   .LASFDE1-.Lframe1

        .long   .LFB2

        .long   .LFE2-.LFB2

        .uleb128 0x0

        .byte   0x4

        .long   .LCFI0-.LFB2

        .byte   0xc

        .uleb128 0x1

        .uleb128 0x0

        .byte   0x9

        .uleb128 0x4

        .uleb128 0x1

        .byte   0x4

        .long   .LCFI1-.LCFI0

        .byte   0xc

        .uleb128 0x4

        .uleb128 0x4

        .byte   0x4

        .long   .LCFI2-.LCFI1

        .byte   0xe

        .uleb128 0x8

        .byte   0x85

        .uleb128 0x2

        .byte   0x4

        .long   .LCFI3-.LCFI2

        .byte   0xd

        .uleb128 0x5

        .byte   0x4

        .long   .LCFI4-.LCFI3

        .byte   0x84

        .uleb128 0x3

        .align 4

.LEFDE1:

        .ident  "GCC: (Debian 4.3.4-6) 4.3.4"

        .section        .note.GNU-stack,"",@progbits

这就是差别

#12

引用 9 楼 macrojj 的回复:

c++也可以像C一样高效。
不爱用c++的对象，就用泛型呗。比C灵活效率还高

帅哥这个效率是运行的效率？不是编程的时间效率吧？

#13

引用 11 楼 do_fork 的回复:

C/C++ code#include<stdio.h>int main()
{
        puts("AAA");
}

当C程序编译:
Assembly code        .file"t.c"
        .section        .rodata
.LC0:
        .string"AAA"
        .text
.globl main
        .type   main, @functionmain:
        leal4(%esp), %ecx
        andl    $-16, %esp
        pushl   -4(%ecx)
        pushl   %ebp
        movl    %esp, %ebp
        pushl   %ecx
        subl    $20, %esp
        movl    $.LC0, (%esp)call    puts
        addl    $20, %esp
        popl    %ecx
        popl    %ebp
        leal    -4(%ecx), %espret
        .size   main, .-main
        .ident"GCC: (Debian 4.3.4-6) 4.3.4"
        .section        .note.GNU-stack,"",@progbits

当作C++编译:
C/C++ code        .file"t.c"
        .section        .rodata
.LC0:
        .string"AAA"
        .text
.globl main
        .type   main, @function
main:
.LFB2:
        leal4(%esp),%ecx
.LCFI0:
        andl    $-16,%esp
        pushl-4(%ecx)
.LCFI1:
        pushl%ebp
.LCFI2:
        movl%esp,%ebp
.LCFI3:
        pushl%ecx
.LCFI4:
        subl    $4,%esp
.LCFI5:
        movl    $.LC0, (%esp)
        call    puts
        movl    $0,%eax
        addl    $4,%esp
        popl%ecx
        popl%ebp
        leal-4(%ecx),%esp
        ret
.LFE2:
        .size   main, .-main
        .section        .eh_frame,"a",@progbits
.Lframe1:
        .long   .LECIE1-.LSCIE1
.LSCIE1:
        .long0x0
        .byte0x1
.globl __gxx_personality_v0
        .string"zP"
        .uleb1280x1
        .sleb128-4
        .byte0x8
        .uleb1280x5
        .byte0x0
        .long   __gxx_personality_v0
        .byte0xc
        .uleb1280x4
        .uleb1280x4
        .byte0x88
        .uleb1280x1
        .align4
.LECIE1:
.LSFDE1:
        .long   .LEFDE1-.LASFDE1
.LASFDE1:
        .long   .LASFDE1-.Lframe1
        .long   .LFB2
        .long   .LFE2-.LFB2
        .uleb1280x0
        .byte0x4
        .long   .LCFI0-.LFB2
        .byte0xc
        .uleb1280x1
        .uleb1280x0
        .byte0x9
        .uleb1280x4
        .uleb1280x1
        .byte0x4
        .long   .LCFI1-.LCFI0
        .byte0xc
        .uleb1280x4
        .uleb1280x4
        .byte0x4
        .long   .LCFI2-.LCFI1
        .byte0xe
        .uleb1280x8
        .byte0x85
        .uleb1280x2
        .byte0x4
        .long   .LCFI3-.LCFI2
        .byte0xd
        .uleb1280x5
        .byte0x4
        .long   .LCFI4-.LCFI3
        .byte0x84
        .uleb1280x3
        .align4
.LEFDE1:
        .ident"GCC: (Debian 4.3.4-6) 4.3.4"
        .section        .note.GNU-stack,"",@progbits

这就是差别

其实我的基础就是花3年时间把c++ primer plus 囫囵吞枣地看一遍呵呵。。。。。。真不好意思

#14

现在我做UGNX编程。。像这种既要效率，又大型的行业软件。。。我觉得除了c++ 应该没其它语言可以胜任吧？

#15

#16

引用 15 楼 rlxtime 的回复:

不要看那些个什么什么虚表啊？构造析构啊？他们为什么存在？因为你存要他， C++为什么叫C++。它是C的扩展。C能做他都能做。但C++提供了更多的特性，比如多态？如果有人说多态慢？那么请问你为什么要用多态？因为你需要他。就算用C语言为了实现结构你也要模拟出来一套，还是那句话因为你需要他才存在。没人有说用了G++你就必需用多态。我说C++和C比没有性能损耗，所谓的性能损耗只是人的选择?-

你好~还有那么多人使用c是不是就是因为c++规范问题啊？

#17

引用 16 楼 qq121598351 的回复:

引用 15 楼 rlxtime 的回复:
不要看那些个什么什么虚表啊？构造析构啊？他们为什么存在？因为你存要他， C++为什么叫C++。它是C的扩展。C能做他都能做。但C++提供了更多的特性，比如多态？如果有人说多态慢？那么请问你为什么要用多态？因为你需要他。就算用C语言为了实现结构你也要模拟出来一套，还是那句话因为你需要他才存在。没人有说用了G++你就必需用多态。我说C++和C比没有性能损耗，所谓的性能损耗只是人的选择?-

你好~还有那么多人使用c是不是就是因为c++规范问题啊？

#18

任何C语言程序都是有效的C++程序哦

#19

一个好的C++程序员之比最好的C程序员慢5%

#20

引用 3 楼 freezezdj 的回复:

据个例子，c++为了让你能多态，所以他实际虚函数机制时背着你做了一些需要额外开销的事情。
如虚函数表。

当然这样的事情干了很多。

我觉得你说的很对，就是这样的原因

#21

引用 18 楼 lovesi3344 的回复:

任何C语言程序都是有效的C++程序哦

这个说法有问题，用C++编译器编译不过去的C程序很多的，
C++兼容的只是早期的C语言，C语言后来又有自身的发展。

#22

c++自动帮你做的事情多些，自然会多一点点开销，这个正常得很，仅从代码效率来说，是一样的

#23

相对c++在很多地方提供的便利来说，这么一点点效率是可以忽略的。

#24

看《深入探索C++对象模型》

#25

11楼很强大……

#26

01010010101010101010010101010100000000000000000000000

#27

引用 8 楼 taodm 的回复:

如果你真的需要那些“关系”，那C语言实现恐怕开销更大。
如果你不真的需要那些“关系”，那C++代码同样不会要你付出什么额外开销。
关键是太多人不知道自己是否真的需要，而是为了C++而C++的。

这句话我得好好体会一下

#28

c++内含一个更严格的c

#29

#30

C++中的C子集与标准C的差异，有可能比不同平台的两个C环境的差异更小！

#31

引用 12 楼 qq121598351 的回复:

引用 9 楼 macrojj 的回复:
c++也可以像C一样高效。
不爱用c++的对象，就用泛型呗。比C灵活效率还高

帅哥这个效率是运行的效率？不是编程的时间效率吧？

#32

怎么又上升到了语言告诉？

#33

#34

引用 18 楼 lovesi3344 的回复:

任何C语言程序都是有效的C++程序哦

这个不对了吧？

#35

good！！！！！！！！！！！！！！！！

#36

>> 现在很少有高级语言能做到C的效率的，这就是C长青的基本保障。

把效率问题归结到语言上,是一些可耻的教科书不负责任的说法.

#37

引用 13 楼 qq121598351 的回复:

引用 11 楼 do_fork 的回复:
C/C++ code#include <stdio.h>int main()
{
        puts("AAA");
}

当C程序编译:
Assembly code        .file"t.c"
        .section        .rodata
.LC0:
        .string"AAA"
        .text
.globl main
        .type  main, @functionmain:
        leal4(%esp), %ecx
        andl    $-16, %esp
        pushl  -4(%ecx)
        pushl  %ebp
        movl    %esp, %ebp
        pushl  %ecx
        subl    $20, %esp
        movl    $.LC0, (%esp)call    puts
        addl    $20, %esp
        popl    %ecx
        popl    %ebp
        leal    -4(%ecx), %espret
        .size  main, .-main
        .ident"GCC: (Debian 4.3.4-6) 4.3.4"
        .section        .note.GNU-stack,"",@progbits

当作C++编译:
C/C++ code        .file"t.c"
        .section        .rodata
.LC0:
        .string"AAA"
        .text
.globl main
        .type  main, @function
main:
.LFB2:
        leal4(%esp),%ecx
.LCFI0:
        andl    $-16,%esp
        pushl-4(%ecx)
.LCFI1:
        pushl%ebp
.LCFI2:
        movl%esp,%ebp
.LCFI3:
        pushl%ecx
.LCFI4:
        subl    $4,%esp
.LCFI5:
        movl    $.LC0, (%esp)
        call    puts
        movl    $0,%eax
        addl    $4,%esp
        popl%ecx
        popl%ebp
        leal-4(%ecx),%esp
        ret
.LFE2:
        .size  main, .-main
        .section        .eh_frame,"a",@progbits
.Lframe1:
        .long  .LECIE1-.LSCIE1
.LSCIE1:
        .long0x0
        .byte0x1
.globl __gxx_personality_v0
        .string"zP"
        .uleb1280x1
        .sleb128-4
        .byte0x8
        .uleb1280x5
        .byte0x0
        .long  __gxx_personality_v0
        .byte0xc
        .uleb1280x4
        .uleb1280x4
        .byte0x88
        .uleb1280x1
        .align4
.LECIE1:
.LSFDE1:
        .long  .LEFDE1-.LASFDE1
.LASFDE1:
        .long  .LASFDE1-.Lframe1
        .long  .LFB2
        .long  .LFE2-.LFB2
        .uleb1280x0
        .byte0x4
        .long  .LCFI0-.LFB2
        .byte0xc
        .uleb1280x1
        .uleb1280x0
        .byte0x9
        .uleb1280x4
        .uleb1280x1
        .byte0x4
        .long  .LCFI1-.LCFI0
        .byte0xc
        .uleb1280x4
        .uleb1280x4
        .byte0x4
        .long  .LCFI2-.LCFI1
        .byte0xe
        .uleb1280x8
        .byte0x85
        .uleb1280x2
        .byte0x4
        .long  .LCFI3-.LCFI2
        .byte0xd
        .uleb1280x5
        .byte0x4
        .long  .LCFI4-.LCFI3
        .byte0x84
        .uleb1280x3
        .align4
.LEFDE1:
        .ident"GCC: (Debian 4.3.4-6) 4.3.4"
        .section        .note.GNU-stack,"",@progbits

这就是差别

其实我的基础就是花3年时间把c++ primer plus 囫囵吞枣地看一遍  呵呵。。。。。。真不好意思

。。。3年，好夸张

#38

引用 28 楼 desd003 的回复:

c++内含一个更严格的c

请问这个更严格的c与c比较一下是怎么样的结果呢？谢谢！！！！！！！！！！！

C++ 需要更多的开销

38 个解决方案

#1

#2

#3

#4

#5

#6

#7

#8

#9

#10

#11

#12

#13

#14

#15

#16

#17

#18

#19

#20

#21

#22

#23

#24

#25

#26

#27

#28

#29

#30

#31

#32

#33

#34

#35

#36

#37

#38

#1

#2

#3

#4

#5

#6

#7

#8

#9

#10

#11

#12

#13

#14

#15

#16

#17

#18

#19

#20

#21

#22

#23

#24

#25

#26

#27

#28

#29

#30

#31

#32

#33

#34

#35

#36

#37

#38

相关文章