Wie kann ich einen neuen Eintrag zu einem Array hinzufügen - Seite 3

Neuer Kommentar
 
ReLor #:
Das ist in der Tat nicht so schwer, ein bisschen Grips bringe ich schon mit, auch als Newbie.

Ich versteh dennoch nicht wieso die Fehlermeldung kommt.

Wenn ich ein leeres Array mit 0 beginne zu indixieren, dürfe es doch gar nicht zu diesem Fehler kommen!?

Wenn ich das Array wie folgt in der Größe definieren möchte erhalte ich jedoch die Meldung "declaration without type" - vielleicht hängt es ja damit zusammen, bislang hatte ich auf den folgenden Code verzichtet weil ich annahm, dass ich dass (siehe oben) später machen könne..!?

"ArrayResize(my_array, 0);"

Du warst da vorhin schon auf der richtigen Spur.

Wenn Du array_size = ArraySize(Array[10]) abfragst, bekommst Du als Ergebnis array_size = 10 zurück. Die Größe des Aind zehn Felder.

Aber da das Array schon bei 0 anfängt sind die zehn Felder schon bei 9 vorbei. Fragst Du 10 ab, bist Du außerhalb der Reichweite Deines Arrays.

Also sobald Du Array[array_size] anforderst bekommst Du einen Out of Range Fehler

 

Hallo @pennyhunter

wenn ich Dich richtig verstehe müßte ich also um einfach ein neues Element zum Array hinzu zufügen nicht (wie ich es aus PHP kenne arraysize+1) sondern...

int size=ArraySize(my_array); //hat zubeginn ja 0=nix/leer

ArrayResize(my_array,size-1); //dann würde ich aber ja nicht bei 0 sondern -1 starten!?
(Aktuell bekomme ich ja nichtmals das erste Element hinzugefügt)
 
Ohje.

int values[];

int arr_size = ArrayResize(values, ArraySize(values) + 1);

values[arr_size - 1] = 4;

printf("Erster Wert im Array: %i", values[arr_size - 1]);


 
Dominik Egert #:
Ohje.

int values[];

int arr_size = ArrayResize(values, ArraySize(values) + 1);

values[arr_size - 1] = 4;

printf("Erster Wert im Array: %i", values[arr_size - 1]);


Danke für Deinen Beitrag aber das ist doch genau dass was ich bereits recht weit oben gepostet habe und damit lande ich ja immer beim Fehler "out of range". Zu beachten ist ggfls. dass ich mit einerm strukturiertem Array arbeite - (falls es relevant sein sollte)

int asize=ArraySize(my_array)+1;
        Print("ArraySize:",ArraySize(my_array)," asize:",asize); // Ergibt 0 bzw. 1
        ArrayResize(my_array,asize);
 
ReLor #:

Danke für Deinen Beitrag aber das ist doch genau dass was ich bereits recht weit oben gepostet habe und damit lande ich ja immer beim Fehler "out of range". Zu beachten ist ggfls. dass ich mit einerm strukturiertem Array arbeite - (falls es relevant sein sollte)

Befallen tust du immer mit beginn 1, es gibt keinen 0ten Wert beim Befüllen

wenn du 10 Werte in ein Array einliest dann sind das die Werte 1-10, wenn du das jetzt auslesen willst, dann sind das die Werte 0-9

da beim Auslesen immer mit 0 begonnen wird

 
Copy Paste meinen Code und probiere es aus.

Diskutiere nicht mit was du machst und was ich schreibe, wenn du offensichtlich etwas falsch machst.

So schwer ist das nicht...
 
amando #:

Befallen tust du immer mit beginn 1, es gibt keinen 0ten Wert beim Befüllen

wenn du 10 Werte in ein Array einliest dann sind das die Werte 1-10, wenn du das jetzt auslesen willst, dann sind das die Werte 0-9

da beim Auslesen immer mit 0 begonnen wird

WAAAAAS?!? Das kann ich so nicht stehen lassen... (Edit: Entschuldige bitte meine ungünstige Ausdrucksweise von heute Morgen) Schreib mir mal bitte eine Schleife die das macht OHNE Out of Range Fehler.

Index 0 ist Index 0, der Index des ersten Wertes.

