这些答案中的许多都给出了为什么C更快或更快的有效理由(无论是在一般情况下还是在特定的场景中)。不可否认的是:

Many other languages provide automatic features that we take for granted. Bounds checking, run-time type checking, and automatic memory management, for example, don't come for free. There is at least some cost associated with these features, which we may not think about—or even realize—while writing code that uses these features. The step from source to machine is often not as direct in other languages as it is in C. OTOH, to say that compiled C code executes faster than other code written in other languages is a generalization that isn't always true. Counter-examples are easy to find (or contrive).

尽管如此，我还是注意到另一件事，我认为它比其他任何因素都更能影响C与许多其他语言的比较性能。即:

其他语言通常更容易编写执行较慢的代码。通常，它甚至受到该语言的设计哲学的鼓励。推论:C程序员更有可能编写不执行不必要操作的代码。

例如，考虑一个简单的Windows程序，其中创建了一个主窗口。C版本将填充一个WNDCLASS[EX]结构，该结构将传递给RegisterClass[EX]，然后调用CreateWindow[EX]并进入消息循环。以下是高度简化和缩写的代码:

WNDCLASS wc;
MSG      msg;

wc.style         = 0;
wc.lpfnWndProc   = &WndProc;
wc.cbClsExtra    = 0;
wc.cbWndExtra    = 0;
wc.hInstance     = hInstance;
wc.hIcon         = NULL;
wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
wc.lpszMenuName  = NULL;
wc.lpszClassName = "MainWndCls";

RegisterClass(&wc);

CreateWindow("MainWndCls", "", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
             CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

while(GetMessage(&msg, NULL, 0, 0)){
    TranslateMessage(&msg);
    DispatchMessage(&msg);
}

c#中类似的程序可能只有一行代码:

Application.Run(new Form());

这一行代码提供了近20行C代码所提供的所有功能，并添加了一些我们遗漏的功能，例如错误检查。这个更丰富、更完整的库(与典型C项目中使用的库相比)为我们做了很多工作，解放了我们的时间来编写更多的代码片段，这些代码对我们来说很短，但涉及到幕后的许多步骤。

但是，一个丰富的库使简单快速的代码膨胀并不是我真正想要的。当您开始检查我们的小一行程序实际执行时实际发生了什么时，我的观点就更加明显了。为了好玩，可以在Visual Studio 2008或更高版本中启用. net源代码访问，然后进入上面简单的一行代码。您将遇到的一个有趣的小珍宝是Control的getter中的这个注释。CreateParams:

// In a typical control this is accessed ten times to create and show a control.
// It is a net memory savings, then, to maintain a copy on control.
// 
if (createParams == null) {
    createParams = new CreateParams(); 
} 

十次。信息大致相当于存储在WNDCLASSEX结构中的内容和传递给CreateWindowEx的内容的总和，在它存储在WNDCLASSEX结构中并传递给RegisterClassEx和CreateWindowEx之前，从Control类中检索10次。

总而言之，在c#中执行这个非常基本的任务的指令数量比在C中多2-3个数量级，部分原因是使用了功能丰富的库，这是必然的，而我们简单的C代码只做了我们需要的事情，仅此而已。但部分原因是. net框架的模块化、面向对象的特性导致了大量的重复执行，而过程方法通常可以避免这些重复执行。

我并不是要挑c#或。net框架。我也不是说模块化、泛化、库/语言特性、OOP等等都是不好的东西。我曾经用C语言进行大部分开发，后来用c++，最近用c#。类似地，在使用C之前，我主要使用汇编。我的语言每“提高”一步，我就能在更短的时间内写出更好、更可维护、更健壮的程序。然而，它们的执行速度往往要慢一些。

一些c++算法比C快，其他语言中的算法或设计模式的一些实现可能比C快。

当人们说C语言很快，然后转向谈论其他语言时，他们通常是在用C语言的性能作为基准。

里面有很多问题——大部分是我没有资格回答的问题。但对于最后一个:

有什么能阻止其他语言编译成运行速度和C一样快的二进制呢?

一句话，抽象。

C语言只比机器语言高出一到两个抽象层次。Java和. net语言距离汇编程序至少有3个抽象级别。Python和Ruby我不太确定。

通常，程序员的玩具越多(复杂的数据类型等)，你离机器语言的距离就越远，需要做的翻译就越多。

我在这里和那里都偏离了，但这是基本的要点。

更新-------这篇文章有一些很好的评论，有更多的细节。

我猜你忘了汇编语言也是一种语言:)

