题

或是它现在周围的其他方式？

从我听到有一些领域在这C#证明是快于C++，但我从来没有胆量来测试它通过自己。

认为你能解释这些差异在细节或点我到正确的地点的信息，这一点。

有帮助吗？

解决方案

没有严格的理由说明具有JIT的基于字节码的语言（如C＃或Java）不能像C ++代码一样快。但是，C ++代码在很长一段时间内都显着提高了速度，而且在很多情况下今天仍然如此。这主要是因为更高级的JIT优化实现起来很复杂，而真正酷的JIT优化只是刚刚到来。

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

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

正如唐纳德克努特所说，“过早优化是所有邪恶的根源”。如果您确实知道您的应用程序将主要包含非常高性能的算法，并且它将成为瓶颈，并且它在C ++中肯定会更快，并且您确信C ++不会与您的其他C ++冲突要求，去C ++。在任何其他情况下，专注于首先以最适合您的语言正确实现您的应用程序，然后在运行速度太慢时找到性能瓶颈，然后考虑如何优化代码。在最坏的情况下，您可能需要通过外部函数接口调用C代码，因此您仍然可以用较低级别的语言编写关键部分。

请记住，优化正确的程序相对容易，但更难以纠正优化的程序。

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

其他提示

C＃可能不会更快，但它会让你/我更快。这是我做的最重要的衡量标准。 ：）

快五颗橙子。或者更确切地说：没有（正确的）一揽子答案。 C ++是一种静态编译的语言（但是，也有配置文件引导优化），C＃在JIT编译器的帮助下运行。有很多不同的问题，例如＆＃8220;快多少＆＃8221;无法回答，甚至没有给出数量级的答案。

我要开始通过不同意部分的接受(和良好的投赞成票)回答这个问题的陈述：

实际上有充足的理由为什么JITted码将运行速度慢于一个正确地优化C++(或其他语言没有运行开销) 程序 其中包括：

  • 计算周期，花在JITting码在运行时通过的定义，不可用于在程序的执行。

  • 任何热的路径在抖动将竞争与你的代码指令和数据的高速缓存在。我们知道，缓占主导地位的时候性能和母语等C++没有这种类型的竞争，通过的定义。

  • 一个运行时优化程序的时间预算是一定是 很多 更受限于一个编译时优化程序(如另一位评论者所指出)

底线：最终，你 将 几乎肯定能够创建一个更快地执行在C++比你能在C#.

现在，这就是说， 快多少 真的不是量化的，因为有太多的变量：该任务，问题领域、硬件、高质量的实现和许多其他因素。你必须上运行测试你的方案，以确定在性能上的差别，然后再决定是否值得的额外的努力和复杂性。

这是一个非常漫长而复杂的课题，但是我觉得值得一提的是为了完整起见，C#'s runtime优化器是卓越的，并且是能够执行某些动态优化在运行时，根本不可用C++与它的编写时(静态)优化。即使有这样，利用仍然是通常深深地在当地应用程序的法庭，但优化的动态的原因"几乎 肯定"的限定词。

--

在条款的相关性能，我也感到不安的数字和进行的讨论，我看到在一些其他的答案，所以我想我要附和的同时，提供一些支持所作的发言，我做了以上。

一个巨大的一部分问题与这些基准是你不能写C++的代码如果你写C#和期望得到的结果代表(例如。执行成千上万的记忆拨款C++是要给你的可怕的数字。)

相反，我写了稍有更多的惯用C++编码和比较C#码@Wiory提供。两个主要改变我所做的C++码是：

1)使用矢量：：保留()

2)平2d阵1d实现更好的缓的地区(毗连区块)

C#(.净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);
}

运行时间(释放):Init：124ms，填写:165ms

C++14(铛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);
}

运行时间(释放):Init：398µs(是的，这是微秒)，填写：152ms

总的运行时间为：C#:289ms、C++152ms(大约90％的速度)

意见

  • 改变C#实现同样的1d阵的执行情况 产生了Init：40毫秒，填写:171ms，总:211ms(C++仍然几乎 40％的速度).

  • 它是非常难以设计和编写的"快速"的代码C++于它是编写"定期"代码语言。

  • 它的(也许)令人惊讶的是容易得到贫穷的性能在C++;我们看到了毫无保留的矢量业绩。有很多缺陷，这样。

  • C#'s绩是相当惊人的，当你考虑的是在运行时间。并且，性能是比较容易 访问。

  • 更多的零星数据进行比较的业绩C++和C#: https://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=gpp&lang2=csharpcore

