[c++] delete[] geeft error in Debug mode

[Verwijderd]

Ik heb een dynamische array gemaakt genaamd cycle, en die wil ik na gebruik weer netjes vrijgeven, en dat wil niet Zo simpel als wat, maar het werkt gewoon niet. (ik moet daarnaast wel zeggen dat ik vermoed dat mn processor niet helemaal 100% is, omdat de tempraturen bij100% cpu load oplopen tot 80 à 90 graden, en ik heb er nu 3 fans in zitten maar het helpt niet, en ik voel zelf ook nix van buiten als ik mn hand erop houd. Maar ik vroeg me dus of door zon beschadigde proc. dit soort rare dingen kunnen voorkomen?)

C++:

    int * cycle;
    cycle = new int[j-i];

    int cycleCounter=0;
    
    for(int x=i; x<=j; x++)
    {
        n = x;
        while(n > 1)
        {
            if(n % 2)
            {
                n == x ? counter += 2 : counter++;
                n = 3*n+1;
            }
            else
            {
                n == x ? counter += 2 : counter++;
                n /= 2;
            }
        }
        cycle[cycleCounter] = counter;
        cycleCounter++;
        counter=0;
    }

    cout<<endl<<kleinste(cycle)<<endl;
    delete[] cycle;

en als ik dat uitvoer krijg ik een error bij delete[]. Als ik dat eruithaal dan is er nix aan de hand.

Dit is wat ik krijg:


Als ik dit in release mode compile, link en uitvoer is er nix aan de hand, maar als ik het in debug mode doe dan krijg ik een error. Ik ben dus bang dat ie geheugen wist waar hij geen toegang tot heeft. Netzoals dat als je in release mode buiten een array schrijft en dat print, dat je dan rare waarden krijgt maar geen error. Terwijl je in debug mode wel een error krijgt.

Iemand enig idee??

[The End]

Volgens mij is of je array een te kort of je for lus een te lang

Dus of:

code:

new int[j - i + 1];

of:

code:

for(int x=i; x<j; x++) // Dus niet x<=j

Bij dit soort dingetjes is het trouwens altijd even handig om er een keer met de debugger door te steppen om naar de waardes te kijken.
Dat het alleen in debug mode voorkomt is gewoon 'mazzel'. Soms kom je het een hele tijd niet tegen en daarna opeens altijd. Ligt er maar aan welk stuk geheugen je overschrijft.

[ Voor 52% gewijzigd door The End op 30-01-2004 21:25 ]

[Verwijderd]

k heb al tig ker gedebugd, en hij heeft nooit raar gedaan bij de for lus. Hij was steeds van goede grootte, maar ik ga het effe proberen

edit:

Ok je had gelijk, maar gek dat de debugger daar niets van zegt, en dat het probleem pas opkomt bij het vrijgeven van het geheugen. Hoe komt dat?

[ Voor 39% gewijzigd door Verwijderd op 30-01-2004 21:29 ]

[The End]

Verwijderd schreef op 30 januari 2004 @ 21:27:
k heb al tig ker gedebugd, en hij heeft nooit raar gedaan bij de for lus. Hij was steeds van goede grootte, maar ik ga het effe proberen

[edit]
Ok je had gelijk, maar gek dat de debugger daar niets van zegt, en dat het probleem pas opkomt bij het vrijgeven van het geheugen. Hoe komt dat?

Het array is van variabele lengte. De compiler kan dus nooit weten hoe groot het array is op het moment dat het programma uitgevoerd wordt. Hier moet je zelf altijd op letten in C++.
Dat je programma crashed bij het vrijgeven is toevallig. Het kan ook gebeuren bij het schrijven voorbij het einde van het array.

[Verwijderd]

The End schreef op 30 januari 2004 @ 21:32:
[...]


Het array is van variabele lengte. De compiler kan dus nooit weten hoe groot het array is op het moment dat het programma uitgevoerd wordt. Hier moet je zelf altijd op letten in C++.
Dat je programma crashed bij het vrijgeven is toevallig. Het kan ook gebeuren bij het schrijven voorbij het einde van het array.

ah ok, want ik dacht dus dat hij altijd crashde op het moment van schrijven buiten array, wist niet dat dat ook op andere momenten kon. Bedankt

[.oisyn]

Wat er daadwerkelijk gebeurd is het volgende: de memory manager alloceert samen met de buffer zelf meestal wat informatie over de buffer, en kan deze informatie dus voor of achter de buffer kwijt. Vooral in debug-mode komt dit voor, omdat de informatie over het algemeen van belang is bij het debuggen Als je naast de buffer schrijft kun je die informatie dus overschrijven, waardoor het bij het vrijgeven ervan verkeerd gaat (de informatie klopt immers niet meer)

Over het algemeen treden dit soort fouten altijd op bij het schrijven buiten de buffer, het schrijven naar al vrijgegeven geheugen en het meerdere keren vrijgeven van hetzelfde stuk geheugen