Performancefrage zu C# vs C++

//C++
struct Packet
{
    int x;
};

//C#
struct Packet
{
    public int x;
}

//C++
using namespace std;

srand(time(NULL));

for (int r = 0; r < rounds; r++)
{
    clock_t start = clock();

    int hits = 0;
    for (int i = 0; i < iterationsPerRound; i++)
    {
        Packet packet;
        packet.x = rand();
        if (packet.x == 0)
            hits++;
    }

    clock_t end = clock();

    cout << "\nRound #" << (r + 1) << ": " << double((end-start))/CLOCKS_PER_SEC << "s (Hits: " << hits << ")" << endl;
}

//C#
var random = new Random(0xDEAD);
var swatch = new Stopwatch();
for (var r = 0; r < rounds; r++)
{
    swatch.Restart();

    var hits = 0;
    for (var i = 0; i < iterationsPerRound; i++)
    {
        Packet packet;
        packet.x = random.Next();

        if (packet.x == 0)
            hits++;
    }

    swatch.Stop();

    Console.WriteLine("Round#{0}: {1} s ({2} Hits)", (r + 1), (double)swatch.ElapsedMilliseconds / 1000, hits);
}

#include <iostream>
#include <chrono>
#include <vector>
#include <random>

static std::vector<int> iteration(10000000);

typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::duration<double> double_seconds;

struct Packet
{
	int x;
};

int main()
{
	int hits = 0;
	int rounds = 10;

	std::random_device rd;
	std::mt19937 mt( rd() );
	std::uniform_real_distribution<double> dist(1,10000000);

	do
	{
		Clock::time_point Start = Clock::now();

		for (auto i : iteration)
		{
			Packet packet;
			packet.x = dist(mt);
			if (!packet.x)
				hits++;
		}
		Clock::time_point End = Clock::now();

		auto ms = std::chrono::duration_cast<double_seconds>(End - Start);
		std::cout << "\nRound #" << rounds << ": " << ms.count() << "s (Hits: " << hits << ")" << std::endl;

		rounds--;
	} while (rounds);
	std::cin.get();

	return 0;
}

#include <iostream>
#include <ctime>
#include <chrono>

static unsigned int g_seed;

typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::duration<double> double_seconds;

struct Packet
{
    int x;
};

inline void fast_srand(int seed) { g_seed = seed; }

inline int fastrand()
{
    g_seed = (214013*g_seed+2531011);
    return (g_seed>>16)&0x7FFF;
}

void Benchmark(int rounds, int iterationsPerRound)
{
    fast_srand(0xDEAD);

    double timings[rounds];
    int hits[rounds];

    std::fill(timings, timings + rounds, 0.0);
    std::fill(hits, hits + rounds, 0);

    for (int r = 0; r < rounds; r++)
    {
//      clock_t start = clock();
        std::chrono::high_resolution_clock::time_point Start = Clock::now();

        int lHits = 0;
        for (int i = 0; i < iterationsPerRound; i++)
        {
            Packet packet;
            packet.x = fastrand();
            if (!packet.x)
                lHits++;
        }

//      clock_t end = clock();
        Clock::time_point End = Clock::now();

        //timings[r] = double((end-start))/CLOCKS_PER_SEC;
        timings[r] = std::chrono::duration_cast<double_seconds>(End - Start).count();
        hits[r] = lHits;
    }

    for(int r = 0; r < rounds; r++)
        std::cout << "Round " << (r+1) << ": " << timings[r] << "s " << hits[r] << "hits." << std::endl;
}

int main()
{
    Benchmark(50, 10000000);

    std::cin.get();

    return 0;
}