Fragen von einem "Dummy" - Seite 126

Neuer Kommentar
 
Renat:

Seit wann sind alle Arrays statisch, und alle Größen und Indizes auch statisch?

Da Arrays fast immer dynamisch sind und Indizes Variablen sind, können zum Zeitpunkt des Aufrufs keine ernsthaften statischen Prüfungen vorgenommen werden. Die einzigen Prüfungen, die noch durchgeführt werden müssen, sind Meta- und Rtti-Prüfungen, und deshalb ist es so wichtig, dass man Zugriff auf das gesamte Objekt bzw. die gesamte Beschreibung hat und nicht auf gut Glück mit einem Stück Speicher arbeitet.

Gehen wir also der Reihe nach vor: Bei statischen Arrays lässt sich alles zur Kompilierzeit leicht überprüfen, oder?

Für die dynamischen (mit ausgeblendeten Objekten!) gibt es doch Metainformationen zur Laufzeit, oder? Natürlich gibt es das.

Es bleibt nur noch, die Laufzeitprüfungen im ausführbaren Code der zu kompilierenden Funktion anzugeben. Und das war's!

Und ich sage nicht, dass das ein Kinderspiel ist. Nun, Slava (Stringo) kennt sich auch aus. Wer hat es heutzutage schon leicht? :)

// Schließlich wird alles zu viert gemacht.

// Wenn sie bereits über dynamische Arrays verfügen, verwenden Sie die Metainformationen, die sie überall mit sich führen!

// Damit kann man sogar wunderbare Dinge tun (z. B. dem Benutzer erlauben, Arrays unbekannter Dimension zu übergeben).

// Und in mql5(!) kann man nicht einmal ein zweidimensionales Array mit beiden Unbekannten an eine Funktion übergeben.

// Sogar in der antiken Kröte kann man das tun. :))

 
Renat:

Machen Sie sich keine Sorgen, alles ist von langer Hand geplant worden.

Die Folgen eines Verstoßes gegen die Schutzprinzipien kennen wir sehr gut - es ist der Weg des "im April haben wir 12 weitere kritische Fehler behoben, die es ermöglichen, aus der virtuellen Maschine auszubrechen und die Kontrolle über das System zu erlangen".

Die Folgen dieser speziellen Lösung riechen nicht einmal nach "Kontrolle des Systems". Ich habe Sie nicht nach solchen Funktionszeigern gefragt. Das Höchste, was es tun kann, ist, den Speicher "eines anderen" zum Absturz zu bringen, wenn er sich außerhalb des Bereichs des Arrays befindet, das falsch kontrolliert wird.
 
MetaDriver:

Das war mein Vorschlag, die Benennung und damit die starre Typisierung einzuführen, zumal dies die einzige Stelle ist, die nicht von der Benennungstypisierung abgedeckt wird und daher gut zur Ideologie der Universalisierung von Sprachentitäten passt.

2. Trotzdem: Erstens ist es schief, und zweitens ist es überhaupt nicht universell. Schlagen Sie einen Weg vor,(1) ein zweidimensionales mql-Array in einen OpenCL-Puffer zu kopieren, ohne es unnötig umzuschreiben und in Strukturen zu wickeln, oder(2) Ihre eigene Funktion ArrayCopy(...) für nicht-uniforme Arrays zu verwenden (für Geschwindigkeit).

// Entschuldigen Sie die Abruptheit des letzten Beitrags. Wirklich unnötig. Ich habe mich aufgeregt, als es hieß: "Wir wollen die Dinge nicht komplizieren". Denn das führt nur zu Komplikationen.

2a: Ich denke, Ihre "Eindimensionalitätsbeschränkung" für Funktionen wie ArrayCopy() kann in vielen Fällen mit einer elementaren Klausel in den Kommentaren schmerzlos aufgeweicht werden: "Die Funktion funktioniert auch mit mehrdimensionalen Arrays, solange das mehrdimensionale Array vollständig kopiert wird. "

Das würde eine Menge Probleme beseitigen. // Aber natürlich nicht alle.

Es gibt zwei Möglichkeiten: Die eine ist, eindimensionale Arrays separat zu kopieren, aber das ist nicht gut, weil die OCL-Schnittstelle dann mit Arrays überladen ist,

