Сравнение скорости c ++ и c #

Меня беспокоила скорость C #, когда он имеет дело с тяжелыми вычислениями, когда вам нужно использовать чистую мощность процессора.

Я всегда думал, что C ++ намного быстрее, чем C #, когда дело касается вычислений. Итак, я провел несколько быстрых тестов. Первый тест вычисляет простые числа ‹целое число n, второй тест вычисляет несколько панцифровых чисел. Идея второго теста исходит отсюда: Панцифровые числа

Простое вычисление C #:

using System;
using System.Diagnostics;

class Program
{

    static int primes(int n)
    {

        uint i, j;
        int countprimes = 0;

        for (i = 1; i <= n; i++)
        {
            bool isprime = true;

            for (j = 2; j <= Math.Sqrt(i); j++)

                if ((i % j) == 0)
                {
                    isprime = false;
                    break;
                }

            if (isprime) countprimes++;
        }

        return countprimes;
    }



    static void Main(string[] args)
    {
        int n = int.Parse(Console.ReadLine());
        Stopwatch sw = new Stopwatch();

        sw.Start();
        int res = primes(n);
        sw.Stop();
        Console.WriteLine("I found {0} prime numbers between 0 and {1} in {2} msecs.", res, n, sw.ElapsedMilliseconds);
        Console.ReadKey();
    }
}

Вариант C ++:

#include <iostream>
#include <ctime>
#include <cmath>

int primes(unsigned long n) {
unsigned long i, j;
int countprimes = 0;
  for(i = 1; i <= n; i++) {
      int isprime = 1;
      for(j = 2; j < sqrt((float)i); j++) 
          if(!(i%j)) {
        isprime = 0;
        break;
   }
    countprimes+= isprime;
  }
  return countprimes;
}

int main() {
 int n, res;
 cin>>n;
 unsigned int start = clock();

 res = primes(n);
 int tprime = clock() - start;
 cout<<"\nI found "<<res<<" prime numbers between 1 and "<<n<<" in "<<tprime<<" msecs.";
 return 0;
}

Когда я запустил тест, пытаясь найти простые числа <100 000, вариант C # завершился за 0,409 секунды, а вариант C ++ - за 0,614 секунды. Когда я запустил их для 1000000, C # закончил за 6,039 секунды, а C ++ - примерно за 12,987 секунды.

Пандигитальный тест на C #:

using System;
using System.Diagnostics;

class Program
{
    static bool IsPandigital(int n)
    {
        int digits = 0; int count = 0; int tmp;

        for (; n > 0; n /= 10, ++count)
        {
            if ((tmp = digits) == (digits |= 1 << (n - ((n / 10) * 10) - 1)))
                return false;
        }

        return digits == (1 << count) - 1;
    }

    static void Main()
    {
        int pans = 0;
        Stopwatch sw = new Stopwatch();
        sw.Start();

        for (int i = 1; i <= 123456789; i++)
        {
            if (IsPandigital(i))
            {
                pans++;
            }
        }
        sw.Stop();
        Console.WriteLine("{0}pcs, {1}ms", pans, sw.ElapsedMilliseconds);
        Console.ReadKey();
    }
}

Пандигитальный тест на C ++:

#include <iostream>
#include <ctime>

using namespace std;

int IsPandigital(int n)
    {
        int digits = 0; int count = 0; int tmp;

        for (; n > 0; n /= 10, ++count)
        {
            if ((tmp = digits) == (digits |= 1 << (n - ((n / 10) * 10) - 1)))
                return 0;
        }

        return digits == (1 << count) - 1;
    }


int main() {
   int pans = 0;
   unsigned int start = clock();

   for (int i = 1; i <= 123456789; i++)
   {
      if (IsPandigital(i))
      {
        pans++;
      }
   }
   int ptime = clock() - start;
   cout<<"\nPans:"<<pans<<" time:"<<ptime;  
   return 0;
}

Вариант C # выполняется за 29,906 секунды, а C ++ - примерно за 36,298 секунды.

Я не трогал никаких переключателей компилятора, и программы на C # и C ++ были скомпилированы с параметрами отладки. Прежде чем я попытался запустить тест, я беспокоился, что C # будет сильно отставать от C ++, но теперь кажется, что разница в скорости в пользу C # довольно большая.

Кто-нибудь может это объяснить? C # не работает, а C ++ скомпилирован в собственном коде, поэтому нормально, что C ++ будет быстрее, чем вариант C #.

Спасибо за ответы!

Я переделал все тесты для конфигурации Release.

Первый тест (простые числа)

C # (числа ‹100,0000): 0,189 секунды C ++ (числа‹ 100,0000): 0,036 секунды

C # (числа ‹1,000,000): 5,300 секунд C ++ (числа‹ 1,000,000): 1,166 секунды

Второй тест (панцифровые числа):

C #: 21,224 секунды C ++: 4,104 секунды

Итак, все изменилось, теперь C ++ намного быстрее. Моя ошибка в том, что я провел тест конфигурации отладки. Могу ли я увидеть некоторое улучшение скорости, если я запустил исполняемые файлы C # через ngen?

Причина, по которой я попытался сравнить C # и C ++, заключается в том, что я знаю некоторые основы обоих, и я хотел изучить API, имеющий дело с графическим интерфейсом. Я думал, что WPF хорош, поэтому, учитывая, что я нацелен на рабочий стол, я хотел увидеть, может ли C # обеспечить достаточную скорость и производительность, когда дело доходит до использования чистой мощности процессора для вычисления различных вычислений (файловые архиваторы, криптография, кодеки и т. Д.) . Но, к сожалению, C # не успевает за C ++, когда дело касается скорости.

Итак, я предполагаю, что навсегда останусь с этим вопросом Сложный вопрос по WPF, Win32 , MFC, а я новичку найду подходящий API.