voor C++ programmeurs: allocatie met 'new'

[SaGA]

Wanneer ik dynamisch geheugen reserveer in een programma bestaat er altijd de mogenlijkheid dat er geen geheugen beschikbaar is. Meestal vang ik die exceptions af op de volgende manier:

// begin pseudo code
#include <new>
#include <iostream>

int main() 
{
    int dynamic_int = 64000; // gewoon willekeurig getal
    char *memspace = NULL; // voorkom cross-memory reads/writes

    try {
        memspace = new char[dynamic_int];
    } catch (bad_alloc &e) {
        // breek het programma voortijdig af indien er geen geheugen vrij is
        cerr << "Not enough memory" << endl;
        exit (1);
    }

    return 0;
}

Is er iemand die een andere manier hanteert zoals met een new_handler of door te kijken of de pointer naar NULL wijst? Zo ja, welke manier gebruik je een waarom?

(ik vraag dit omdat ik een parseer algoritme ontwikkeld dat heeeeel veel manipuleert met dynamisch geheugen (kan helaas niet anders). Het checken op beschikbaar geheugen wil ik zo efficient mogenlijk doen zowel qua codeer stijl als processor overhead)

PS: Ik compile mijn code met g++-2.95 onder linux

Ik zou gewoon werken met NULL pointer:

#include <iostream.h>

int main()
{
    int dynamic_int = 64000; // gewoon willekeurig getal
    char *memspace = NULL; // voorkom cross-memory reads/writes

    memspace = new char[dynamic_int];
    if(!memspace)
    {
        // breek het programma voortijdig af indien er geen geheugen vrij is
        cerr << "Not enough memory" << endl;
        exit (1);
    }
    else
    {
        // ruim pointer weer op
        delete memspace;
    }

    getchar();

    return 0;
}

Is makkelijker vind ik

[Screaming Slave]

hm, offtopic, maar gcc 3.2 is veel meer standard-compliant, dus ik zou overwegen over te stappen

[SaGA]

Crystal Method schreef op 30-05-2003 @ 15:15:
hm, offtopic, maar gcc 3.2 is veel meer standard-compliant, dus ik zou overwegen over te stappen

het punt is dat gcc een C compiler is... ik programmeer liever in C++ vanwege het gebruik van classes en dergelijke...

[SaGA]

******** schreef op 30-05-2003 @ 10:12:
Ik zou gewoon werken met NULL pointer:

#include <iostream.h>

int main()
{
    int dynamic_int = 64000; // gewoon willekeurig getal
    char *memspace = NULL; // voorkom cross-memory reads/writes

    memspace = new char[dynamic_int];
    if(!memspace)
    {
        // breek het programma voortijdig af indien er geen geheugen vrij is
        cerr << "Not enough memory" << endl;
        exit (1);
    }
    else
    {
        // ruim pointer weer op
        delete memspace;
    }

    getchar();

    return 0;
}

Is makkelijker vind ik

Okee, tis makkelijker, maar stel je hebt in deze functie een stuk of 20 verschillende geheugengebieden te alloceren, dan krijg je dus ook 20 verschillende if statements...

SaGA schreef op 31-05-2003 @ 04:22:
het punt is dat gcc een C compiler is... ik programmeer liever in C++ vanwege het gebruik van classes en dergelijke...

GCC is de GNU Compiler Collection. Daar hoort G++ als subsysteem / frontend gewoon bij hoor (sinds versie 2 ofzo) :/

Je kunt met GCC ook in Objective C, Fortran en zelfs JAVA programmeren.

SaGA schreef op 31-05-2003 @ 04:25:
Okee, tis makkelijker, maar stel je hebt in deze functie een stuk of 20 verschillende geheugengebieden te alloceren, dan krijg je dus ook 20 verschillende if statements...

Misschien kun je het probleem wat specifieker uitleggen?

Ik zou zonder meer een functie schrijven die deze gebieden alloceert (by reference in pointers). In het begin van die functie zet je ff als return waarde een boolean neer, bijv Succeeded. Die zet je dan op true.

Mocht 1 van je allocaties niet werken, zet je hem op false.

Klaar?

Ik heb liever 20 if-statements dan 20 try .. catch routines. Het if-statement is een domme controle op een waarde, jouw error handling kost je gelijk weer wat cpu-cycles. Niet echt bevorderlijk voor de performance

[SaGA]

******** schreef op 31-05-2003 @ 08:23:
Misschien kun je het probleem wat specifieker uitleggen?

Ik zou zonder meer een functie schrijven die deze gebieden alloceert (by reference in pointers). In het begin van die functie zet je ff als return waarde een boolean neer, bijv Succeeded. Die zet je dan op true.

Mocht 1 van je allocaties niet werken, zet je hem op false.

Klaar?

Ik heb liever 20 if-statements dan 20 try .. catch routines. Het if-statement is een domme controle op een waarde, jouw error handling kost je gelijk weer wat cpu-cycles. Niet echt bevorderlijk voor de performance

Nee, als je try catch gebruikt dan heb je daar dus maar 1 blok van waarin alle allocaties plaatsvinden en dus maar 1 catch blok.

Oh ja, gcc, ben een beetje abuis

Maar die errorhandling (met try en catch) wat voor extra's doet dat dan, dat het zoveel cpu cycles meer gebruikt om zn taak te vervullen. Bij if statements is het ook een soort van CMP en een JMP instructie... Ik kan hier op het internet ook niets zinnigs over vinden... ik zoek gewoon nog even door, maar bedankt voor je reactie iig