Me preocupaba la velocidad de C# cuando se trata de cálculos pesados, cuando se necesita utilizar la potencia bruta de la CPU.velocidad de C++ yC# en comparación con
Siempre pensé que C++ es mucho más rápido que C# en lo que respecta a los cálculos. Así que hice algunas pruebas rápidas. La primera prueba calcula los números primos < un entero n, la segunda prueba calcula algunos números pandigitales. La idea de la segunda prueba viene de aquí: Pandigital Numbers
C# primer cálculo:
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++ variante:
#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;
}
Cuando me encontré con la prueba tratando de encontrar números primos < de 100.000, C# variante terminó en 0,409 segundos y la variante C++ en 0,614 segundos. Cuando los ejecuté para 1,000,000 C# terminaron en 6.039 segundos y C++ en aproximadamente 12.987 segundos.
prueba Pandigital en 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();
}
}
prueba Pandigital en 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# variante se ejecuta en 29.906 segundos y C++ en alrededor de 36,298 segundos.
No toqué ningún conmutador del compilador y se compilaron los programas C# y C++ con las opciones de depuración. Antes de intentar ejecutar la prueba, estaba preocupado de que C# quedara muy por detrás de C++, pero ahora parece que hay una diferencia de velocidad bastante grande en C#.
¿Alguien puede explicar esto? C# está jitted y C++ está compilado nativo, por lo que es normal que un C++ sea más rápido que una variante de C#.
Gracias por las respuestas!
He rehecho todas las pruebas para la configuración de la versión.
Primera prueba (números primos)
C# (números < 100,0000): 0.189 segundos C++ (números < 100.0000): 0.036 segundos
C# (nummbers < 1.000.000): 5.300 segundos C++ (nummbers < 1000000): 1.166 segundos
segunda prueba (números Pandigital):
C#: 21. 224 segundos C++: 4.104 segundos
Por lo tanto, todo ha cambiado, ahora C++ es mucho más rápido. Mi error es que realicé la prueba de configuración de depuración. ¿Puedo ver alguna mejora en la velocidad si ejecuto los ejecutables de C# a través de ngen?
La razón por la que traté de comparar C# y C++ es porque conozco algunos conceptos básicos de ambos y quería aprender una API que tratara con la GUI.Estaba pensando que WPF es agradable, por lo tanto, dado que me estoy enfocando en el escritorio, quería ver si C# puede ofrecer suficiente velocidad y rendimiento cuando se trata de usar potencia pura de CPU para calcular varios cálculos (archivadores de archivos, criptografía, códecs, etc.) . Pero parece que lamentablemente C# no puede seguir el ritmo de C++ cuando se trata de velocidad.
Por lo tanto, supongo que siempre quedaré atrapado con esta pregunta Tough question on WPF, Win32, MFC, y buscaré una API adecuada.
"¿Alguien puede explicar esto? C# está jitted y C++ está compilado nativo, por lo que es normal que un C++ sea más rápido que una variante C#." <- No en modo de depuración. –
"... los programas de C++ se compilaron con opciones de depuración". Entonces, ¿por qué nos preocupamos por el rendimiento? – GManNickG
'= 2; j <(i^(1/2)); j ++) 'Este código es incorrecto. Lo estás haciendo en modo bit, o no como exponenciador. –