Die zweite Möglichkeit besteht darin, ein eindimensionales Array als zweidimensionales darzustellen, da es ohnehin per Band an OCL übergeben wird. Es geht also folgendermaßen. Übrigens könnten die Datenverschiebungen bei Änderung der Dimension in OCL durch Kopieren eines Teils des Arrays erfolgen; es hängt alles von der Größe ab und davon, ob es kosteneffektiv ist.

class CArrayTwo_merniy
  {
   float             a[];
   int               size_i;
   int               size_j;
public:
                     CArrayTwo_merniy(void){size_i=0;size_j=0;};
                    ~CArrayTwo_merniy(void){};
   void              Resize(int i,int j)
     {
      int size;
      if(j<size_j)// если уменьшаем j размер массива
        {
         for(int l=1;l<i;l++)
            for(int k=0;k<j;k++)
               a[l*i+k]=a[l*size_i+k];
         size=ArrayResize(a,i*j);
         if(size==i*j)
           {size_i=i; size_j=j;}
         return;
        }
      else // иначе, если увеличиваем j размер массива
        {
         size=ArrayResize(a,i*j);
         if(size==i*j)
           {
            for(int l=i-1;l>=0;l--)
               for(int k=j-1;k>=0;k--)
                  a[l*i+k]=a[l*size_i+k];
            size_i=i; size_j=j;
           }
        }
     };
   void set(int i,int j,float v)
     {
      if(i*size_i+j>=0 && i*size_i+j<size_i*size_j)a[i*size_i+j]=v;
      else Print("Ошибка set ["+i+":"+j+"]");
     };
   float get(int i,int j)
     {
      if(i*size_i+j>=0 && i*size_i+j<size_i*size_j)return(a[i*size_i+j]);
      else {Print("Ошибка get ["+i+":"+j+"]"); return(EMPTY_VALUE);}
     };
  };
//+------------------------------------------------------------------+
void OnStart()
  {
   CArrayTwo_merniy ar; string t;
   ar.Resize(3,3); int cnt=0;
   for(int i=0;i<3;i++)for(int j=0;j<3;j++){ar.set(i,j,(float)cnt); cnt++;}
   t="исх ";for(int i=0;i<3;i++){for(int j=0;j<3;j++)t+="["+ar.get(i,j)+"]";t+=".";} Print(t);
   ar.Resize(5,5);
   t="5х5 "; for(int i=0;i<5;i++){for(int j=0;j<5;j++)t+="["+ar.get(i,j)+"]";t+=".";} Print(t);
   ar.Resize(3,3);
   t="3х3 ";for(int i=0;i<3;i++){for(int j=0;j<3;j++)t+="["+ar.get(i,j)+"]";t+=".";} Print(t);
  }
 
Urain:

Es gibt zwei Möglichkeiten: Die eine ist, eindimensionale Arrays separat zu kopieren, aber das ist nicht gut, weil die OCL-Schnittstelle dann mit Arrays überladen ist,

Die zweite Möglichkeit besteht darin, ein eindimensionales Array als zweidimensionales darzustellen, da es ohnehin per Band an OCL übergeben wird. Es geht also folgendermaßen. Übrigens können die Datenverschiebungen bei einer Änderung der Dimensionalität in OCL durch Kopieren eines Teils des Arrays erfolgen; dies hängt von der Größe ab und davon, inwieweit es kosteneffektiv ist.

многа многа букаф

Ich habe genug von all dem. :) Occam ist hysterisch...

;)

Hier habe ich ein zweidimensionales Array. Ich habe seine sizeof(My2DArray). Was brauche ich noch, um es in den Puffer zu kopieren? Jedenfalls hat mir niemand einen Offset in meinem Array gegeben, um daraus eine Variable zu machen. Also, nein. Zuerst muss ich es umschreiben (was zu Verzögerungen führt) oder mein eigenes zweidimensionales Array schreiben. (!!) Oh, mein Gott. Und wofür ist das gut? So kann ich sicher sein. (!) Das war's, ich lache. :)))

 
MetaDriver:

Das ist alles, wovon ich genug habe. :) Occam ist hysterisch...

;)

:))

Offen gesagt ist der Overhead bei der Größenanpassung enorm, aber Sie können ihn reduzieren, indem Sie OCL für diese Dinge verwenden.