底线是用C++给你更多的控制的性能。你想使用一个指?一个参考？堆的记忆？堆?动态性或消除运行开销的一种虚表的静态多态性(通过的模板/CRTP)?C++你必须...呃， 去 使所有这些选择(和更大)的自己，最好让你的解决方案的最佳解决问题你解决.

问问自己，如果你真的想要或者需要控制，因为甚至简单的例子上，你可以看到，尽管有显着的改进性能，需要更深入地投资访问。

根据我的经验（我用两种语言都做了很多工作），C＃与C ++相比的主要问题是高内存消耗，我还没有找到一种控制它的好方法。正是内存消耗最终会减慢.NET软件的速度。

另一个因素是JIT编译器无法承担太多时间进行高级优化，因为它在运行时运行，如果花费太多时间，最终用户会注意到它。另一方面，C ++编译器始终需要在编译时进行优化。这个因素远比内存消耗重要，恕我直言。

在编译时可以预先确定多态决策的情况下，C ++仍然具有优势（并将在未来几年内发挥作用）的一种特殊情况发生。

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

通常，这个成本是非实质性的，但是有些应用程序中虚拟方法调用和对象创建的开销会产生影响（特别是因为虚方法会阻止其他优化，例如方法调用内联）。这就是C ++具有巨大优势的地方，因为您可以使用模板来实现不同类型的泛化，这种泛化对运行时具有 no 影响，但不一定比OOP更少多态。事实上，构成OOP的所有机制都可以仅使用模板技术和编译时解析来建模。

在这种情况下（并且诚然，它们通常仅限于特殊问题域），C ++赢得了C＃和类似语言。

C ++（或C语言）为您提供了对数据结构的细粒度控制。如果你想捏捏你有这个选择。大型托管Java或.NET应用程序（OWB， Visual＆nbsp; Studio＆nbsp; 2005 ）使用Java / .NET库的内部数据结构带有它们的包袱。我见过OWB设计师会议使用超过400 MB的RAM和BIDS for cube或 ETL 设计也进入100的MB。

在可预测的工作负载（例如多次重复某个过程的基准测试）上，JIT可以为您提供经过充分优化的代码，以确保没有实际差异。

IMO对大型应用程序的区别不在于JIT与代码本身使用的数据结构差别。如果应用程序占用大量内存，则缓存使用效率会降低。现代CPU上的高速缓存未命中非常昂贵。在C或C ++真正获胜的地方，你可以优化数据结构的使用，以便与CPU缓存很好地配合。

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

我们有一个简单的基准测试，用于查看图形库的速度，并且只是在窗口中绘制随机线。 C ++ / GDI仍然很容易使用10000行，而C＃/ Graphics很难实时执行1000行。

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

  1. GC何时会发生？

  2. 需要多长时间？

    3. 这是不确定的。

我们必须确定C＃在性能上是否与C ++相当，我为此编写了一些测试程序（对于这两种语言使用Visual Studio 2005）。事实证明，没有垃圾收集，只考虑语言（而不是框架），C＃与C ++的性能基本相同。 C＃中的内存分配比C ++中更快，当数据大小超出缓存行边界时，C＃在确定性方面略有优势。然而，所有这些最终都要付出代价，并且由于垃圾收集而导致C＃的非确定性性能命中的成本很高。

与往常一样，这取决于应用程序。在某些情况下，C＃的速度可能会慢得多，而其他情况下C ++的速度要快5到10倍，尤其是在操作可以轻松进行SIMD的情况下。

我知道这不是你要求的，但C＃通常比C ++更快写，这在商业环境中是一个很大的好处。

C / C ++可以在程序中执行得更好，在这些程序中有大型数组或重型循环/迭代数组（任何大小）。这就是图形在C / C ++中通常要快得多的原因，因为重型阵列操作几乎是所有图形操作的基础。由于所有安全检查，.NET在数组索引操作中的速度非常慢，对于多维数组尤其如此（是的，矩形C＃数组甚至比锯齿状C＃数组慢）。

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

