主要的因素是它是一种静态类型的语言，可以编译为机器代码。此外，由于它是一种低级语言，它通常不会做任何您不让它做的事情。

这些是我想到的其他一些因素。

Variables are not automatically initialized No bounds checking on arrays Unchecked pointer manipulation No integer overflow checking Statically-typed variables Function calls are static (unless you use function pointers) Compiler writers have had lots of time to improve the optimizing code. Also, people program in C for the purpose of getting the best performance, so there's pressure to optimize the code. Parts of the language specification are implementation-defined, so compilers are free to do things in the most optimal way

大多数静态类型语言的编译速度可以和C语言一样快，甚至比C语言更快，特别是如果它们可以假设C语言因为指针别名等原因而不能这样做的话。

只需在您的IDE中逐步检查机器代码，您就会看到为什么它更快(如果它更快的话)。它省去了很多手把手的环节。很有可能你的Cxx也会被告知不要使用，在这种情况下，它应该是相同的。

编译器优化被高估了，就像几乎所有关于语言速度的看法一样。

优化生成的代码只会对热点代码产生影响，也就是说，没有函数调用(显式或隐式)的紧凑算法。在其他地方，收效甚微。

不要轻信别人的话，看看在代码的任何性能关键部分，C语言和你选择的语言的反汇编。我认为你可以在Visual Studio运行时的反汇编窗口中看到已分解的. net。如果Java使用windbg有点棘手，应该是可能的，尽管如果你用。net来做，许多问题将是相同的。

如果没有必要的话，我不喜欢用C来编写，但我认为，这些回答中吹捧除C之外其他语言的速度的许多主张可以放在一边，只需用C和您选择的高级语言分解相同的例程，特别是如果涉及大量数据(这在性能关键型应用程序中很常见)。Fortran在其专业领域可能是个例外，不知道。它比C高吗?

第一次比较JITed代码和本地代码时，我解决了。net代码是否能与C代码运行得相当的所有问题。额外的抽象层次和所有的安全检查都带来了巨大的成本。同样的成本可能也适用于Java，但不要相信我的话，在性能至关重要的地方尝试一下。(有没有人足够了解JITed Java来在内存中找到一个编译过的过程?这当然是可能的)

这实际上是一个长期存在的谎言。虽然C程序确实经常更快，但情况并非总是如此，特别是当C程序员不太擅长它的时候。

人们往往会忘记的一个明显的漏洞是，当程序必须为某种IO阻塞时，比如任何GUI程序中的用户输入。在这些情况下，使用什么语言并不重要，因为您受到数据传入速度的限制，而不是处理数据的速度。在这种情况下，不管你使用的是C、Java、c#甚至Perl;你不能比数据进入的速度更快。

The other major thing is that using garbage collection and not using proper pointers allows the virtual machine to make a number of optimizations not available in other languages. For instance, the JVM is capable of moving objects around on the heap to defragment it. This makes future allocations much faster since the next index can simply be used rather than looking it up in a table. Modern JVMs also don't have to actually deallocate memory; instead, they just move the live objects around when they GC and the spent memory from the dead objects is recovered essentially for free.

This also brings up an interesting point about C and even more so in C++. There is something of a design philosophy of "If you don't need it, you don't pay for it." The problem is that if you do want it, you end up paying through the nose for it. For instance, the vtable implementation in Java tends to be a lot better than C++ implementations, so virtual function calls are a lot faster. On the other hand, you have no choice but to use virtual functions in Java and they still cost something, but in programs that use a lot of virtual functions, the reduced cost adds up.

这不是语言的问题，而是工具和库的问题。C语言可用的库和编译器比新语言要老得多。你可能认为这会让它们变慢，但事实恰恰相反。

这些库是在处理能力和内存非常重要的时候编写的。它们必须写得非常高效，才能发挥作用。C编译器的开发人员也花了很长时间为不同的处理器进行各种巧妙的优化。C语言的成熟和广泛采用使得它比同时期的其他语言具有显著的优势。它还使C语言在速度上比那些不像C语言那样强调原始性能的新工具更有优势。

我在链接上找到了一个关于为什么有些语言更快，有些更慢的答案，我希望这将更清楚为什么C或c++比其他语言更快，还有一些其他语言也比C更快，但我们不能使用所有的语言。一些解释-

Fortran仍然重要的一个重要原因是它的速度快:用Fortran编写的数字处理例程往往比用大多数其他语言编写的等效例程要快。在这个领域与Fortran竞争的语言是C和c++，因为它们在性能上具有竞争力。

这就提出了一个问题:为什么?是什么让c++和Fortran速度如此之快?为什么它们比其他流行语言(如Java或Python)性能更好?

解释与编译 根据编程语言所鼓励的编程风格和所提供的特性，有许多方法可以对编程语言进行分类和定义。在性能方面，最大的区别是解释语言和编译语言之间的区别。

划分并不难;而是有一个光谱。在一端，我们有传统的编译语言，包括Fortran、C和c++。在这些语言中，有一个独立的编译阶段，将程序的源代码转换为处理器可以使用的可执行形式。

这个编译过程有几个步骤。对源代码进行分析和解析。基本的编码错误，如错字和拼写错误，此时可以检测到。解析后的代码用于生成内存中的表示，该表示也可用于检测错误——这一次是语义错误，例如调用不存在的函数，或者试图对文本字符串执行算术操作。

然后，这个内存中表示形式用于驱动代码生成器，即生成可执行代码的部分。代码优化，以提高所生成代码的性能，在此过程中的不同时间执行:可以在代码表示上执行高级优化，而在代码生成器的输出上使用低级优化。

实际执行代码发生在后面。整个编译过程只是用来创建可以执行的内容。

在另一端，我们有口译员。解释器将包括一个类似于编译器的解析阶段，但这随后用于驱动直接执行，程序立即运行。

最简单的解释器包含与该语言支持的各种特性相对应的可执行代码，因此它将具有用于添加数字、连接字符串以及给定语言所具有的任何其他功能的函数。当它解析代码时，它将查找相应的函数并执行它。在程序中创建的变量将保存在某种将其名称映射到其数据的查找表中。

解释器风格的最极端的例子是类似批处理文件或shell脚本的东西。在这些语言中，可执行代码通常甚至不内置在解释器本身中，而是单独的独立程序。

So why does this make a difference to performance? In general, each layer of indirection reduces performance. For example, the fastest way to add two numbers is to have both of those numbers in registers in the processor, and to use the processor's add instruction. That's what compiled programs can do; they can put variables into registers and take advantage of processor instructions. But in interpreted programs, that same addition might require two lookups in a table of variables to fetch the values to add, then calling a function to perform the addition. That function may very well use the same processor instruction as the compiled program uses to perform the actual addition, but all the extra work before the instruction can actually be used makes things slower.

如果你想知道更多，请查看来源