【问题标题】:How much faster is C++ than C#?C++ 比 C# 快多少?
【发布时间】:2010-09-13 09:27:29
【问题描述】:

还是现在反过来了?

据我所知,在某些领域 C# 被证明比 C++ 更快,但我从来没有勇气自己测试它。

认为你们中的任何人都可以详细解释这些差异,或者为我指出正确的位置以获取相关信息。

【问题讨论】:

  • 受保护,以防止发布更多随机基准。如果您认为自己可以提出自己的观点,则需要 10 名代表。
  • 这几乎是一个没有实际意义的问题,因为我们生活在一个可以将 IL 转换为 CPP 并从那里优化的时代:docs.unity3d.com/Manual/IL2CPP.html
  • 一种检查超出范围数组访问的语言永远不会胜过不检查的语言。
  • @SevaAlekseyev 不是语言,而是编译器。 C++ 这么快的原因之一(除了显而易见的原因)是 C++ 编译器已经存在了 35 年(如果不是更多的话)。没有什么可以阻止 C# 编译器随着时间的推移变得更好。对于您提到的情况,请阅读此stackoverflow.com/questions/16713076/…

标签: c# c++ performance benchmarking


【解决方案1】:

我将首先不同意对这个问题的部分接受(和好评)的回答,并声明:

实际上有很多原因导致 JITted 代码比经过适当优化的 C++(或其他没有运行时开销的语言)运行得慢 计划包括:

  • 根据定义,在运行时 JITting 代码上花费的计算周期不可用于程序执行。

  • JITter 中的任何热路径都将与您的代码竞争 CPU 中的指令和数据缓存。我们知道缓存在性能方面占主导地位,而像 C++ 这样的原生语言在设计上没有这种类型的争用。

  • 运行时优化器的时间预算必然比编译时优化器的更受限制(正如另一位评论者指出的那样)

底线:最终,您将几乎肯定能够在 C++ 中创建比在 C# 中更快的实现。

现在,话虽如此,快多少确实无法量化,因为变量太多:任务、问题域、硬件、实施质量以及许多其他因素。您将针对您的场景运行测试以确定性能差异,然后决定是否值得付出额外的努力和复杂性。

这是一个很长很复杂的话题,但为了完整起见,我觉得值得一提的是,C# 的运行时优化器非常出色,并且能够在运行时执行某些 C++ 编译时根本无法使用的动态优化-时间(静态)优化器。即便如此,优势仍然在本机应用程序的法庭上很深,但动态优化器是上面给出的“几乎肯定”限定词的原因。

--

就相对表现而言,我也对我在其他一些答案中看到的数字和讨论感到不安,所以我想我会插话,同时为我上面的陈述提供一些支持.

这些基准测试的很大一部分问题是您不能像编写 C# 一样编写 C++ 代码并期望获得具有代表性的结果(例如,在 C++ 中执行数千次内存分配会给您带来可怕的数字。 )

相反,我编写了稍微惯用的 C++ 代码,并与 @Wiory 提供的 C# 代码进行了比较。我对 C++ 代码所做的两个主要更改是:

  1. 使用的向量::reserve()

  2. 将 2d 数组扁平化为 1d 以实现更好的缓存局部性(连续块)

C# (.NET 4.6.1)

private static void TestArray()
{
    const int rows = 5000;
    const int columns = 9000;
    DateTime t1 = System.DateTime.Now;
    double[][] arr = new double[rows][];
    for (int i = 0; i < rows; i++)
        arr[i] = new double[columns];
    DateTime t2 = System.DateTime.Now;

    Console.WriteLine(t2 - t1);

    t1 = System.DateTime.Now;
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < columns; j++)
            arr[i][j] = i;
    t2 = System.DateTime.Now;

    Console.WriteLine(t2 - t1);
}

运行时间(发布):初始:124 毫秒,填充:165 毫秒

C++14 (Clang v3.8/C2)

#include <iostream>
#include <vector>

auto TestSuite::ColMajorArray()
{
    constexpr size_t ROWS = 5000;
    constexpr size_t COLS = 9000;

    auto initStart = std::chrono::steady_clock::now();

    auto arr = std::vector<double>();
    arr.reserve(ROWS * COLS);

    auto initFinish = std::chrono::steady_clock::now();
    auto initTime = std::chrono::duration_cast<std::chrono::microseconds>(initFinish - initStart);

    auto fillStart = std::chrono::steady_clock::now();

    for(auto i = 0, r = 0; r < ROWS; ++r)
    {
        for (auto c = 0; c < COLS; ++c)
        {
            arr[i++] = static_cast<double>(r * c);
        }
    }

    auto fillFinish = std::chrono::steady_clock::now();
    auto fillTime = std::chrono::duration_cast<std::chrono::milliseconds>(fillFinish - fillStart);

    return std::make_pair(initTime, fillTime);
}

运行时间(发布):初始化:398µs(是的,那是微秒),填充:152ms

总运行时间:C#:289ms,C++ 152ms(大约快 90%)

观察

  • 将 C# 实现更改为相同的一维数组实现 产生 Init: 40ms, Fill: 171ms, Total: 211ms (C++ 还差不多 快 40%)。

  • 用 C++ 设计和编写“快速”代码比用任何一种语言编写“常规”代码要困难得多。

  • 在 C++ 中表现不佳(也许)非常容易;我们看到了无保留向量的性能。还有很多这样的陷阱。

  • 考虑到运行时发生的所有事情,C# 的性能相当惊人。而且这种性能比较容易 访问。

  • 比较 C++ 和 C# 性能的更多轶事数据:https://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=gpp&lang2=csharpcore

最重要的是,C++ 让您可以更好地控制性能。你想使用指针吗?参考?堆栈内存?堆?动态多态性还是消除具有静态多态性的 vtable 的运行时开销(通过模板/CRTP)?在 C++ 中,您必须...呃,开始自己做出所有这些选择(以及更多),理想情况下,您的解决方案可以最好地解决您正在解决的问题。

