Zunächst entschuldige ich mich für den langen Weg zu einer solch simplen Frage.

Ich implementiere eine Klasse, die als sehr langer eindimensionaler Index auf einer raumfüllenden Kurve oder dem n-Tupel dient, das die kartesische Koordinate darstellt, der der Index entspricht.

<code>class curvePoint
{
public:
    friend class curveCalculate;

    //Construction and Destruction
    curvePoint(): point(NULL), dimensions(0) {}
    virtual ~curvePoint(){if(point!=NULL) delete[] point;}

    //Mutators
    void convertToIndex(){ if(isTuple()) calc(this); }
    void convertToTuple(){ if(isIndex()) calc(this); }
    void setTuple(quint16 *tuple, int size);
    void setIndex(quint16 *index, int size);
    void setAlgorithm(curveType alg){algorithm = alg;}

    //Inspectors
    bool isIndex(){return current==Index;}
    bool isTuple(){return current==Tuple;}
    size_t size(){return dimensions;}
    quint16 operator[](size_t index);

    enum curveType{HilbertCurve, ZCurve, GrayCodeCurve};
    enum status{Index, Tuple};

private:
    curveCalculate calc;
    curveType algorithm;
    quint16 *point;
    size_t dimensions;
    status current;
};
</code>

(Die Länge des Arrays, auf das von gezeigt wirdPunkt istMaße)

Wie auch immer, bei der Implementierung von operator [] habe ich mich gefragt, was die beste Methode ist, um Grenzen zu überprüfen. Ich möchte vermeiden, Ausnahmen auszulösen, wenn dies überhaupt möglich ist, und der gesamte Wertebereich kann für jede Zahl im Array verwendet werden, sodass ein spezieller Wert, der im Falle eines Fehlers außerhalb der Grenzen zurückgegeben wird, ebenfalls nicht möglich ist.

Ich dachte an so etwas, obwohl es in der Klassendefinition implementiert war:

<code>quint16 curvePoint::operator[](size_t index)
{
    return point[ index % dimensions ];
}
</code>

Dies macht es so, dass wir nie die Grenzen des Arrays verlassen und wenn gut dokumentiert, denke ich, dass es in Ordnung wäre; Trotzdem bin ich dieser speziellen Implementierung nicht gewachsen.

Schaut dies für andere akzeptabel aus? Gibt es eine andere Möglichkeit, die Grenzen zu überprüfen, während meine Einschränkungen weiterhin erfüllt werden?

Edit: Berechnung von Dingen wie Hilbert-Kurven usw. sind sehr chaotisch, so chaotisch, dass ich die zusätzliche Schnittstelle für die stl-Bibliotheken nicht im Weg habe.

Da ich jedes Mal, wenn die mehrdimensionale Datenbank abgefragt wird, viele Tausend davon konvertieren muss, möchte ich die zusätzlichen Kosten der stl-Funktionsaufrufe in der Mischung nicht, wenn überhaupt möglich.

Mir gefällt die Idee der Behauptung eher; aber wenn ich mich richtig erinnere, dass Releases in Builds kaputt gehen, nicht wahr?

Ich nehme an, ich kann Ausnahmen verwenden, das scheint das zu sein, worauf sich jeder stützt, aber ich verwende die Qt-Bibliotheken und diese vermeiden Ausnahmen sowohl für die Leistung als auch für die Portabilität, und ich hatte gehofft, dasselbe zu tun.