Array auswählen

Hallo,

in einem meiner Projekte sollen Werte von Arrays ausgelesen werden.

Hierfür schreibe ich momentan eine Funktion.

Ich möchte innerhalb der Funktion Arrayindexe auslesen, weiss nun aber leider nicht, wie es bewerkstelligen kann, diese Auslesevorgäng auf jeweils ein bestimmtes Arrays anzuwenden.

Ich möchte die besagte "Auslesefunktion" ja lediglich nur einmal schreiben um dann wahlweise eines von mehreren Arrays auslesen zu können.

Gruß Chris

Sowas funktioniert nicht?

int auslesen (int array[], int index)
{
return (array[index]);
}

Grüße Uwe

Wenn alle Arrays vom gleichen Typ sind, dann kannst Du einen Pointer auf das Array übergeben, wenn die Arrays unterschiedliche Typen haben, wird es schwerer. Was aber meinst Du genau mit "Arrayindexe" auslesen? Kannst Du ein Beispiel geben?

Denn ein int a =readValue( myarray, 5); ist ja auch nicht besser als int a = myarray[5];

Mario.

Hallo,

die Arrays sind alle vom selben Typ, jedoch unterschiedlich lang.

Ein Beispiel wäre..

byte a = array_01[5];

oder (falls das "nächste" Array ausgelesen werden soll..

byte a = array_02[5];

Kannst Du mir ein Beispiel geben, wie Du das mitr der "Auswahl" des Arrays meinst?

Gruß Chris

Sowas?

int getValue(int* array, int index)
{
    return array[index];
}

Arrays in C sind nur syntaktischer Zucker für Zeiger. Eine Array Variable ist ein Zeiger auf das erste Element. Man übergibt also einen Zeiger auf den Datentyp als Parameter.

Die Syntax von uwefed sieht man auch manchmal und es ist nicht falsch. Aber das verschleiert etwas was eigentlich gemacht wird. Das suggeriert irgendwie dass das gesamte Array übergeben wird. Es ist aber nur der Zeiger.

Oder du erstellst ein jagged Array. Ein zwei-dimensionales Array bei dem die Teil-Arrays unterschiedlich lang sind: http://forum.arduino.cc/index.php?topic=221951.msg1612210#msg1612210 Dann kannst du auch einen Index für das Array übergeben. Das ist vielleicht eher was du willst.

byte array_1[30];
byte array_2[30];
byte array_3[255];

byte* arrays[] = {array_1, array_2, array_3 };

Dann kann man einfach Dinge wie arrays[1][5] machen

Ich verstehe den Sinn hinter dieser Funktion noch immer nicht. Wo ist der Mehrwert hinter einer solchen Funktion?

Mario.

mkl0815: Ich verstehe den Sinn hinter dieser Funktion noch immer nicht. Wo ist der Mehrwert hinter einer solchen Funktion?

Auch wenn ich dir praktisch Recht gebe, hat "Daten-Abstraktion" einen Sinn. Dem Aufrufer kann es dann egal sein, ob die Zahl, die er über einen Index adressiert, im RAM oder sonstwo, in Form eines Arrays oder einer anderen Sammlung liegt oder gar nur bei Anfrage ausgerechnet wird.

Manchmal gehen C++ Trickser aber den umgekehrten Weg und programmieren einen [] - Operator, damit auch Daten, die eventuell eigentlich gar nicht in einem Array liegen, so gelesen und gar geschrieben werden können. Overloading operator [ ]

michael_x:

mkl0815: Ich verstehe den Sinn hinter dieser Funktion noch immer nicht. Wo ist der Mehrwert hinter einer solchen Funktion?

Auch wenn ich dir praktisch Recht gebe, hat "Daten-Abstraktion" einen Sinn. Dem Aufrufer kann es dann egal sein, ob die Zahl, die er über einen Index adressiert, im RAM oder sonstwo, in Form eines Arrays oder einer anderen Sammlung liegt oder gar nur bei Anfrage ausgerechnet wird. ...

Das verstehe ich, finde das gerade in C/C++ bei Arrays aber gefährlich, da zur Laufzeit der Funktion ja keine Informationen über die Größe des Arrays vorliegen. Bei einem Array im Quellcode kommt man evtl. noch auf die Idee mal zu schauen ob der Index "out of bound" ist. Bei einer abstrahierten Funktion ist das schon nicht mehr so offensichtlich.

Ob int getValue(byte index) den Index prüft, kann ein Aufrufer der Funktion nicht wissen, stimmt.
Und sollte auch egal sein, das ist Aufgabe der Funktion getValue.
Das ist ja gerade Sinn der Sache. ( Abstraktion des Array-Zugriffs )
Auch was bei falschem Index passieren soll, ist ziemlich offen. Kann aber, anders als bei direkter Array-Adressierung, beliebig realisiert werden.
Dass man in C / C++ “gefährlich” programmieren kann, ist auch jedem klar.

Wenn schon Abstraktion, dann eine Klasse Array, die im Konstruktor die Größe bekommt und das Ganze von Hand per malloc und free verwaltet. Die kann sich dann auch die Größe des Arrays merken und man kann ggf. sogar zur Laufzeit die Größe ändern.
Notfalls in plain C auch ein struct typedef mit Längenvariable und passenden Funktionen.

Hallo,

Uwe, ich habe Dein Beispiel leider nicht verstanden. Vielleicht habe ich meine Frage auch zu schwammig formuliert.

Ich möchte mein Problem anhand des folgenden Beispiels verdeutlichen:

Bei Eintritt in die tolle_funktion steht fest, welches Array innerhalb der tollen Funktion ausgelesen werden soll. Diese tolle Funktion möchte ich auf verschiedene Arrays anwenden können, ohne für jedes Array eine eingene tolle Funktion schreiben zu müssen. Damit ich dies gewährleisten kann, habe ich eine kleine Zusatzfunktion namens auslese_funktion geschrieben, bei der ich jedoch das Gefühl habe zu kompliziert gedacht zu haben.

byte array_01[] = {34, 32, 4, 7};
byte array_02[] = {43, 2, 7, 2};
byte array_03[] = {35, 39, 40, 70};
byte array_nummer;

void setup()
{
}

void loop()
{
  // An dieser Stelle entscheidet sich, welches Array innerhalb der tollen Funktion gelesen werden soll
  array_nummer = 2;  // Notlösung hierfür von mir
  tolle_funktion();
}

void tolle_funktion()
{
  blabla;
  auslese_funktion();
  blabla;
  blabla;
  blabla;
}

void auslese_funktion(byte leseindex)
{
  switch(arraynummer)
  {
    case 1:
     index_wert= array_01[leseindex];  // Die Variable index_wert wird dann innerhalb der tollen Funktion vweiterverarbeitet
     break;
    case 2:
     index_wert= array_02[leseindex];  // Die Variable index_wert wird dann innerhalb der tollen Funktion vweiterverarbeitet
     break;
    case 3:
     index_wert= array_03[leseindex];  // Die Variable index_wert wird dann innerhalb der tollen Funktion vweiterverarbeitet
     break;
  }
}

Uwe, wie könnte ich mein Code auf Dein Beispiel umbauen?

Wäre es alternativ u.U. einfacher mit einem mehrdimensionalen Array zu arbeiten und die momentan einzelnen Arrays in die einzelnen Zeilen des neuen mehrzeiligen Arrays zu schreiben?

Gruß Chris

OK, jetzt wird es klarer. Dann passt doch für Dich der Vorschlag von Serenifly perfekt:

byte array_01[] = {34, 32, 4, 7};
byte array_02[] = {43, 2, 7, 2};
byte array_03[] = {35, 39, 40, 70};

byte* alle_werte[] = {array_01, array_02, array_03 };

Der Zugriff erfolgt dann wie beschrieben per alle_werte[0][z] auf das erste Array mit dem index "z". Auf Array 2 greifst Du dann mit alle_werte[1][y] zu usw.

Mario.

Ja, der Vorschlag passt definitiv.

Jetzt hab auch endlich ich es gecheckt. :P

Danke allen!

Gruß Chris

Wenn alle Teil-Arrays gleich lang sind kannst du übrigens auch einfach ein normales 2-dimensionales Array erstellen:

byte array [][4] = { {34, 32, 4, 7}, {43, 2, 7, 2}, {35, 39, 40, 70} };

Der Vorteil eines jagged Arrays liegt darin, dass die Teil-Arrays nicht die gleiche Länge haben müssen.

Ja, klar. In meinem Fall handelt es sich jedoch um Melodien, welche sich in einer Kette von einzelnen Bytes in verschiedenen Arrays befinden und diese sind halt unterschiedlich lang.

Danke für den Nachtrag.

Gruß Chris