[C++] Priemgetallen, malloc probleem

[honda4life]

Hallo, voor school zijn we bezig met behulp van de zeef van eratosthenes priemgetallen te berekenen, ik ben op deze methode al geraakt tot 450.000.000 en ben daarna beginnen zoeken waar m'n programma beter kon, nu zit ik echter met een fout ergens in de malloc, als m'n zeef in de duizendtallen zit.
Kan iemand zeggen wat er fout gaat, of evt goede tips geven zodat m'n zeef nog hogere getallen kan berekenen, geen andere methode dus!
Hopelijk is m'n programmeerstijl duidelijk.

First-chance exception at 0x008d10e2 in Priem.exe: 0xC0000005: Access violation writing location 0x00899000.
Unhandled exception at 0x008d10e2 in Priem.exe: 0xC0000005: Access violation writing location 0x00899000.

---

code:

// Priem.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

void Zeef(int intBovengrens, int *arrayGetallen);

int _tmain(int argc, _TCHAR* argv[])
{
    int intMaxzeef = 0;

    printf("Priemgetallen berekenen met behulp van de zeef van Eratosthenes \n");
    printf("Geef de bovengrens in: \n");
    scanf("%d", &intMaxzeef);
    
    //Geheugen reserveren
    int *arraymalloc = (int*)malloc(intMaxzeef*sizeof(int));
    
    if( arraymalloc == NULL )
    {
        printf( "Niet genoeg geheugen beschikbaar \n" );
    }
    else
    {
        printf( "Geheugen gereserveerd \n \n" );
    }
    
    //Zeef oproepen
    Zeef(intMaxzeef, arraymalloc);
    
    //Geheugen vrijgeven
    free(arraymalloc);
    printf("\n");
    printf( "Geheugen gewist \n" );

    return 0;
}

//Vanaf hier komen de functies

void Zeef(int intBovengrens, int *arrayGetallen)
{
    int intLoopgetallen=0 , intVeelvoudenschrapper=0 , intVeelvoud=0;

    // array opvullen tot bovengrens
    for(intLoopgetallen=0; intLoopgetallen<intBovengrens; intLoopgetallen++)
    {
        arrayGetallen[intLoopgetallen]=intLoopgetallen;
    }
    intLoopgetallen = 0;
    // array leegmaken
    for(intLoopgetallen=0; intLoopgetallen<intBovengrens; intLoopgetallen++)
    {
        //Getallen 0 en 1 schrappen
        if (intLoopgetallen<2)
        {
            arrayGetallen[intLoopgetallen]=0;
        }
        //Veelvouden schrappen
        else
        {
            for(intVeelvoudenschrapper=2; intVeelvoud<intBovengrens; intVeelvoudenschrapper++)
            {
                intVeelvoud=intLoopgetallen*intVeelvoudenschrapper;
                arrayGetallen[intVeelvoud]=0;
            }
            intVeelvoud=0;
        }
    //zeef weergeven op het scherm
        if (arrayGetallen[intLoopgetallen] != 0)
        {
            printf("%d\t", arrayGetallen[intLoopgetallen]);
        }
        else
        {
            printf("\t");
        }
    }
}

[Creepy]

Eeeeh, wij zijn er hier niet om voor jou te debuggen. Dat zul je in eerste instantie toch echt zelf moeten doen. Je code dumpen tesamen met een foutmelding en verder geen extra informatie e.d. is hier niet de bedoeling. Zie ook Programming Beleid - De Quickstart

Dus ben je al aan het debuggen geslagen? Zo ja, wat heb je dan gedebugged? Op welke regel gaat het mis? Zo nee, begin daar dan eerst eens mee

[ Voor 15% gewijzigd door Creepy op 08-03-2008 10:42 ]

[honda4life]

sorry, op regel 68 gaat het mis, zal echt maar een kleinigheid zijn met het de malloc, voor de rest werkt het wel

[MrBucket]

