C++比C#语言快多少？


How much faster is C++ than C#?

或者是它现在在其他的方式吗？ P / < >

从我已经听到有一些地区在这种C # proves去的速度比C + +，但我从来没有勇气去让我的身体由它自己。 P / < >

我认为，任何你能explain的差异在这些细节或点我到合适的地方为信息在这。 P / < >

相关讨论

没有一个严格的理由，为什么有一个基于字节码的语言，比如具有C语言的Java或Java，不能像C++代码那么快。然而，C++代码在很长一段时间内明显地更快，而且今天在很多情况下仍然如此。这主要是由于更高级的JIT优化实现起来比较复杂，而真正酷的JIT优化现在才刚刚到来。

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

另一方面，解释语言中的代码在运行时(.NETCLR或Java VM)的后期版本中变得更快，而不需要你做任何事情。而且有很多有用的优化，JIT编译器可以做到这一点，在带有指针的语言中是完全不可能的。另外，一些人认为垃圾收集通常应该和手动内存管理一样快或更快，而且在许多情况下是这样的。通常可以在C++或C中实现和实现这一切，但是它会变得更加复杂和容易出错。

正如DonaldKnuth所说，"过早的优化是万恶之源"。如果你确实知道你的应用程序大部分都是由性能非常关键的算法组成的，它将是瓶颈，而且它肯定会在C++中运行得更快，而且你确信C++不会与你的其他要求相冲突，去C++。在任何其他情况下，首先集中精力以最适合您的语言正确地实现应用程序，然后在运行太慢的情况下找到性能瓶颈，然后考虑如何优化代码。在最坏的情况下，您可能需要通过一个外部函数接口调用C代码，这样您仍然可以用较低级别的语言编写关键部分。

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

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

相关讨论

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

相关讨论

快五个橙子。或者更确切地说：没有(正确的)笼统的答案。C++是一种静态编译语言(但是，也有轮廓引导的优化)，C是由JIT编译器辅助运行的。有如此之多的差异，以至于像"多快"这样的问题都无法回答，甚至连给出数量级的问题也无法回答。

相关讨论

我首先不同意这个问题的部分被接受(并且被很好地支持)的答案，并声明：好的。

事实上，为什么JIT代码会比一个优化的C++运行得慢一些(或者没有运行时开销的其他语言)。项目包括：好的。

  • 根据定义，在运行时用于抖动代码的计算周期在程序执行中不可用。好的。

  • 抖动中的任何热路径都将与您的代码竞争CPU中的指令和数据缓存。我们知道缓存在性能方面占主导地位，而像C++这样的本地语言不具有这种类型的争用。好的。

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

底线：最终，几乎可以肯定的是，你可以在C++中创建比C++中更快的实现。好的。

现在，尽管如此，速度到底有多快还不能量化，因为有太多的变量：任务、问题域、硬件、实现质量和许多其他因素。您将对您的场景运行测试，以确定性能的差异，然后决定是否值得付出额外的努力和复杂性。好的。

这是一个很长且复杂的话题，但我觉得值得一提的是，C的运行时优化器是优秀的，并且能够在运行时执行某些动态优化，而对于编译时(静态)优化器来说，C++是不可用的。即使这样，本地应用程序的优势仍然很明显，但动态优化器是上面给出的"几乎可以肯定"限定符的原因。好的。

——好的。

在相对表现方面，我也被我在其他答案中看到的数字和讨论所困扰，所以我想我会插嘴，同时为我上面所做的陈述提供一些支持。好的。

这些基准的一个很大的问题是，你不能编写C++代码，就像你写C语言一样，期望得到有代表性的结果(例如在C++中执行成千上万的内存分配会给你带来可怕的数字)。好的。

相反，我写了一些更为实用的C++代码，并与提供的C代码进行了比较。我对C++代码的两个主要变化是：好的。

1)使用的向量：：reserve()好的。

2)将二维数组展平为1d，以获得更好的缓存位置(连续块)好的。

C.*(.NET4.6-1)好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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，fill:165ms好的。

C++ 14(CLANV3.8/C2)好的。

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
#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(是，即微秒)，fill:152ms好的。总运行时间：C＝：2809MS，C++152MS(大约快90%)

观察好的。

  • 将C实现更改为相同的一维数组实现屈服点：40ms，填充：171ms，总计：211ms(c++)仍然几乎40%快些。好的。

  • 在C++中设计和编写"快速"代码比在任何一种语言中编写"正则"代码都困难得多。好的。

  • 在C++中获得性能很差(也许)是很容易的；我们看到了具有非保留向量的性能。有很多这样的陷阱。好的。

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

  • 更多的轶事数据比较性能的C++和C ^：HTTPS://TimeMasksgAMial.AutoTo.DiBAN.OR/U64 Q/COMPARE.PHP？lang=gpp&lang2=csharpcore好的。

