Primzahlen

Hey, ich glaub ich hab hier mal wieder ein Speicherproblem, wollte eine Prozedur erstellen, die ein Array und eine Zahl n nimmt, und in das Array dann die ersten n Primzahlen einträgt. Dazu hab ich das zweigeteilt in eine Funktion die das Sieb des Eratosthenes realisiert, also ein maximales Element nimmt und bis dahin alle Nichtprimzahlen rausschmeißt, neues Array anlegt und Pointer drauf zurückgibt (Anzahl der Primzahlen auf Stelle 0 damit man weiß, wie groß das Array ist) und die eigentliche Prozedur, die solange das Maximale Element erhöht und die Erat. Fkt. aufruft bis genug Primzahlen erstellt wurden. Nun ist es aber so, dass sobald ich das ganze einbinde und es komplexer wird, krieg ich sporadisch so ne Win32 exception, also compilen geht, aber irgendwo muss wohl ein Fehler in der Speicherreservierung oder so drin sein...
Der Code sieht so aus:

Code:

#include <cstdlib>
#include <iostream>
#include "primz.h" 

unsigned int* erat(unsigned int maxelt)
{
     unsigned int toStore[maxelt-1], run, factor, count = 0;
     for(int i = 2; i<=maxelt; i++)
          toStore[i-2] = i;
// Array mit Zahlen 2 bis maxelt füllen
          
     for(int i = 0; i<maxelt/2; i++){
          while(toStore[i] == 0 && i < maxelt/2)
               i++;
//Zahlen die bereits auf 0 gesetzt wurden nicht mehr behandeln
          if(i<maxelt/2){
               factor = toStore[i] * toStore[i]; // kleinstes sinnvolles Element zum Starten (da kleinere Faktoren in früherem Schritt abgearbeitet)
               if(factor > maxelt)
                    i = maxelt/2; //ab maxelt/2 macht es keinen Sinn mehr zu prüfen ob vielfache des Faktors im Array
               while(factor <= maxelt){
                    if(toStore[factor-2] != 0){
                         toStore[factor-2] = 0; // sollte ne neue Zahl gefunden worden sein, die Vielfaches einer kleineren ist, auf 0 setzen
                         count++; // Die Anzahl der Nullen in count zählen
                    }
                    factor += toStore[i];
               }
          }
     }
     
     count = maxelt - count + 1; //Anzahl der Elemente != 0 plus eines für die Anzahl an Primzahlen
     
     unsigned int *res = new unsigned int(count); //Rückgabearray erstellen
     res[0] = count - 1;
     res[1] = 1;
     run = 2;
     for(int i = 0; i<maxelt - 1; i++){
          if(toStore[i] != 0)
               res[run++] = toStore[i]; // Primzahlen eintragen
     }

     return res;
}

void primz(unsigned int *toStore, unsigned int quantity)
{
     unsigned int maxelt = quantity; 
     unsigned int *filter = erat(maxelt); //Beginn mit Primzahlen bis Anzahl
     while(filter[0] <= quantity){           // falls noch nicht genug, maxelt um quantity erhöhen und nochmal probieren
          maxelt += quantity;
          delete filter;
          filter = erat(maxelt);
     }
     for(int i = 0; i<quantity; i++)
          toStore[i] = filter[i+1];          //Die (echten) Primzahlen in toStore eintragen
     
     delete filter;     
}

Sollte jemand ne schnellere Methode kennen, mindestens n Primzahlen zu erstellen, oder auf ne effiziente Weise Primzahlen in nem Intervall zu erstellen, wär ich auch für Anregungen offen :-)