我是C，C ++，Java和C＃的专家程序员。我最近有机会在后3种语言中实现完全相同的算法程序。该程序有很多数学和多维数组操作。我用所有3种语言对其进行了大量优化。 结果是我通常在不太严格的比较中看到的典型结果：Java比C＃快约1.3倍（大多数JVM比CLR更优化），而C ++原始指针版本比C＃快约2.1倍请注意，C＃程序只使用安全代码＆＃8212;我认为您在使用 unsafe 关键字之前也可以用C ++编写代码。

为了避免有人认为我有反对C＃的东西，我会说C＃可能是我最喜欢的语言。它是迄今为止我遇到的最合乎逻辑，最直观，最快速的开发语言。我在C＃中做了所有的原型设计。与Java相比，C＃语言具有许多小的，微妙的优势（是的，我知道微软有机会通过较晚进入游戏并且可以复制Java来修复Java的许多缺点）。吐司到Java的 Calendar 类有人吗？如果微软花费了大量精力来优化CLR和.NET JITter，那么C＃可以认真接管。我老实说他们还没有惊讶他们在C＃语言中做了很多事情，为什么不跟着重击编译器优化呢？也许如果我们都乞求。

从我听到的...

你的困难似乎是，在决定是否你有什么听到的是可信的，并且这种困难，只会是重复当你尝试评估这些答复在这个网站。

你怎么决定事情的人在这里说的都或多或少可靠的比你原来听到了吗？

一种办法是要求 证据.

当某人的权利要求"有一些领域在这C#证明是快于C++" 问他们 为什么 他们说，, ，要求他们出示你的测量，要求他们出示你的节目。有时候他们只是犯了一个错误。有时候你会发现他们只是表达意见，而不是共享的东西，他们可以显示出是真实的。

通常的信息和意见将被混合起来在人怎么要求，你就必须尝试整理出哪个是哪个。例如，从答复在此论坛：

  • "采取各项基准在 http://shootout.alioth.debian.org/ 一个很大的怀疑， 这些主要的测试算代码， 这是最有可能不是类似于 你的代码。"

    问问自己，如果你真的 理解什么 "这些主要的测试 算代码" 装置，然后 问问自己，如果提交人 实际上显示您他的要求是 真的。

  • "这是一个相当没有用的试验，因为这真的取决于如何很好 个别的计划已经 优化；我已经快了 他们中的一些由4至6倍或更多， 这就很清楚，比较 之间的未优化程序 而不是愚蠢的。"

    问问自己，提交人是否有 实际上显示您他的管理 "加快他们中的一些由4至6 次或更多"-这是一个简单的要求。

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

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

对于“令人难以置信的并行”问题，当在C ++上使用英特尔TBB和OpenMP时，我发现与使用C＃和TPL的类似（纯数学）问题相比，性能提升了大约10倍。 SIMD是C＃无法竞争的一个领域，但我也觉得TPL有相当大的开销。

也就是说，我只使用C ++进行性能关键任务，我知道我可以快速多线程并获得结果。对于其他一切，C＃（偶尔也是F＃）就好了。

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

例如;我宁愿玩用C ++创建的3D游戏而不是C＃，因为性能肯定要好得多。 （而且我知道XNA等等，但它并没有接近真实的东西）。

另一方面，如前所述;你应该用一种语言进行开发，让你快速做你想做的事，然后在必要时进行优化。

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

我怀疑这是由.NET或任何JRE完成的，但是当我在大学时它正在被研究回来，所以认为这些东西可能会进入现实世界并不是不合理的有一点很快。

需要密集内存访问的应用程序，例如在非托管环境（C ++）中编写图像操作通常比托管（C＃）更好。使用指针算术的优化内循环在C ++中更容易控制。在C＃中，您可能需要使用不安全的代码来获得接近相同的性能。

我已经测试了 vector C++和C#相当于- List 简单2d阵列。

我使用的视觉C#/C++2010年表达的版本。这两个项目都是简单的控制台应用程序，我已经测试过他们在标准(没有定义设置)的释放和调试模式。C#列出运行得更快，列初始化也更快C#、数学运算速度较慢。

我使用英特尔Core2Duo P8600@2.4GHz C#-.净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#-array:

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);

}

时间：(Release/调试)

C++

  • 600/606ms列init,
  • 200/270ms阵列的填补，
  • 1秒/13sec矢量init&填补。

(是的，13秒钟，我总是有问题列表/载体调试模式。)

C#:

  • 20/20毫列init,
  • 403/440ms阵列的填补，
  • 710/742ms表init&填补。

