Array nach Pascal-Art



  • Hi,

    wäre es nicht irgendwie wünschenswert, wenn es als Alternative zu den normalen Feldern und den doch mit ein wenig Overhead versehenen Vektoren in C++ auch einfache Arrays wie in Pascal gäbe, wo man die Ober- und Untergrenze frei definieren und über High und Low bei Bedarf abfragen könnte. Sicher kann man das auch irgendwie zusammenbasteln, aber als direkt eingebauter Typ wäre es sicher effizienter. Was meint Ihr dazu.

    Gruß Mümmel



  • Hallo,

    Ich wüsste nicht wozu. Mir haben die vorhandenen Arrays immer ausgereicht. In boost bzw. tr1 gibt es ja noch mehr (boost::array, boost::multi_array).



  • Für den Normalbedarf reichen die vorhandenen Möglichkeiten (Arrays und std::vector<>) vollkommen aus - auch wenn es evt. etwas Umgewöhnung für Pascal-Schreiber erfordert, daß der Index grundsätzlich mit 0 beginnt.

    Wenn dir das nicht reicht, schreib dir doch eine eigene Template-Klasse dafür.



  • Ach ja, bei den Borland-Compilern gibt es sowas ja schon. Nennt sich DynamicArray



  • CStoll schrieb:

    Für den Normalbedarf reichen die vorhandenen Möglichkeiten (Arrays und std::vector<>) vollkommen aus - auch wenn es evt. etwas Umgewöhnung für Pascal-Schreiber erfordert, daß der Index grundsätzlich mit 0 beginnt.

    Schlimmstenfalls lässt sich auch das mit einem Fünfzeiler recht schnell beheben. 😉



  • Hi,

    naja, das mit dem Beheben ist kein Problem. Aber speziell wenn was quelltextmäßig aus anderen Sprachen kommt wäre das gut brauchbar.
    Sonst verschenkt man bei mehrdimensionalen Arrays ne menge Platz oder eben Laufzeit. Oder man muß alles auf die andere Felduntergrenze umstellen -> Fehlerträchtig. Ne richtig vom Compiler realisierte Lösung wäre bestimmt leistungsfähiger.

    Gruß Mümmel



  • Da bleibt wohl nur selber schreiben:

    template<typename T,int Min,int Max>
    class PascalArray
    {
      T data[Max-Min+1];
    public:
      T& operator[](int pos)
      { return data[pos-Min]; }
    ...
    };
    
    template<typename T>
    class dynPascalArray
    {
      int min,max;
      vector<T> data;
    public:
      dynPascalArray(int nmin,int nmax)
      : min(nmin),max(nmax),data(nmax-nmin+1)
      {}
      T& operator[](int pos)
      { return data[pos-min]; }
    ...
    };
    


  • Hi,

    ja, vielen Dank auch, löst aber auch nicht so das eigentliche Problem, denn wenn man das als 3-4-dimensionales Array macht, dann gibt das garantiert einen Verwaltungsoverhead, der nicht von schlechten Eltern ist. Da wäre eine direkte Sprachlösung, wo der Compiler den Prozessor und dessen Möglichkeiten "kennt" und direkt ohne Hilfskonstrukte zugreifen kann sicher um Größenordnungen effizienter.

    Wer die Sache wohl dann doch mal lieber in Delphi probieren und hoffen, daß das effizienter ist. Trotzdem Danke.

    Gruß Mümmel.



  • Nein, ergibt keinen Overhead! Wenn du dich mal mit Arrays beschäftigen würdest, wüsstest du, das eine Buildin-Lösung nicht anders arbeiten könnte, als die von Hand gebaute. In C++ kannst du mittels Temlates praktisch Buildin-Typen bauen. In C++ wird kein Unterschied zwischen Buildin und Non-Buildin Typen gemacht.

    Wenn du keine Templates benutzen willst, hast du halt Pech gehabt!



  • Der Pascal-compiler wirds nicht anders machen als CStolls Vorschlag und sich irgendwo die Grenzen merken und das dann jeweils auf ein 0..X array umrechnen. Ob du das nu als eingebautes Feature hast oder wie hier einen 5-Zeiler schreibst, wird bei eingeschalteten Optimierungen keinen Performance-Unterschied mehr machen, da die ganze "Rechenarbeit" (den offset draufaddieren/abziehen, was ein Aufwand!) beim Compilieren durchgefuehrt wird.



  • Du kannst dir ja mal 2 kleine Programme zum Vergleich basteln. Ich finde aber, du solltest nicht überrascht sein, wenn C++ effizienter ist. Overhead gibt es bei Delphi gewöhnlich sowieso mehr (vergleiche mal den Speicherverbrauch in der Prozessliste). Was die Geschwindigkeit angeht, würde ich auch auf C++ setzen. Es ist bestimmt auch mit der Subtraktion beim Zugriff schneller als Delphi. Du kannst aber auch Zeigerarithmetik verwenden, um ohne Subtraktion auf Elemente zugreifen zu können:

    template<typename T,int Min,int Max>
    class PascalArray
    {
      T data[Max-Min+1];
      T * const ptr2MinB4data;
    public:
      PascalArray() : ptr2MinB4data(data-Min) {}
      T& operator[](int pos)
      { return ptr2MinB4data[pos]; } 
    //...
    };
    


  • Hi,

    nochmals vielen Dank allen. Bin leider erst heute wieder on air.
    Ich hab nichts gegen Templates, hatte nur die Hoffnung, daß der Compiler bei direkten Typen noch irgendwelche gemeine Tricks in der Hinterhand hat.
    Aber es wird wohl so sein.
    Hab da wahrscheinlich noch zu viele Vorurteile von einer ähnlichen Sache die damals auf einem 386 SX lief und mit den damals noch als normalen Klassen versuchten Lösungen der Emulation von Pascal-Feldern nicht aus dem Knick kam.
    War damals nen Versuch von etwas Grafikarbeit, wo man die Bildpunkte fast mit der Bohrmaschine hätte schneller setzen können. Seitdem sind mir Felder mit mehreren Dimensionen immer etwas suspekt.
    Das auch bei Borland C++-Anwendungen dem Augenschein nach schneller laufen ist mir auch schon aufgefallen, kann es mir aber nicht erklären wiese, da zumindest bei den älteren Versionen der C++ und der Delphi-Compiler identisch sein sollten und nur von unterschiedlichen Parsern gefüttert wurden. Vielleicht ist das aber nicht mehr so.

    Gruß Mümmel


Log in to reply