问问自己,您是否真的想要或需要这种控制,因为即使对于上面的简单示例,您也可以看到虽然性能有了显着提高,但需要更深入的投资才能访问。

【讨论】:

  • @Quonux 感谢您的评论。当然,这不是一个“真正的程序”。基准测试的重点是重构本页其他地方提供的 C# 基准测试,作为 JITted 代码在某种程度上比原生代码更快的证据——事实并非如此,并且该基准测试可能会误导新人。
  • @Quonux 你为什么要这样写?是像你这样的人让我不喜欢 stackoverflow。
  • @MarkusKnappenJohansson 我度过了糟糕的一天;),我也只是一个普通人,删除了我的反对票,但我的意见仍然适用。哦,请不要仅仅因为有些“愚蠢”的人而讨厌 SO :) 。祝你好运。
  • 完全误导性的基准。在 C++ 版本中,您只是保留部分内存(然后惊叹该操作如何花费微秒来执行)。在 C# 版本中,您正在创建 5000 个数组(在内存中实例化对象)。 C++ 比 C# 快……但差异远不及 40%……现在它更多地处于 int[,]... 跟进示例。
  • 所以,我在我的机器上重做 C# 示例以使用double[,],它更接近于基准测试中使用的。它仍然不是完美的比较,因为 C# 中的几乎所有东西都是在内存中初始化的对象(并且那里有开销)。结果:初始化耗时 3 ms,执行耗时 95 ms。所以我现在可以声明 C# 比 C++ 快 40%。这显然不是真的。也许我的机器比@U007D 快。也许我忘记设置发布模式(然后我的代码需要超过 300 毫秒才能执行)。结论:编译代码的速度是相等的。您编写代码的好坏是一个更大的因素。
【解决方案2】:

我在 C++ 与 C# 中检测代码的一个领域是创建与 SQL Server 的数据库连接并返回结果集。我比较了 C++(ODBC 上的薄层)和 C#(ADO.NET SqlClient),发现 C++ 比 C# 代码快 50%。 ADO.NET 应该是用于处理数据库的低级接口。您看到的可能更大的差异在于内存消耗而不是原始速度。

使 C++ 代码更快的另一件事是,您可以在粒度级别上调整编译器选项,以 C# 中无法做到的方式进行优化。