嗯，这取决于。如果字节码被翻译成机器代码（而不仅仅是JIT）（我的意思是如果你执行程序）和如果你的程序使用了很多分配/解除分配，它可能会更快，因为 GC 算法只需要一次通过（理论上）整个内存一次，但是正常的malloc / realloc / free C / C ++调用会在每次调用时产生开销（调用开销，数据结构开销，缓存未命中;）。）

因此理论上可行（也适用于其他GC语言）。

我真的没有看到不能使用元编程的极端劣势C＃用于大多数应用程序，因为大多数程序员都不使用它。

另一大优势是SQL，如 LINQ “扩展名”，提供编译器优化对数据库的调用的机会（换句话说，编译器可以将整个LINQ编译为一个“blob”二进制文件，其中被调用的函数被内联或供您优化使用，但我在这里推测）。

我认为C＃编写的应用程序运行速度很快，而且有更多的C ++编写的应用程序运行得很快（C ++刚刚老了......并且也采用了UNIX ...）
- 问题确实是 - 那是什么东西，用户和开发者都抱怨......
嗯，恕我直言，在C＃的情况下，我们有非常舒适的UI，非常好的库层次结构，以及CLI的整个界面系统。在C ++的情况下，我们有模板，ATL，COM，MFC和已经编写并运行OpenGL，DirectX等代码的整个shebang ...开发人员抱怨在C＃的情况下不可避免地升级GC调用（意味着程序运行速度快，并且一秒钟 - 砰！它被卡住了。） 用C＃编写代码非常简单快速（不要忘记这也会增加错误的机会）。 在C ++的情况下，开发人员抱怨内存泄漏， - 意味着压缩，DLL之间的调用，以及“DLL地狱”。 - 较新的支持和替换库的问题...
我认为你在编程语言中会有更多的技巧，你的软件的质量（和速度）就越高。

我会这样说：编写速度更快的代码的程序员是那些更了解当前机器运行速度的人，顺便说一句，他们也是那些使用适当工具的人水平和确定性优化技术。出于这些原因，这些人是使用C / C ++而不是C＃的人。我会说这是一个事实。

>后所有的答案必须是某个地方，不是吗？:)

嗯，没有。

作为若干答复指出， 问题是下指定的 的方式，邀请问题的响应，而不是答案。采取只有一个办法：

然后该程序？这机器吗?其操作系统？哪些数据？

如果我没有记错的话,C#模板确定在运行时间。这必须是慢于编制时间模板C++.

当你把所有的其它编制时优化所提到的许多其他人，以及缺乏安全，不，事实上，意味着更快的速度...

要我说C++是显而易见的选择方面的原的速度和最低存储的消耗。但是，这也意味着更多的时间发展码，并确保你是不是漏水的存储器或造成任何空指例外情况。

判决：

  • C#:更快的发展速度较慢跑

  • C++:发展缓慢，更快的运行。

这实际上取决于您在代码中尝试完成的任务。我听说在VB.NET，C＃和托管C ++之间存在性能差异，这只是都市传奇的一部分。但是，我发现，至少在字符串比较中，托管C ++胜过C＃，这反过来又打败了VB.NET。

我决不会对语言之间的算法复杂性进行任何详尽的比较。我也只是使用每种语言的默认设置。在VB.NET中，我使用设置来要求声明变量等。以下是我用于托管C ++的代码:(正如您所看到的，此代码非常简单）。我在Visual Studio 2013中使用.NET 4.6.2在其他语言中运行相同的程序。

#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;
}

有一些主要差异之间C#and C++在性能方面：

  • C#是GC/堆为基础的。分配和GC本身的开销，因为不当地的存访问
  • C++优化已成为非常好。JIT汇编者就无法实现的水平相同，因为他们只有有限的汇编时间和没有看到全球范围

此外，程序员的职能也发挥着作用。我已经看到坏C++代码类传递的价值作为论点，所有的地方。实际上你可以让它更糟糕的是用C++如果你不注意。

灵感来自这样，我做了一个快速测试有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和对列表使用故意以包括这些指令。

这里是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();
}

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

这里的结果-

  • C++码跑在9秒钟。
  • C#码：4秒钟！

哦，这是Linux上...C#上运行 单...和C++与克++.

好吧，这是什么我上了车窗 Visual Studio2003年:

  • C#码跑在9秒钟。
  • C++的代码可怕的370秒钟！
许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top