Aber das direkte Kopieren eines zweidimensionalen Arrays in einen OCL-Puffer.

Und ich würde Ihnen nicht raten, das Array bei jedem Niesen neu aufzuteilen.

So wie es ist, ist es ziemlich zutreffend.

 
MetaDriver:

Das ist alles, wovon ich genug habe. Occam ist hysterisch...

;)

Komm schon, es sind drei Funktionen zum Abrufen und Ändern der Größe.

Ich habe es für dich auf meinen Knien geschrieben, während du Trübsal geblasen hast.

 
Urain:
Komm schon, das sind eine Menge Wörter, drei Funktionen setzen, get und Resize
Ich wette, das ist cool. Wenn sie uns die Überladung von Operatoren ermöglichen (und vergessen Sie nicht, die Operatoren "[ ]" und "=" überladbar zu machen), dann werden wir Spaß haben. Wir werden in der Lage sein, unsere dynamischen Arrays auf dem Markt zu verkaufen. Und sie werden es annehmen! Und wer wird sie nicht nehmen - schalten wir die Gasübertragung von mehrdimensionalen Arrays in Funktionen aus. :)
 
MetaDriver:
Cool, kein Zweifel. Wenn sie uns das Überladen von Operatoren ermöglichen (und vergessen Sie nicht, den Operator "[ ]" vorladbar zu machen), dann werden Sie zufrieden sein. Wir werden unsere eigenen dynamischen Arrays auf dem Markt verkaufen. Und sie werden es annehmen! Und wer es nicht nimmt - schalten wir die Gasübertragung von mehrdimensionalen Arrays in Funktionen ab. :)
Wir werden es nicht vergessen ;)
 
mql5:
Wir werden es nicht vergessen ;)
:))
 
MetaDriver:

Ich habe ein zweidimensionales Array. Ich habe seine sizeof(My2DArray). Was brauche ich noch, um es in den Puffer zu kopieren? Jedenfalls hat mir niemand einen Offset in meinem Array gegeben, um daraus eine Variable zu machen. Also, nein. Zuerst muss ich es umschreiben (was zu Verzögerungen führt) oder mein eigenes zweidimensionales Array schreiben (!!) Nun, das ist ein Chaos. Und wofür ist das? Um mich in Sicherheit zu bringen. (!) Das war's, ich lache. :)))

Sehr geehrter Herr, achten Sie auf den Kontext.

1) Wenn Sie von einer kontrollierten und sicheren Umgebung in einen völlig unkontrollierten Rohpuffer wechseln, sind Sie selbst für die Kompatibilität mit dieser binären Umgebung verantwortlich.

2) Wenn Sie Code schreiben, sind Sie für die Architektur dieses Codes verantwortlich. Und jammern Sie nicht, dass es schwer ist, "Pferd und Kuh in einen Wagen zu setzen", wenn Sie unterschiedliche Strukturen verwenden.

3) Ich empfehle Ihnen, die Beschreibung von CLBufferRead und CLBufferWrite zu lesen - dank der universellen void*-Referenz können Sie jede Art von Referenz an OpenCL übergeben. Und es gibt auch Versatzstücke und Größen. 

uint  CLBufferRead(
   int          buffer,                    // хендл на буфер OpenCL
   const void&  data[],                     // массив значений
   uint         buffer_offset=0,           // смещение в OpenCL буфере в байтах, по умолчанию 0
   uint         data_offset=0,             // смещение в массиве в элементах, по умолчанию 0
   uint         data_count=WHOLE_ARRAY      // количество значений из буфера для чтения, по умолчанию весь буфер
   );

uint  CLBufferWrite(
   int          buffer,                    // хендл на буфер OpenCL
   const void&  data[],                     // массив значений
   uint         buffer_offset=0,           // смещение в OpenCL буфере в байтах, по умолчанию 0
   uint         data_offset=0,             // смещение в массиве в элементах, по умолчанию 0
   uint         data_count=WHOLE_ARRAY      // количество значений из массива для записи, по умолчанию весь массив
   );

Ich kann sehen, dass das Thema einfach aus dem Nichts aufgetaucht ist.

1...119120121122123124125126127128129130131132133...277
Neuer Kommentar