【讨论】:

    【解决方案3】:

    我发现这个 2020 年 4 月的内容是:https://www.quora.com/Why-is-C-so-slow-compared-to-Python,作者是一位拥有 15 年以上软件开发经验的真实程序员。

    它指出 C# 通常较慢,因为它被编译为 通用中间语言 (CIL) 而不是像 C++ 这样的机器代码。 CIL 然后通过 公共语言运行时 (CLR) 输出机器代码。但是,如果您继续执行 C#,它将获取机器代码的输出并缓存它,以便保存机器代码以供下次执行。总而言之,C# 可以更快,如果你执行多次,因为它在多次执行之后是机器码。

    还有一些 cmets 表明,优秀的 C++ 程序员可以进行耗时的优化,最终会得到优化。

    【讨论】:

      【解决方案4】:

      C# 和 C++ 在性能方面存在一些主要差异:

      • C# 是基于 GC/堆的。由于内存访问的非局部性,分配和 GC 本身就是开销
      • 多年来,C++ 优化器已经变得非常好。 JIT 编译器无法达到相同的水平,因为它们只有有限的编译时间并且看不到全局范围

      除此之外,程序员的能力也很重要。我见过糟糕的 C++ 代码,其中类在各处都按值作为参数传递。如果您不知道自己在做什么,实际上可以使 C++ 中的性能变差。

      【讨论】:

        【解决方案5】:

        这实际上取决于您要在代码中完成什么。我听说 VB.NET、C# 和托管 C++ 之间存在任何性能差异只是都市传说。但是,我发现,至少在字符串比较中,托管 C++ 胜过 C#,而 C# 又胜过 VB.NET。

        我从未对两种语言的算法复杂性进行过详尽的比较。我也只是使用每种语言的默认设置。在 VB.NET 中,我使用设置来要求声明变量等。这是我用于托管 C++ 的代码:(如您所见,此代码非常简单)。我在 .NET 4.6.2 的 Visual Studio 2013 中以其他语言运行相同的程序。

        #include "stdafx.h"
        
        using namespace System;
        using namespace System::Diagnostics;
        
        bool EqualMe(String^ first, String^ second)
        {
            return first->Equals(second);
        }
        int main(array<String ^> ^args)
        {
            Stopwatch^ sw = gcnew Stopwatch();
            sw->Start();
            for (int i = 0; i < 100000; i++)
            {
                EqualMe(L"one", L"two");
            }
            sw->Stop();
            Console::WriteLine(sw->ElapsedTicks);
            return 0;
        }
        

        【讨论】:

          【解决方案6】:

          如果我没记错的话,C# 模板是在运行时确定的。这必须比 C++ 的编译时模板慢。

          当您考虑到许多其他人提到的所有其他编译时优化,以及缺乏安全性时,确实意味着更高的速度......

          我会说 C++ 在原始速度和最小内存消耗方面是显而易见的选择。但这也意味着您需要更多时间来开发代码并确保您不会泄漏内存或导致任何空指针异常。

          判决:

          • C#:更快的开发,更慢的运行

          • C++:开发慢,运行快。

          【讨论】:

            【解决方案7】:

            嗯,这取决于。如果字节码被翻译成机器码(而不仅仅是 JIT)(我的意思是如果你执行程序)并且如果你的程序使用许多分配/释放它可能会更快,因为@987654321 @ 算法只需要一次(理论上)通过整个内存一次,但正常的 malloc/realloc/free C/C++ 调用会导致每次调用的开销(调用开销、数据结构开销、缓存未命中;))。

            所以理论上是可以的(其他GC语言也可以)。

            对于大多数应用程序,我并没有真正看到不能将 metaprogramming 与 C# 一起使用的极端劣势,因为大多数程序员反正不会使用它。

            另一个很大的优势是 SQL,就像LINQ“扩展”一样,为编译器提供了优化对数据库的调用的机会(换句话说,编译器可以将整个 LINQ 编译为一个“blob”二进制文件,其中调用的函数是内联的或为您的使用而优化的,但我在这里推测)。

            【讨论】:

            • 任何合适的 C++ 开发人员都不会遇到您描述的问题。只有那些决定在他们的程序上添加类并称其为 C++ 的糟糕 C 程序员才会有这些问题。
            • 看在上帝的份上,这是8岁,OMFGz
            • 随时提供更好的最新答案
            • 我们还应该考虑 c++ 的编译时元编程能力,它使开发人员能够在编译时执行代码片段。请注意,现代 c++ 更像是带有模板的 C。与 OOPS 相比,它更倾向于函数式编程。 constexp 的引入使元编程更易于阅读和编写。
            【解决方案8】:

            .NET 语言可以与 C++ 代码一样快,甚至更快,但 C++ 代码将具有更恒定的吞吐量,因为 .NET 运行时必须暂停 GC,即使它是它的停顿非常聪明。

            因此,如果您有一些代码必须始终快速运行而没有任何停顿,即使您对运行时 GC 非常小心,.NET 也会在某些时候引入延迟。

            【讨论】:

            • -1:这实际上是一个神话。首先,惯用 C++ 的延迟实际上很糟糕,而且通常比 .NET 更糟糕,因为当大型数据结构超出范围时,RAII 会导致析构函数雪崩,而现代 GC 是增量的,而 .NET 甚至是并发的。其次,您实际上可以通过不分配来完全消除 .NET 上的 GC 暂停。
            • 如果你这样做,你就不得不放弃使用 BCL,因为大多数方法都会创建瞬态对象。
            • 确实如此,直到 .net 4 才使 GC 成为增量式。我们有一个大型 C# 应用程序,它一次暂停几秒钟以进行 GC。对于性能关键型应用来说,这是一个杀手锏。
            • 倾向于推动硬件的程序倾向于使用 C++ 是有原因的。您可以在需要时进行更精细的控制。只有在你推动系统时,性能才是关键,否则使用 C# 或 Java 来节省你的时间。
            • 如果您无法管理缓存行为,就无法击败优化的 C++ 代码。从 L1 到主内存的缓存未命中可能会使您的操作减慢 100 倍。
            【解决方案9】:

            受此启发,我对大多数程序所需的 60% 的常用指令进行了快速测试。

            这是 C# 代码:

            for (int i=0; i<1000; i++)
            {
                StreamReader str = new StreamReader("file.csv");
                StreamWriter stw = new StreamWriter("examp.csv");
                string strL = "";
                while((strL = str.ReadLine()) != null)
                {
                    ArrayList al = new ArrayList();
                    string[] strline = strL.Split(',');
                    al.AddRange(strline);
                    foreach(string str1 in strline)
                    {
                        stw.Write(str1 + ",");
                    }
                    stw.Write("\n");
                }
                str.Close();
                stw.Close();
            }
            

            String array 和 arraylist 是专门用来包含这些指令的。

            这是 c++ 代码:

            for (int i = 0; i<1000; i++)
            {
                std::fstream file("file.csv", ios::in);
                if (!file.is_open())
                {
                    std::cout << "File not found!\n";
                    return 1;
                }
            
                ofstream myfile;
                myfile.open ("example.txt");
                std::string csvLine;
            
                while (std::getline(file, csvLine))
                {
                    std::istringstream csvStream(csvLine);
                    std::vector csvColumn;
                    std::string csvElement;
            
                    while( std::getline(csvStream, csvElement, ‘,’) )
                    {
                        csvColumn.push_back(csvElement);
                    }
            
                    for (std::vector::iterator j = csvColumn.begin(); j != csvColumn.end(); ++j)
                    {
                        myfile << *j << ", ";
                    }
            
                    csvColumn.clear();
                    csvElement.clear();
                    csvLine.clear();
                    myfile << "\n";
                }
                myfile.close();
                file.close();
            }
            

            我使用的输入文件大小为 40 KB。

            这是结果 -

            • C++ 代码在 9 秒内运行。
            • C# 代码:4 秒!!!

            哦,但这是在 Linux 上运行的...在 Mono 上运行 C#...而在 g++ 上运行 C++。

            好的,这就是我在 Windows 上得到的——Visual Studio 2003:

            • C# 代码在 9 秒内运行。
            • C++ 代码——可怕的 370 秒!!!

            【讨论】:

            • 您在那里使用了不同的数据结构和库代码,尽管“370 秒”确实表明了一些可怕的事情——您不会在调试器中运行它吧?我怀疑您使用的 CSV 库的性能比您使用的语言的性能更有趣。我会质疑在这种情况下使用向量,以及您使用了哪些优化。此外,众所周知,iostreams(特别是“myfile
            • 最后,您在 C++ 版本中做了更多的工作。 (为什么要清除 csvColumn、csvElement 和 csvLines?)
            • while 循环的每次迭代都将破坏和重建一个 std::istream 和一个 std::vector 和一个 std::string。 while 主体每次迭代都会超出范围,while 范围内的所有变量都将在每次迭代时破坏和构造。
            • 从阅读你试图从一个文件复制到另一个文件的 c++ 代码的外观。您可以直接将输入文件流复制到输出文件流,而不是使用文件流、字符串、向量和字符串流之间的复杂交互。这将节省大量时间和内存。
            • 进行速度测试,测试内存中的东西不要进入磁盘 IO,除非您在最新的 SSD 上进行测试,并且它专用于您的性能应用程序。由于计算机不断向磁盘写入数据,即使您不触摸键盘也是如此。
            【解决方案10】:

            > 毕竟,答案必须在某个地方,不是吗? :)

            嗯,没有。

            正如几位回复所指出的,问题未充分说明,以邀请问题作为回应而不是答案的方式。采取一种方式:

            然后是哪些程序?哪台机器?哪个操作系统?哪个数据集?

            【讨论】:

            • 我完全同意。我想知道为什么人们在提出一般性问题时期望得到准确的答案(63.5%)。我认为这类问题没有一般的答案。
            • @callmesteve:我知道你的意思,但你的最后一句话对于任何程序员来说都应该像是钉在黑板上的钉子。
            • 这似乎没有回答这个问题,更多的是作为评论或咆哮。
            【解决方案11】:

            >据我所知...

            您的困难似乎在于确定您所听到的内容是否可信,而当您尝试评估本网站上的回复时,这种困难只会再次出现。

            您将如何确定人们在这里所说的话是否比您最初听到的更可信?

            一种方法是要求证据。

            当有人声称“在某些领域 C# 被证明比 C++ 更快”问他们为什么他们这么说,让他们向你展示测量结果,问他们向您展示程序。有时他们只是犯了一个错误。有时你会发现他们只是在表达一种观点,而不是分享他们可以证明是真实的东西。

            通常信息和意见会与人们声称的内容混在一起,您必须尝试找出哪个是哪个。例如,来自本论坛的回复:

            • “在http://shootout.alioth.debian.org/ 进行基准测试 带着极大的怀疑态度,如 这些在很大程度上测试算术代码, 这很可能与 你的代码。”

              问问你自己是否真的 了解“这些主要测试什么 算术代码” 表示,然后 问问自己作者有没有 实际上向你展示了他的主张是 真的。

            • “这是一个相当无用的测试,因为它真的取决于如何 个别程序已 优化;我设法加快了速度 其中一些是 4-6 倍或更多, 明确比较 未优化程序之间是 有点傻。”

              问问自己作者有没有 实际上向你展示了他已经成功了 “将其中一些加速 4-6 倍或更多” - 这是一个很容易提出的要求!

            【讨论】:

            • 我完全同意你的看法,这就是我在这个论坛上提问的原因......毕竟,答案必须在某个地方,不是吗? :)
            • 是的。答案是“视情况而定”。
            【解决方案12】:

            这是一个非常模糊的问题,没有真正的明确答案。

            例如;我宁愿玩用 C++ 创建的 3D 游戏,也不愿玩 C#,因为性能肯定要好得多。 (而且我知道 XNA 等,但它与真实的东西相去甚远)。

            另一方面,如前所述;您应该使用一种可以让您快速完成您想做的事情的语言进行开发,然后在必要时进行优化。

            【讨论】:

            • 您能举几个例子吗?用 C# 编写的游戏你发现速度很慢
            • 即使是安装附带的示例应用程序也感觉很慢。
            • 垃圾收集器在使用 C# 制作游戏时是一个巨大的负担,因为它可以随时启动,导致严重的停顿。显式内存管理最终使游戏开发更容易。
            • 大多数现代游戏都受 GPU 限制。对于此类游戏,逻辑(在 CPU 上执行)是否慢 10% 无关紧要,它们仍然受 GPU 而不是 CPU 的限制。垃圾收集器是一个真正的问题,如果内存分配没有很好地调整,会导致随机短暂的冻结。
            • @postfuturist:PC 上不是这样;垃圾收集器在进出方面做得很好,我从来没有遇到过任何问题。但是,在 XBox 360 和 Zune/Windows-7-Phone 上,垃圾收集器几乎没有 PC 上的智能;我从来没有写过,但是people who have告诉我垃圾收集器是一个巨大的问题。
            【解决方案13】:

            C++(或就此而言的 C)为您提供对数据结构的细粒度控制。如果你想旋转,你有这个选项。使用 Java/.NET 库的内部数据结构的大型托管 Java 或 .NET 应用程序(OWB,Visual Studio 2005)随身携带。我已经看到 OWB 设计师会议使用超过 400 MB 的 RAM 和 BIDS 用于立方体或 ETL 设计也达到了 100 MB。

            在可预测的工作负载上(例如大多数重复一个过程多次的基准测试),JIT 可以为您提供优化得足够好以至于没有实际差异的代码。

            IMO 在大型应用程序上的区别与其说是 JIT,不如说是代码本身使用的数据结构。在应用程序占用大量内存的情况下,您的缓存使用效率会降低。现代 CPU 上的缓存未命中非常昂贵。 C 或 C++ 真正胜出的地方在于,您可以优化数据结构的使用以与 CPU 缓存完美配合。

            【讨论】:

              【解决方案14】:

              C# 可能不会更快,但它让你/我更快。这是我所做的最重要的衡量标准。 :)

              【讨论】:

              • 哈哈,Larry Wall 对这个话题有一段很好的引用。他说的是 perl,但在所有涉及语言和性能的讨论中都可以想到它:“……早期的计算机语言,例如 Fortran 和 C,旨在有效利用昂贵的计算机硬件。相比之下,Perl 旨在有效利用昂贵的计算机程序员”
              • 1. “C# 比 C++ 快得多” 2. “这不可能” 1. “当然可以” 2. “快多少?” 1.“通常3-4个月”
              • 对于真正取决于您使用的库的 C++,C# 通常不会更快,.NET 是,当您谈论生产力时
              • 这也是为什么你可以使用 Python 而不是 C 来编写一些代码的原因......但是在创建了一些繁重的计算之后你可以感受到性能上的差异。
              • 这取决于你的习惯。我在 C++ 中的编程速度比在 C# 中要快得多。图书馆知识是其中很大一部分,因为您不想为基本任务重新发明轮子。 C/C++ 的主要问题是指针管理,这几乎可以通过智能指针解决。话虽如此,C++ 严重缺乏 .NET 和 Java 提供的广泛库,并且可以大大加快开发速度。这不会很快得到解决,因为那些标准男孩喜欢把时间花在模板改进而不是库扩展上。
              【解决方案15】:

              没有严格的理由说明基于字节码的语言(如具有 JIT 的 C# 或 Java)不能像 C++ 代码一样快。然而,C++ 代码在很长一段时间内都明显更快,今天在许多情况下仍然如此。这主要是因为更高级的 JIT 优化实施起来很复杂,而真正酷的优化才刚刚出现。

              因此,在许多情况下,C++ 更快。但这只是答案的一部分。 C++ 实际上更快的情况是高度优化的程序,专业程序员彻底优化了代码。这不仅非常耗时(因此也很昂贵),而且由于过度优化通常会导致错误。

              另一方面,解释语言中的代码在运行时的更高版本(.NET CLR 或 Java VM)中变得更快,而无需您执行任何操作。 JIT 编译器可以进行许多有用的优化,而这些优化在具有指针的语言中是根本不可能的。此外,有些人认为垃圾收集通常应该与手动内存管理一样快或更快,而且在许多情况下确实如此。您通常可以在 C++ 或 C 中实现和实现所有这些,但它会更加复杂且容易出错。

              正如 Donald Knuth 所说,“过早的优化是万恶之源”。如果您真的确定您的应用程序将主要包含对性能至关重要的算术,并且它将成为瓶颈,并且在 C++ 中它肯定会更快,并且您确定 C++ 不会与您的其他要求,去C++。在任何其他情况下,首先集中精力以最适合您的语言正确实现您的应用程序,然后在运行速度太慢时找到性能瓶颈,然后考虑如何优化代码。在最坏的情况下,您可能需要通过外部函数接口调用 C 代码,因此您仍然可以使用低级语言编写关键部分。

              请记住,优化一个正确的程序相对容易,但要纠正一个优化的程序要困难得多。

              不可能给出速度优势的实际百分比,这在很大程度上取决于您的代码。在许多情况下,编程语言的实现甚至不是瓶颈。对http://benchmarksgame.alioth.debian.org/ 的基准测试持怀疑态度,因为这些主要测试算术代码,很可能与您的代码完全不同。

              【讨论】:

              • 解释语言中的代码在更高版本的运行时变得更快因为由更好版本的编译器编译的代码也会变得更快。
              • 事实上至少有一个原因:JIT 需要快速,并且不能花时间在 C++ 编译器可用的各种高级优化上。
              • “但也经常由于过度优化而导致错误。” [迫切需要引用]。我在一个国家实验室工作,我们优化我们的代码。这通常不会导致代码错误。
              • “优化一个正确的程序相对容易,但要纠正一个优化的程序要困难得多。”
              • Inge:不确定您是否走在正确的轨道上。是的,C# 是用另一种语言实现的,但是 JIT 编译器正在生成机器代码,所以它不是解释语言。因此,它不受其 C++ 实现的限制。我不知道为什么你认为在某事中添加一些经理本质上会使其更快。
              【解决方案16】:

              我会这样说:编写速度更快的代码的程序员,更了解使当前机器运行得更快的原因,顺便说一下,他们也使用适当的工具来实现精确的低-水平和确定性优化技术。由于这些原因,这些人是使用 C/C++ 而不是 C# 的人。我会尽可能地说明这是一个事实。

              【讨论】:

              • 考虑到他正在处理的数据量,Notch 将我的世界编码为相当快。此外,他主要是在相对较短的时间内单枪匹马地编写了代码,这在 C++ 中几乎是不可能的。不过,我确实同意优化技术——如果您有额外 10 倍的开发时间可以花费,因此您的代码运行速度是原来的两倍,那么这可能是值得的。
              【解决方案17】:

              C/C++ 在存在大型数组或对数组(任意大小)进行大量循环/迭代的程序中表现得更好。这就是图形在 C/C++ 中通常要快得多的原因,因为繁重的数组操作几乎是所有图形操作的基础。由于所有的安全检查,.NET 在数组索引操作方面是出了名的慢,对于多维数组尤其如此(是的,矩形 C# 数组甚至比锯齿状 C# 数组还要慢)。

              如果您直接使用指针并避免使用 Boost、std::vector 和其他高级容器,以及 inline 每个可能的小函数,则 C/C++ 的好处最为明显。尽可能使用老式数组。是的,您将需要更多行代码来完成您在 Java 或 C# 中所做的相同事情,因为您避免使用高级容器。如果您需要一个动态大小的数组,您只需要记住将您的new T[] 与相应的delete[] 语句配对(或使用std::unique_ptr)— 额外速度的代价是您必须更仔细地编码。但作为交换,您可以摆脱托管内存/垃圾收集器的开销,这很容易占 Java 和 .NET 中大量面向对象的程序以及那些大规模托管的执行时间的 20% 或更多内存数组索引成本。在某些特定情况下,C++ 应用程序也可以从一些漂亮的编译器开关中受益。

              我是 C、C++、Java 和 C# 方面的专家级程序员。我最近难得有机会用后 3 种语言实现完全相同的算法程序。该程序有很多数学和多维数组操作。我在所有 3 种语言中都对它进行了大量优化。 结果是我通常在不太严格的比较中看到的典型结果:Java 比 C# 快约 1.3 倍(大多数 JVM 比 CLR 更优化),C++ 原始指针版本比 C# 快约 2.1 倍. 请注意,C# 程序只使用安全代码——我认为您最好在使用 unsafe 关键字之前用 C++ 对其进行编码。

              为了避免有人认为我反对 C#,我最后说 C# 可能是我最喜欢的语言。它是迄今为止我遇到的最合乎逻辑、最直观、最快速的开发语言。我在 C# 中完成所有原型设计。与 Java 相比,C# 语言有许多细微的优势(是的,我知道微软有机会通过较晚进入游戏并复制 Java 来弥补 Java 的许多缺点)。向 Java 的 Calendar 类敬酒吗?如果 Microsoft 真正花精力优化 CLR 和 .NET JITter,C# 可能会严重接管。老实说,我很惊讶他们还没有——他们在 C# 语言中做了很多正确的事情,为什么不跟进重击的编译器优化呢?也许如果我们都乞求。

              【讨论】:

              • “您只需要记住将您的new T[] 与相应的delete[] 配对” – 不,您不需要。有std::unique_ptr 为您做这件事。
              • 假设你在图形中写了一些东西,为什么要在 c# 中编写安全代码,你是否考虑过使用不安全代码并再次比较?。
              【解决方案18】:

              我已经在 C++ 和 C# 等效项 - List 和简单的二维数组中测试了 vector。

              我正在使用 Visual C#/C++ 2010 Express 版本。这两个项目都是简单的控制台应用程序,我已经在标准(无自定义设置)发布和调试模式下对它们进行了测试。 C# 列表在我的电脑上运行得更快,数组初始化在 C# 中也更快,数学运算更慢。

              我使用的是 Intel Core2Duo P8600@2.4GHz,C# - .NET 4.0。

              我知道向量实现不同于 C# 列表,但我只是想测试用于存储对象的集合(并且能够使用索引访问器)。

              当然你需要清除内存(假设每次使用new),但我想让代码保持简单。

              C++ 向量测试:

              static void TestVector()
              {
                  clock_t start,finish;
                  start=clock();
                  vector<vector<double>> myList=vector<vector<double>>();
                  int i=0;
                  for( i=0; i<500; i++)
                  {
                      myList.push_back(vector<double>());
                      for(int j=0;j<50000;j++)
                          myList[i].push_back(j+i);
                  }
                  finish=clock();
                  cout<<(finish-start)<<endl;
                  cout<<(double(finish - start)/CLOCKS_PER_SEC);
              }
              

              C# 列表测试:

              private static void TestVector()
              {
              
                  DateTime t1 = System.DateTime.Now;
                  List<List<double>> myList = new List<List<double>>();
                  int i = 0;
                  for (i = 0; i < 500; i++)
                  {
                      myList.Add(new List<double>());
                      for (int j = 0; j < 50000; j++)
                          myList[i].Add(j *i);
                  }
                  DateTime t2 = System.DateTime.Now;
                  Console.WriteLine(t2 - t1);
              }
              

              C++ - 数组:

              static void TestArray()
              {
                  cout << "Normal array test:" << endl;
                  const int rows = 5000;
                  const int columns = 9000;
                  clock_t start, finish;
              
                  start = clock();
                  double** arr = new double*[rows];
                  for (int i = 0; i < rows; i++)
                      arr[i] = new double[columns];
                  finish = clock();
              
                  cout << (finish - start) << endl;
              
                  start = clock();
                  for (int i = 0; i < rows; i++)
                      for (int j = 0; j < columns; j++)
                          arr[i][j] = i * j;
                  finish = clock();
              
                  cout << (finish - start) << endl;
              }
              

              C# - 数组:

              private static void TestArray()
              {
                  const int rows = 5000;
                  const int columns = 9000;
                  DateTime t1 = System.DateTime.Now;
                  double[][] arr = new double[rows][];
                  for (int i = 0; i < rows; i++)
                      arr[i] = new double[columns];
                  DateTime t2 = System.DateTime.Now;
              
                  Console.WriteLine(t2 - t1);
              
                  t1 = System.DateTime.Now;
                  for (int i = 0; i < rows; i++)
                      for (int j = 0; j < columns; j++)
                          arr[i][j] = i * j;
                  t2 = System.DateTime.Now;
              
                  Console.WriteLine(t2 - t1);
              
              }
              

              时间:(发布/调试)

              C++

              • 600 / 606 毫秒数组初始化,
              • 200 / 270 ms 数组填充,
              • 1 秒/13 秒矢量初始化和填充。

              (是的,13 秒,我在调试模式下总是遇到列表/向量的问题。)

              C#:

              • 20 / 20 毫秒数组初始化,
              • 403 / 440 ms 数组填充,
              • 710 / 742 毫秒列表初始化和填充。

              【讨论】:

              • 我很想在 std::list 中看到索引访问器。无论如何,列表,发布模式需要 37 秒。无需调试即可发布:3s 列表,0,3 s 矢量。可能取消引用问题或某事。示例:nopaste.pl/12fb
              • 对于更精确的测量,您不应该使用System.DateTime.Now,而应该使用Stopwatch 类。
              • C++ 中向量填充时间如此缓慢的部分原因是您使用了 push_back。这已在许多帖子中显示出比使用 at 方法或运算符 [] 慢。为了使用其中任何一种方法,您需要使用调整大小或保留方法。此外,对于 c++ 向量案例,您的初始化需要这么长时间的原因是您正在强制使用复制或赋值运算符(在这种情况下不确定是哪个)来初始化您的 c++ 向量。对于 c++ 中的数组,有一种算法使用 2 个新调用而不是 5001,并且迭代速度也更快。
              • 我认为您没有以适当的方式使用 c++。只是看了一眼,发现了很多问题。例如。矢量> myList=vector>()
              • 哇。不确定从比较列表和可调整大小的数组可以得出什么结论,但如果你要使用这样的向量,你会想了解 reserve(),我的朋友,reserve()。
              【解决方案19】:

              对于“令人尴尬的并行”问题,在 C++ 上使用英特尔 TBB 和 OpenMP 时,我观察到与使用 C# 和 TPL 完成的类似(纯数学)问题相比,性能提高了大约 10 倍。 SIMD 是 C# 无法竞争的领域之一,但我也觉得 TPL 的开销很大。

              也就是说,我只将 C++ 用于我知道我将能够多线程并快速获得结果的性能关键任务。对于其他一切,C#(偶尔还有 F#)就可以了。

              【讨论】:

                【解决方案20】:

                我们必须确定 C# 在性能上是否与 C++ 相当,我为此编写了一些测试程序(两种语言都使用 Visual Studio 2005)。事实证明,没有垃圾回收,只考虑语言(而不是框架),C# 的性能与 C++ 基本相同。 C# 中的内存分配比 C++ 中的快得多,并且当数据大小增加到超出缓存线边界时,C# 在确定性方面略有优势。然而,所有这些最终都必须付出代价,而且由于垃圾回收,C# 会以非确定性的性能损失的形式付出巨大的代价。

                【讨论】:

                • 在 C++ 中,您可以选择使用不同的分配方法,因此根据 C# 中的内存分配方式(AOT?),可以在 C++ 中以相同的方式完成(但要快得多)。
                • @zackery.fix .NET 在堆分配方面有一个有趣的优势,因为它只需要移动一个指针来分配一个新对象。这仅由于压缩垃圾收集器而可行。当然,您可以在 C++ 中做同样的事情,但 C++ 不这样做。有趣的是,您如何使用相同的论点来说“C# 可以但不能,所以它是垃圾”和“C++ 不能,但它可以,所以它很棒”:)
                【解决方案21】:

                需要大量内存访问的应用程序,例如。图像处理通常最好在非托管环境 (C++) 中编写而不是在托管 (C#) 中编写。使用指针算法优化的内部循环在 C++ 中更容易控制。在 C# 中,您可能需要使用不安全的代码才能获得接近相同的性能。

                【讨论】:

                  【解决方案22】:

                  垃圾收集是 Java# 不能用于实时系统的主要原因。

                  1. GC 什么时候发生?

                  2. 需要多长时间?

                  这是不确定的。

                  【讨论】:

                  • 我不是 Java 的忠实粉丝,但没有什么说 Java 不能使用实时友好的 GC。
                  • 如果你愿意看的话,有很多实时 GC 实现。 (GC 是一个充满研究论文的领域)
                  • FWIW,Richard Jones 刚刚发布了他的垃圾收集书的更新版本,其中涵盖了最先进的实时 GC 设计等内容。
                  • 这是一个无稽之谈,Windows(和 Linux)不是实时操作系统。您的 C++ 代码也可以随时换出多个 18 毫秒的插槽。
                  • @HenkHolterman 是的,但是您始终可以在汇编中编写引导加载程序,将其绑定到您的应用程序的内核引导程序中,然后直接针对硬件执行您的 C++ 应用程序(在 RT btw 中)。您不能在 C# 中执行此操作,而我所看到的任何努力都只能模仿 C# 中的预编译程序集并使用大量 C 代码,这使得使用 C# 毫无意义。阅读所有这些内容有点有趣,因为没有 .NET 框架,C# 真的毫无用处。
                  【解决方案23】:

                  理论上,对于长时间运行的服务器类型的应用程序,JIT 编译的语言可以变得比本地编译的对应语言快很多。由于 JIT 编译语言通常首先编译为相当低级的中间语言,因此无论如何您都可以在编译时进行很多高级优化。最大的优势在于 JIT 可以继续动态地重新编译代码部分,因为它会获得越来越多的关于应用程序如何使用的数据。它可以安排最常见的代码路径,以使分支预测尽可能多地成功。它可以重新排列经常一起调用的单独代码块,以将它们都保存在缓存中。它可以花更多的精力优化内部循环。

                  我怀疑这是由 .NET 或任何 JRE 完成的,但在我上大学时正在研究它,因此认为这类事情可能会进入现实世界并非没有道理很快就到了。

                  【讨论】:

                    【解决方案24】:

                    对于图形,标准 C# 图形类比通过 C/C++ 访问的 GDI 慢得多。 我知道这与语言本身无关,更多的是与整个 .NET 平台有关,但图形是作为 GDI 替代品提供给开发人员的,它的性能太差了,我什至不敢做图形用它。

                    我们有一个简单的基准来查看图形库的速度,它只是在窗口中绘制随机线。 C++/GDI 在 10000 行时仍然很敏捷,而 C#/Graphics 很难实时做到 1000 行。

                    【讨论】:

                    • 我对你的回答很感兴趣。您是否使用不安全代码和锁定位测试了相同的基准,并自己绘制随机线?现在那将是一件有趣的事情。
                    • @Pedery 不,我没有。只是以最基本的方式使用 GDI 和 .NET.Graphics。 “自己画随机线”是什么意思?
                    • 那么您或许应该考虑对此进行测试,以获得更真实的 C# 速度指标。这是该技术的一个很好的概述:bobpowell.net/lockingbits.htm
                    • 这不是我们想要做的,我们自己将单独的像素放入帧缓冲区。如果您必须自己实现所有内容,那么使用 API/平台进行编码有什么意义?对我来说,这不是论据。我们从来不需要在 GDI 的帧缓冲区中放置单独的像素来绘制线条,我们也不打算在 .NET 中这样做。在我看来,我们确实使用了一个现实的指标,结果证明 .NET 很慢。
                    • 好吧,我只是稍微了解什么是斑点检测,但只是说明一个时间点并不能证明任何事情。你用 C++ 写过一个吗?在 JavaScript 中?并将它们与 C# 中的进行比较?除此之外,我不认为斑点检测使用了许多图形基元。如果错了,请纠正我,但我猜这是对像素执行操作的统计算法。
                    【解决方案25】:

                    我想有一些用 C# 编写的应用程序运行得很快,还有更多的 C++ 编写的应用程序运行得很快(嗯,C++ 更老了......而且也使用 UNIX......)
                    - 问题确实是 - 那是什么,用户和开发人员在抱怨...
                    好吧,恕我直言,在 C# 的情况下,我们有非常舒适的 UI、非常好的库层次结构和 CLI 的整个界面系统。在 C++ 的情况下,我们有模板、ATL、COM、MFC 和整个已经编写和运行的代码,如 OpenGL、DirectX 等......在一秒钟内 - 砰!它卡住了)。
                    用 C# 编写代码非常简单和快速(不要忘记这也会增加出错的机会。 在 C++ 的情况下,开发人员抱怨内存泄漏 - 意味着崩溃、DLL 之间的调用以及“DLL 地狱” - 支持和替换库的问题...
                    我认为您在编程语言方面拥有的技能越多,您的软件的质量(和速度)就会越高。

                    【讨论】:

                      【解决方案26】:

                      当多态决策可以在编译时预先确定时,会出现 C++ 仍然占上风(并且将在未来几年内)的特殊情况。

                      一般来说,封装和延迟决策是一件好事,因为它使代码更加动态,更容易适应不断变化的需求,更容易作为框架使用。这就是为什么 C# 中的面向对象编程非常高效,并且可以在术语“泛化”下进行泛化。不幸的是,这种特殊类型的泛化在运行时是有代价的。

                      通常,此成本并不大,但在某些应用程序中,虚拟方法调用和对象创建的开销可能会产生影响(尤其是因为虚拟方法会阻止其他优化,例如方法调用内联)。这是 C++ 具有巨大优势的地方,因为您可以使用模板来实现不同类型的泛化,它对运行时没有影响,但不一定比 OOP 的多态性少。事实上,构成 OOP 的所有机制都可以仅使用模板技术和编译时解析来建模。

                      在这种情况下(诚然,它们通常仅限于特殊问题领域),C++ 胜过 C# 和类似语言。

                      【讨论】:

                      • 实际上,Java VM(可能还有 .NET)竭尽全力避免动态调度。基本上,如果有办法避免多态,你可以很确定你的虚拟机会这样做。
                      • +1 我总是很难向我的 C# 同事解释这一点,他们对 C++ 知之甚少,以使他们能够理解其重要性。你解释得很好。
                      • @crtracy:您在没有高性能计算应用程序的情况下下注。考虑天气预报、生物信息学和数值模拟。 C++ 在这些方面的性能领先优势不会缩小,因为没有其他代码可以在相同的高抽象级别上达到可比的性能。
                      • @Jon 苹果和橙子。您的具体主张是“在元编程的上下文中,C# 比 C++ 快几个数量级”,而不是“使用预编译代码比解释代码快几个数量级”。虽然我们在这里,但您声称运行时代码生成比编译时代码生成“更通用”的说法显然也是错误的——它们都有优点和缺点。编译时代码生成使用类型系统来提供静态类型安全——运行时代码生成不能做到这一点(它可以提供强类型安全,但不能静态类型安全)。
                      • @user3800527 我认为你错过了这个答案的全部意义。当然,你可以通过打破封装并下降到低级结构来解决这个问题——你可以用(大多数)任何语言编写汇编。使 C++(几乎)独一无二并且特别适合高性能编程的原因在于,您可以构建 高级 抽象,而这些抽象没有 运行时成本。因此,您无需在 C++ 中编写类似汇编的代码即可获得出色的性能:编写良好的 sort(arr, generic_comparer) 将与 C++ 中的手写循环一样高效。它永远不会出现在 C# 中。
                      【解决方案27】:

                      我知道这不是您要问的,但 C# 通常编写比 C++ 快,这在商业环境中是一大优势。

                      【讨论】:

                      • 我会说大多数时候它更快:)
                      【解决方案28】:

                      根据我的经验(我对这两种语言都进行了很多工作),与 C++ 相比,C# 的主要问题是内存消耗高,我还没有找到控制它的好方法。最终会降低 .NET 软件速度的是内存消耗。

                      另一个因素是 JIT 编译器不能花太多时间进行高级优化,因为它在运行时运行,如果花费太多时间最终用户会注意到它。另一方面,C++ 编译器有所有时间在编译时进行优化。这个因素远没有内存消耗那么重要,恕我直言。

                      【讨论】:

                      • 在一个工作项目中,我们必须挖掘大量数据,包括同时在内存中保存许多 GB 并对所有数据执行昂贵的计算——这需要精确控制所有分配,C++ 非常棒很多唯一的选择。 +1 用于 C++。另一方面,这只是一个项目,我们大部分时间都在编写与慢速模拟器交互的系统,调试可能是一场噩梦,所以我希望我们可以为所有其他项目使用程序员时间优化语言东西。
                      • @IngeHenriksen:我很了解 Dispose 模式,但它对托管内存毫无帮助。
                      • @IngeHenriksen 处置它仅确保已调用 Dispose 方法。处置永远不会释放垃圾收集的内存。 Dispose 方法仅用于清理文件句柄等非托管资源,与内存管理无关。
                      • @user3800527:即使添加 RAM 总是可行的(实际上并非如此——想象 Microsoft 为每个 MS Office 用户添加 RAM)也无法解决问题。内存是分层的,C# 程序比 C++ 程序有更多的缓存未命中。
                      • 谢谢你,有人真正提供了答案,而不仅仅是说“哦,这取决于......等等”。
                      【解决方案29】:

                      像往常一样,这取决于应用程序。在某些情况下,C# 的速度可能可以忽略不计,而在其他情况下,C++ 的速度会快 5 或 10 倍,尤其是在操作很容易进行 SIMD 处理的情况下。

                      【讨论】:

                      • VM 的最佳情况是生成代码的运行时编译(例如匹配运行时读入的正则表达式),因为静态编译的 vanilla C++ 程序只能使用解释,因为它们没有内置 JIT 编译器。
                      • 未来注意事项:.NET 确实从 2014 年左右开始支持 SIMD 和朋友,尽管它没有被广泛使用。
                      【解决方案30】:

                      快了五个橙子。或者更确切地说:不可能有(正确的)一揽子答案。 C++ 是一种静态编译语言(但也有配置文件引导优化),C# 在 JIT 编译器的帮助下运行。差异如此之多,以至于无法回答“多快”之类的问题,甚至无法给出数量级。

                      【讨论】:

                      • 你有任何证据支持你离谱的五个橙子的说法吗?我的实验都指向最多 2 个橙子,在进行模板元编程时提高了 3 个芒果。
                      • 在酵母中,他并没有把开胃菜的速度更快。
                      • 根据我的经验,它是 5.2 个橙子。但这取决于您使用的水果计量器。
                      • 更新,StackOverflow 本身搞砸了,处理 cmets 效率低下,因此香蕉数量减少(比应有的还差 300 个香蕉):meta.stackexchange.com/questions/254534/…
                      猜你喜欢
                      • 2012-11-03
                      • 1970-01-01
                      • 2011-07-05
                      • 1970-01-01
                      • 2014-05-04
                      • 2011-04-17
                      • 2018-04-10
                      • 1970-01-01
                      相关资源
                      最近更新 更多