底线是C++给了你更多的控制性能。是否要使用指针？参考文献？堆栈存储器？堆？使用静态多态(通过模板/crtp)来动态多态或消除vtable的运行时开销？在C++中，你必须…呃，你自己做所有这些选择(以及更多)，理想情况下，这样你的解决方案就能最好地解决你正在解决的问题。好的。

问问你自己，你是否真的想要或需要这种控制，因为即使是上面的一个小例子，你也可以看到，尽管性能有了显著的提高，但是访问它需要更深入的投资。好的。好啊。

相关讨论

(P)In my experience(and I have worked a lot with both languages)，the main problem with C++35；compared to C++is high memory consumption，and I have not found a good way to control it.这是一个记忆的消耗，这将是唯一的事件(p)(P)另一个因素是，jit compiler cannot afford too much time to do advanced优化，because it runs at runtime，and the end user would notice it if it takes too much time.On the other hand，a C++compiler has all the time it need to do最优化at compile time.这一因素比记忆消耗更重要，IMHO。(p)

相关讨论

(P)在C++still has the upper hand(and will，for years to come)occurs when polymorphic decisions can be prefered at compile time.(p)(P)一般而言，由于《守则》使之更具活力，因此《准则》适合于不断变化的要求，而且《准则》作为一个框架得到了运用，因此《准则》的制定和执行是一件好事。This is why object oriented programming in C§35；is very productive and it can be generaled under the term"generalation".未及时的是，这种特殊的普遍性模式是以一种成本在运行中出现的。(p)(P)通常，这一成本是非实质性的，但有一些应用，当虚拟方法的上级召唤和目标创建能够产生不同的效果(特别是在虚拟方法防止其他优化的情况下，这种方法作为一种方法呼吁注入)。This is where C++has a huge advantage because you can use templates to achieve a different kind of generalization which has no impact on runtime but isn't necessarily any less polymmorphic than oop.In fact，all of the mechanisms that constitute oop can be modeld using only template techniques and compile-time resolution.(p)(P)In such cases(and admitedly，they're often restricted to special problem domains)，C++wins against C+，and comparational languages.(p)

相关讨论

(P)c+(or C for that matter)gives you fine-grained control over your data structures.如果你想要一个双倍你有选择。Large Managed Java or Net Apps(Owb，Visual&NBS；Studio&NBS；2005)that use the internal data structures of the Java/.net libraries carry the baggage with them.I've seen owb designer sessions using over 400&NBS；MB of ram and bids for cube or etl design getting into the 100's of mb as well.(p)(P)On a predictable workload(such as most benchmarks that repeat a process many times)a jit can get you code that is optimed well enough that there is no practical difference.(p)(P)IMO on large applications the difference is not so much the jit as the data structures that the code itself is using.当应用是一个备忘录-沉重的你会得到的效率搜身使用。现代CPUS中的每一个错误都是显而易见的。Where C or C++really win is where you can optime your usage of data structures to play nicely with the CPU cake.(p)

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

我们有一个简单的基准，我们用来看看一个图形库有多快，那就是简单地在一个窗口中绘制随机的线。C++/GDI仍然有10000条线，C／图形很难实时完成1000。

相关讨论

