Verständnisfrage statisches Feld + Destruktor

uwerothfeld

Hallo zusammen,

ich habe eine Klasse welche ein statisches char-Feld enthält, in welches ich Objekte abspeicher, welche vom Typ dieser Klasse sind. Dies geht auch ganz gut. Nun bin ich an einer Stelle, in der ich einzelne Objekte aus diesem Feld nicht mehr brauche. Ich will es nicht komplett löschen. Muß ich die Objekte expliziet löschen bzw. wenn ich gar keine mehr brauche, wie bekomme ich dieses Feld gelöscht? Einfach bei der nächsten Nutzung überschreiben, oder kann ich da schon expliziet aufräumen???

Bin gerade etwas verwirrt, wie man vielleicht merkt

Frohe Ostern
Uwe

uwerothfeld schrieb:

ich habe eine Klasse welche ein statisches char-Feld enthält, in welches ich Objekte abspeicher, welche vom Typ dieser Klasse sind.

iih, das hört sich eklig an. kannst du ein bisschen code zeigen?

bitte WAS ?

ich vermute du konstruierst die klasse in dem array

dann musst du auch den destruktor aufrufen:

class a
{
public:
    a():i(1){}
    ~a(){i=0;}
    int geti(){return i;}
};
char buffer[64];
a *ptr = (a *)buffer;
a->a::a();
a->~a();

Nexus

Scheint mir auch eine eklige Vorgehensweise. Hat es einen Grund, wieso du das so machst? Da ist ja fast noch void* schöner.

Sofern es sich nicht um PODs handelt und man den Konstruktor aufruft, sollte man den Destruktor auch aufrufen. Ich würde aber eher Placement New und reinterpret_cast einsetzen.

uwerothfeld

Forhe Ostern,

also sorry das ich mich jetzt erst melde, die Familie ... ;).

Also ich habe ne Klasse ASTExpression, welche die verwendeten ASTExpressions in einer Liste speichern soll. Dies mach ich, da es bei meinem System kein malloc o.ä. gibt. Hier also die ASTExpression.h:

//define a list to store all expressions
static char expressionList[(sizeof(ExpressionType)+2*sizeof(ASTTerm*)+sizeof(ASTExpression*))*DSM_EXPRESSION_CNT_MAX];

static size_t expressionListIndex;

Es sollen DSM_EXPRESSION_CNT_MAX Elemente gespeichert werden, wobei die Größe eines Elementes aus der obigen Anweisung denk ich zu entnehmen ist.

In der ASTExpression.cpp habe ich dann folgendes:

size_t ASTExpression::expressionListIndex = 0;

char ASTExpression::expressionList[(sizeof (ExpressionType) + 2 * sizeof (ASTTerm*) + sizeof (ASTExpression*)) * DSM_EXPRESSION_CNT_MAX];

static void* ASTExpression::operator new (size_t size) {

        if (ASTExpression::expressionListIndex + size >
            (DSM_EXPRESSION_CNT_MAX * sizeof (ASTExpression))) {
            throw std::bad_alloc();
        }//End if
        else {
            ASTExpression::expressionListIndex += size;
            return ASTExpression::expressionList + ASTExpression::expressionListIndex - size;

        }//End else
    }//End operator new

Verwenden tue ich es mittels:

ASTExpression* e = new ASTExpression();

Kurz es sollte einigen hier bekannt vorkommen. Wenn ich dies mit Placement new richtig verstanden habe, dann ist dies hier eine solche Konstruktion. Zumindest zeigt mir der Debugger an das sich das Array langsam füllt. Gehe ich hier recht in der Annahme?

Nun habe ich einen Fall, da will ich aus dem Baum von ASTExpressions Elemente löschen. Dies ist unteranderem hier der Fall (Methodenausschnitt):

//current ASTExpression is ex
        ASTExpression* child = ex->getLeft();
        ex->setType(child->getType());

        if (child->getType() != DSM_EXPRESSION_TERM &&
            child->getType() != DSM_EXPRESSION_UNDEFINED) {

            ex->setLeft(child->getLeft());

            if (child->getType() == DSM_EXPRESSION_AND ||
                child->getType() == DSM_EXPRESSION_OR) {

                ex->setRight(child->getRight());
            }//End if
        }//End if

Nun bin ich gerade verwirrt, ob ich den ehemaligen, aktuellen Ausdruck per Destrukter zerstören muß, oder ob ich warten kann, bis ich eh alle (Zeitpunkt kommt nach einer Reihe von Transformationen) wegwerfe. Oder ist dies eh alles egal, da die Liste statisch ist, ich also eigentlich nur den Index zurücksetzen muß (dazu tendiere ich im Moment).

Frohe Ostern
Uwe