Ein Array mit zehn Feldern wird über die Indizes 0-9 befüllt und abgerufen. Wenn Du in Copybuffer einen Count angibst, gibst Du vielleicht die Anzahl an, also zehn. 
double a_array[], b_array[], c_array[];
int array_size = 10;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit() {
//---
   ArrayResize(a_array, array_size);
   ArrayResize(b_array, array_size);
   ArrayResize(c_array, array_size);

   for(int i = 0; i < array_size; i++) {              //i geht nicht bis zehn, sondern hört bei neun auf, (ersetzt Du "kleiner als" durch "kleiner gleich", bekommst Du ebenfalls Out of Range)
      a_array[i] = (double)(i + 1);                   //der erste Wert ist der mit Index 0.
      b_array[i] = (double)(array_size - i);
      Print(a_array[i], " ; ", b_array[i]);
   }

   for(int i = 0; i < array_size; i++) {
      c_array[i] = a_array[i] / b_array[i];           // Hier wird gleichzeitig ausgelesen und befuellt.
                   Print (c_array[i]);
   }

//---
   return(INIT_SUCCEEDED);
}
 

Hallo nochmals.

Also ich bedauere es wirklich, dass ich aktuell an solch einer simplen Sache festhänge und eine so umfangreiche Diskussion führe. Dennoch wäre etwas Geduld hilfreich - schön das Ihr wisst wie es geht - ich möchte es ja gerade verstehen...

Zur Sache ich habe nun nochmals den von @Dominik Egert geposteten Code genommen, soweit so gut. 

struct my_array_struc
   {  
      //Definiere die Struktur
      int      field1;    
      int      field2;    
      double   field3;    
      //...etc.  
      
   };
   
   //Erstelle das Array und weise die Struktur zu
   my_array_struc my_array[]; 

   int asize=ArraySize(my_array)+1;
   Print("Test ArraySize:",ArraySize(my_array)," asize:",asize); // Ergibt 0 bzw. 1
   ArrayResize(my_array,asize);

Er läuft und gibt erwartungsgemäß 0 und 1 aus.

Gehe ich jedoch nun hin und möchte dieses neue Element befüllen, erhalte ich prompt wieder "out of range"

my_array[asize].field1=123;
ArrayPrint(my_array);

Verusche ich 

my_array[0].field1=123;

komme ich einen Schritt weiter und sehe, dass dem "field1" der Wert 123 zugewiesen wurde - AHA!
(Warum haben field2 und field3 so seltsame Werte eigentlich hätten diese doch leer sein sollen?)
[field1]   [field2]         [field3]
123         1072911154  1.20746

das führte mich nun zu folgendem

my_array[asize-1].field1=123;

und siehe da auch hier wird das Feld befüllt.

Nun komme ich zu dem Beitrag von @amando

Befallen tust du immer mit beginn 1, es gibt keinen 0ten Wert beim Befüllen

wenn du 10 Werte in ein Array einliest dann sind das die Werte 1-10, wenn du das jetzt auslesen willst, dann sind das die Werte 0-9

da beim Auslesen immer mit 0 begonnen wird

Diese Erklärung würde ich nun für mich so umdeuten:

Um ein neues Element zu einem Array hinzuzufügen frage ich die Größe mit ArraySize() ab. Diese gibt bei einem leeren Array 0.

Nun erhöhe ich die Größe auf 1 "Zeile" im Array. Der Index dieser Zeile ist aber ja nicht 1 sonder 0, weil die Indexierung hier im übrigen analog wie bei PHP bei 0 beginnt.
Im Endeffekt liegt immer 1 als Abstand zwischen dem Wert von arraySize() (zumindest wenn ich nur die Größe Stück für Stück erzeuge die ich brauche) und dem Index der jeweiligen Zeile. Bsp.die nächste Zeile wäre dann nun

        ArrayResize(my_array,ArraySize(my_array)+1); // 1 alte Größe +1 neuer Eintrag= neue Größe 2

        my_array[ArraySize(my_array)-1]=456; //weil Größe 2 jedoch Index=1
Hab ich das jetzt soweit korrekt dargestellt
 
Ja, hast du.

Sehr gut.

Warum haben Zellen eines Array unbekannte/undefinierte Werte?

Weil dir der Speicher zwar zugewiesen wird, jedoch steht an dem Speicher eventuell Müll von einer vorhergehenden Nutzung.

Deswegen musst du die dir zugeteilten Speicherzellen immer vor Benutzung initialisieren. - Immer!!!

Dafür gibt es ArrayFill, ArrayInitialize, ZeroMemory.

Doku hilft weiter.

123
Neuer Kommentar