但是说真的，只有当程序员知道自己在做什么的时候，C程序才会更快。你可以很容易地编写一个C程序，它比用其他语言编写的程序运行得更慢。

C语言之所以更快，是因为它就是这样设计的。它允许你做很多“低级”的事情，帮助编译器优化代码。或者，我们可以说，你程序员负责优化代码。但这通常相当棘手，而且容易出错。

其他语言，就像前面提到的其他语言一样，更关注程序员的生产力。人们普遍认为程序员的时间比机器的时间要昂贵得多(即使在过去)。因此，尽量减少程序员花在编写和调试程序上的时间，而不是减少程序的运行时间，是很有意义的。为了做到这一点，您将牺牲一些可以使程序更快的事情，因为许多事情都是自动化的。

C语言并不总是更快。

C语言比现代Fortran语言慢。

在某些方面，C通常比Java慢。(特别是在JIT编译器对您的代码进行了测试之后)

C允许发生指针混叠，这意味着一些好的优化是不可能的。特别是当您有多个执行单元时，这将导致数据获取停滞。噢。

指针算术工作的假设确实会导致某些CPU系列(特别是PIC !)它曾经在x86上很差劲。

基本上，当你得到一个矢量单元，或者一个并行编译器，C语言很糟糕，而现代的Fortran运行得更快。

C程序员的一些技巧，比如thking(动态修改可执行文件)会导致CPU预取暂停。

明白我的意思了吗?

而我们的好朋友x86执行的指令集，如今与实际的CPU架构关系不大。影子寄存器，负载存储优化器，都在CPU中。所以C离虚拟金属很近。真正的金属，英特尔不会让你看到。(从历史上看，VLIW CPU有点破产，所以，也许这并不是那么糟糕。)

如果你在高性能DSP上用C编程(可能是TI DSP ?)，编译器必须做一些棘手的事情，在多个并行执行单元之间展开C。因此，在这种情况下，C语言并不接近金属，但它接近编译器，它将进行整个程序优化。奇怪。

最后，一些cpu (www.ajile.com)在硬件中运行Java字节码。C将在该CPU上使用一个PITA。

在过去，只有两种类型的语言:编译型和解释型。

编译语言利用“编译器”读取语言语法并将其转换为相同的汇编语言代码，这可以直接在CPU上进行。解释型语言使用了几种不同的方案，但从本质上讲，语言语法被转换成一种中间形式，然后在“解释器”(用于执行代码的环境)中运行。

因此，在某种意义上，在代码和机器之间存在另一个“层”——解释器。而且，在计算机中，越多就意味着使用更多的资源。翻译速度较慢，因为他们必须执行更多的操作。

More recently, we've seen more hybrid languages like Java, that employ both a compiler and an interpreter to make them work. It's complicated, but a JVM is faster, more sophisticated and way more optimized than the old interpreters, so it stands a much better change of performing (over time) closer to just straight compiled code. Of course, the newer compilers also have more fancy optimizing tricks so they tend to generate way better code than they used to as well. But most optimizations, most often (although not always) make some type of trade-off such that they are not always faster in all circumstances. Like everything else, nothing comes for free, so the optimizers must get their boast from somewhere (although often times it using compile-time CPU to save runtime CPU).

Getting back to C, it is a simple language, that can be compiled into fairly optimized assembly and then run directly on the target machine. In C, if you increment an integer, it's more than likely that it is only one assembler step in the CPU, in Java however, it could end up being a lot more than that (and could include a bit of garbage collection as well :-) C offers you an abstraction that is way closer to the machine (assembler is the closest), but you end up having to do way more work to get it going and it is not as protected, easy to use or error friendly. Most other languages give you a higher abstraction and take care of more of the underlying details for you, but in exchange for their advanced functionality they require more resources to run. As you generalize some solutions, you have to handle a broader range of computing, which often requires more resources.

保罗。