Gebruik je een ontwikkelomgeving met debugger (zoals bijv. Visual Studio), of heb je een losse debugger beschikbaar die op source-code niveau kan debuggen? Zo ja, kijk eens wat er gebeurt op regel 67 vlak voordat je die access violation krijgt.

code:

intVeelvoud=intLoopgetallen*intVeelvoudenschrapper;

Wat zijn de waardes van intLoopgetallen en intVeelvoudenschrapper, en wat wordt de waarde van intVeelvoud?

[honda4life]

ik werk met visual studio, vlak voor dat is nogal moeilijk, vermits die lus heel veel malen doorlopen wordt, heb zopas gevonden dat intVeelvoud veel te groot wordt om een of andere reden en dat ik zo naar een geheugenadres schrijf dat niet kan
intloopgetallen en intveelvoudenschrapper worden nu bekeken

[MrBucket]

honda4life schreef op zaterdag 08 maart 2008 @ 11:16:
ik werk met visual studio, vlak voor dat is nogal moeilijk, vermits die lus heel veel malen doorlopen wordt, heb zopas gevonden dat intVeelvoud veel te groot wordt om een of andere reden en dat ik zo naar een geheugenadres schrijf dat niet kan
intloopgetallen en intveelvoudenschrapper worden nu bekeken

Ik gebruik Visual Studio eigenlijk alleen voor .NET-projecten, maar ik vermoedt dat het volgende ook wel moet kunnen i.c.m. C++:

Het is mogelijk om conditionele breakpoints te plaatsen, die pas afgaan bij een bepaalde voorwaarde. Als je een breakpoint hebt geplaatst, klik met rechts op zo'n breakpoint-balletje, en als het goed is kun je dan een hit count opgeven. De breakpoint zal dan pas afgaan nadat het zoveel maal is geraakt.

Hoe je dit kunt gebruiken is als volgt: je plaatst een breakpoint met een belachelijk grote hit count. Laat het programma lopen totdat de fout optreedt. Voordat je de debugger afsluit, bekijk de huidige hit count van dat breakpoint - dit is de correcte hit count. Laat vervolgens het programma nog een keer lopen, ditmaal met de correcte hit count voor die breakpoint.

Als het goed is, stopt je programma nu op dit breakpoint, vlak voordat de fout optreedt.

[honda4life]

ik heb het gevonden, ik scheef naar een te hoog adres, er stond een regeletje verkeerd, alvast bedankt

[Creepy]

Misschien nog leuk voor de meelezers om te melden wat er nu precies verkeerd stond?

[Soultaker]

Ik weet het wel: hij schrijft éérst naar arrayGetallen[intVeelvoud] en gaat daarna pas kijken of intVeelvoud misschien groter is dan (of gelijk aan) intBovengrens. (Maar aan de TS: voortaan wel leuker als je dat zelf even vermeldt.)

Overigens kun je de zeef nog flink wat efficienter maken door bij het vinden van een priemgetal p niet te beginnen met wegstrepen bij p (zoals je nu doet) maar bij p². Alle kleinere niet-priemgetallen zijn namelijk al eerder weggestreept (denk daar maar eens over na!).

Verder kun je het geheugengebruik nog flink terugdringen door alle even getallen weg te laten, en door je zeef te representeren als een array van bits, zodat je slechts één bit per getal nodig hebt, in plaats van vier bytes in dit geval.

[writser]

En daarna loop je tegen de limieten van 32-bits getallen op en zul je moeten overstappen op unsigned long longs.

[.oisyn]

Ja, want registergrootte is immers een groter probleem dan geheugengebruik

[writser]

que?

[.oisyn]

Oh excuus, ik las in Soultaker's post booleans ipv bits. Als je booleans gebruikt dan heb je bij de zeef 2GB geheugen nodig. Dat is vaak al het maximum wat een applicatie op een 32 bits systeem kan gebruiken (op windows heb je wel hacks om naar 3GB te kunnen, wat linux betreft weet ik het eigenlijk niet goed). Maar als je bits gebruikt is dat "slechts" 256MB, dus dan loop je eerder tegen de registergrootte aan idd .