垃圾收集是Java无法用于实时系统的主要原因。

  • GC什么时候发生？

  • 要多长时间？

    • 这是不确定性的。

    相关讨论

    我们必须确定C ^是否与C++的性能相媲美，我为此编写了一些测试程序(使用Visual Studio 2005为两种语言编写)。结果表明，在没有垃圾收集的情况下，只考虑语言(不是框架)，C基本上具有与C++相同的性能。C语言中内存分配的方式比C++中的快，而当数据大小超过缓存行边界时，C的决定论有轻微的优势。然而，所有这些最终都要付出代价，而且由于垃圾收集，对于C的非确定性性能命中的形式存在巨大的成本。

    相关讨论

    和往常一样，这取决于应用程序。有些情况下，C ^可能是可忽略的慢，而其他情况下C++的速度是5或10倍，特别是在操作很容易SIMD D的情况下。

    相关讨论

    (P)I know i t's not what you were asking，but C's 35；is often quicker to write than C+，which is a big bonus in a commercial setting.(p)

    相关讨论

    C/C++可以在大数组或重循环/迭代数组(任意大小)的程序中表现得更好。这是图形在C/C++中一般要快得多的原因，因为重数组操作是几乎所有图形操作的基础。由于所有的安全检查，.NET在数组索引操作中都是出了名的慢，这对于多维数组尤其如此(而且，是的，矩形C数组甚至比锯齿形C数组慢)。

    C/C++的奖金是最明显的，如果你直接使用指针，避免Boost、EDOCX1、0和其他高级容器，以及EDCOX1×1，那么每个小函数都是可能的。尽可能使用老式阵列。是的，当你避免高级容器时，你需要更多的代码来完成你在Java或C语言中所做的事情。如果您需要一个动态大小的数组，您只需记住将您的new T[]与相应的delete[]语句(或使用std::unique_ptr语句)进行配对；额外速度的代价是您必须更仔细地编码。但是在交换中，您可以摆脱托管内存/垃圾收集器的开销，这很容易是Java和.NET中面向对象程序的执行时间的20%或更多，以及那些海量的托管内存数组索引成本。在某些特定的情况下，C++应用程序也可以从一些优秀的编译器开关中获益。

    我是C、C++、Java和C语言中的专家程序员。我最近很少有机会用后三种语言实现完全相同的算法程序。这个程序有很多数学和多维数组操作。我在所有3种语言中都进行了大量优化。结果是我通常在不太严格的比较中看到的：Java的速度比C语言快1.3倍(大多数JVM比CLR更优化)，C++原始指针版本比C语言快约2.1X。请注意，C++程序只使用安全代码& MMASH；我认为，在使用EDCOX1×5 }关键字之前，您最好也可以在C++中对其进行编码。

    为了避免有人认为我对C有什么不满，我会说C可能是我最喜欢的语言。它是迄今为止我遇到的最符合逻辑、最直观、最快速的开发语言。我在C中完成所有原型设计。C语言比Java有很多小的、微妙的优势(是的，我知道微软有机会通过较晚进入游戏，并有可能复制Java来修复Java的许多缺点)。对Java的EDCOX1，6类的人敬酒？如果微软真的花了大量精力来优化clr和.NET抖动，C可能会认真地接管。我真的很惊讶他们还没有用C语言做那么多正确的事情，为什么不用重击编译器优化来跟进呢？如果我们都乞求的话。

    相关讨论

    >据我所知…

    你的困难似乎在于决定你所听到的是否可信，当你试图评估这个网站上的回复时，这个困难就会重复出现。

    你将如何决定人们在这里说的话是否比你最初听到的更可信？

    一种方法是询问证据。

    当有人声称"C的某些区域被证明比C++更快"时，问他们为什么这么说，让他们给你看测量，让他们给你看节目。有时他们会犯错误。有时你会发现他们只是表达了一种观点，而不是分享一些他们可以证明是真的东西。

    通常情况下，信息和意见会混为一谈，你必须试着找出谁是谁。例如，从本论坛的回复中：

    • "在http://shootout.alioth.debian.org上进行基准测试。/带着极大的怀疑，如这些主要是测试算术代码，很可能与你的代码。"

      问问你自己了解"这些主要测试算术代码"是指，然后问问自己作者是否事实上他向你证明了他的主张真的。

    • "这是一个相当无用的测试，因为它实际上取决于测试的好坏。各个项目已优化；我已设法加快其中一些是4-6倍或更多，明确比较在未优化的程序之间相当愚蠢。"

      问问自己作者是否实际上向你证明他是成功的将其中一些速度提高4-6次数或更多"-这是一个简单的声明！

    相关讨论

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

    因此，如果您有一些代码必须持续快速运行而不停顿，.NET将在某个时刻引入延迟，即使您非常小心地使用运行时GC。

    相关讨论

    (P)It's an extremely vague question without real definitive answers.(p)(P)For example；I'd rather play 3d-games that are created in C++than in C's 35；，because the performance is certainly a lot better.(and I know XNA，etc.，but it comes no way near the real thing).(p)(P)On the other hand，as previously mentioned；you should develop in a language that lets you do what you want quickly，and then if necessary optimize.(p)

    相关讨论

    对于"并行并行"的问题，当使用英特尔TBB和OpenMP上的C++时，我发现与C(C)和TPL所做的类似(纯数学)问题相比，性能提高了大约10倍。Simd是一个C_无法竞争的领域，但我也觉得TPL的开销相当大。

    这就是说，我只使用C++来执行性能关键任务，我知道我将能够多线程并快速获得结果。对于其他的一切，c(偶尔f)都很好。

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

    我怀疑这是由.NET或任何JRE完成的，但在我上大学的时候，它正在被研究，所以认为这些事情很快就会进入现实世界并不是不合理的。

    需要密集内存访问的应用程序(如图像处理)通常比非托管环境(C++)更好地写入非托管环境(C++)。用指针算法优化内环，更容易在C++中进行控制。在C中，您可能需要使用不安全的代码，甚至接近相同的性能。

    我已经测试了EcOX1 0在C++和C等价的EDCOX1，1和简单2D阵列中的应用。

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

    我使用的是Intel Core2Duo [email protected]，C-.NET 4.0。

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

    当然，您需要清除内存(比如说每次使用new)，但我希望代码保持简单。

    C++向量测试：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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列表测试：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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++数组：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    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β-阵列：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    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 ms阵列初始化，
    • 200/270 ms阵列填充，
    • 1秒/13秒矢量初始化和填充。

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

    C：

    • 20/20 ms阵列初始化，
    • 403/440 ms阵列填充，
    • 710/742 ms列表初始化和填充。
    相关讨论

    嗯，要看情况。如果字节码被翻译成机器代码(而不仅仅是JIT)(我的意思是，如果你执行程序)，如果你的程序使用许多分配/解除分配，它可能会更快，因为GC算法只需要一次通过(理论上)通过整个内存一次，但正常的MalC/ReAlOC/免费C/C++调用会导致每次调用的开销(CA)。ll开销、数据结构开销、缓存未命中；)。

    所以理论上是可能的(对于其他GC语言也是如此)。

    对于大多数应用程序，我并不认为不能使用带有C_的元编程是一个极端的缺点，因为大多数程序员无论如何都不使用它。

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

    相关讨论

    我想C语言运行的应用程序运行得很快，还有更多的C++应用程序运行得很快(C++)只是老了…也要用Unix…)-问题确实是-那是什么东西，用户和开发人员抱怨…嗯，imho，在C的情况下，我们有非常舒适的用户界面、非常好的库层次结构和整个CLI接口系统。在C++的情况下，我们有模板、ATL、COM、MFC和完整的SeBangC等编写和运行的代码，如OpenGL、DirectX等。开发人员抱怨在C(意味着程序运行得很快，而且一秒钟之内)的情况下，GC调用会无限增加。它被卡住了。用C语言编写代码非常简单和快速(不要忘记这也会增加出错的几率)。在C++的情况下，开发人员抱怨内存泄漏，-意味着崩溃，DLL之间的调用，以及"DLL地狱"-新的支持和替换库的问题……我认为您在编程语言方面的技能越多，软件的质量(和速度)就越高。

    我是这样说的：编写速度更快的代码的程序员，更了解当前机器运行速度的原因的程序员，顺便说一句，他们也是使用适当的工具来实现精确的低级和确定性优化技术的程序员。由于这些原因，这些人是使用C/C++而不是C语言的人。我会尽可能地把这说成事实。

    相关讨论

    如果我没有弄错，C模板是在运行时确定的。这必须比C++的编译时模板慢。

    当你接受了许多其他人提到的所有其他编译时优化，以及缺乏安全性，这确实意味着更快的速度…

    我认为C++是原始速度和最小内存消耗的明显选择。但这也意味着开发代码和确保不会泄漏内存或导致任何空指针异常的时间更长。

    判决：

    • C：更快的开发，较慢的运行

    • C++：开发速度慢，运行速度快。

    >毕竟，答案必须在某个地方，不是吗？：)

    嗯，不。

    正如一些回复所指出的那样，问题的具体表达方式是邀请回答问题，而不是回答问题。只有一种方法：

    • 这个问题把语言和语言实现混为一谈——这个C程序比这个C程序慢2194倍，快1.17倍——我们必须问你：哪种语言实现？

    然后是哪些节目？哪台机器？哪个操作系统？哪个数据集？

    相关讨论

    这实际上取决于您在代码中试图完成什么。我听说，这只是城市传说中的东西，VB.NET、C和托管C++之间有任何性能上的差异。然而，我发现，至少在字符串比较中，管理C++会击败C语言的裤子，而这又胜过VB.NET。

    在语言之间的算法复杂性方面，我从来没有做过任何详尽的比较。我也在使用每种语言的默认设置。在VB.NET中，我使用设置来要求变量的声明等等。下面是我使用的C++托管代码：(如你所见，这个代码非常简单)。我在使用.NET 4.6.2的Visual Studio 2013的其他语言中也运行同样的程序。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #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;
    }

    受此启发，我做了一个快速测试，其中60%是大多数程序所需的通用指令。

    这是C代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    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("
    "    );
        }
        str.Close();
        stw.Close();
    }

    字符串数组和arraylist用于包括这些指令。

    下面是C++代码：

    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
    39
    for (int i = 0; i<1000; i++)
    {
        std::fstream file("file.csv", ios::in);
        if (!file.is_open())
        {
            std::cout <<"File not found!
    "    ;
            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 <<"
    "    ;
        }
        myfile.close();
        file.close();
    }

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

    结果就是这样-

    • C++代码在9秒内运行。
    • 代码：4秒！！！！

    哦，但这是在Linux上的……C在Mono上运行…以及C++与G++。

    好的，这是我在Windows上看到的—Visual Studio 2003：

    • C代码在9秒内运行。
    • C++代码-可怕的370秒！！！！
    相关讨论