Arrays aus Integern verbinden

Hallo,

ich habe beispielsweise zwei Arrays die voller Integer sind. Die Integer möchte ich in einem dritten Array so wie sie in den ersten zweien sind speichern. Meine Funktion, von der ich leichtsinniger weise dachte sie würde funktionieren, sieht so aus:

int array01[4] = {166, 167, 168, 169} ; 
int array02[5] = {180, 181, 182, 183, 184} ;


int arraymerge( int array01[], int array02[])
{
    int wert = 0 ;

    int arlen01 = sizeof(array01) / sizeof(array01[0]);		// array 1 laenge
    int arlen02 = sizeof(array02) / sizeof(array02[0]);		// array 2 laenge
    int arlen03 = arlen01 + arlen02 ;						// neues array 3 laenge
    int array03[arlen03];     // neues array 3 anlegen
 
	// inhalt von Array 1 in 3
	for(int i=0; i<arlen01; i++){
     	wert = array01[i] ;
        array03[i] = wert ; 
    }

	// inhalt von Array 2 in 3
	for(int i=0; i<arlen02; i++){
     	wert = array02[i] ;
        array03[i + arlen01] = wert ; 
    }


	// ausgabe von Array 3 zur kontrolle
	for(int i=0; i<arlen03; i++){
	 	wert = array03[i] ;
	 	Serial.println("Wert" + String(wert));
	}

	return array03

}

Jedoch funktioniert schon die Variablenübergabe nicht. Wie kann ich mein Vorhaben erreichen?

Hallo,

array im array speichern geht wirklich nicht. Ich weis auch nicht was das für einen Sinn ergeben soll, das rumkopieren, aber vielleicht hilft Dir das Stichwort "mehrdimensionale arrays" weiter.

Jedoch funktioniert schon die Variablenübergabe nicht

  1. Du übergibst nur die Anfangsadressen der zwei Arrays. Die Funktion weiss nicht, wie groß sie sind.
    ( sizeof ( int array[] ) geht nicht )
  2. Neues array anlegen und zurückliefern geht so auch nicht, da es nur temporär auf dem Stack ist, und nach Rückkehr aus der Funktion nicht mehr gültig.

( wobei der Rückgabetyp int waqs anderes ist als dein int array3[arlen3] )

Du hast vermutlich eine Vorstellung von Arrays, die nicht mit C / C++ übereinstimmt.
Wobei die Frage von Doc "was willst du eigentlich damit erreichen?" durchaus berechtigt ist.

Naja, ich will nicht das Array im Array Speichern, sondern "array03[9] = {166, 167, 168, 169, 180, 181, 182, 183, 184}" haben.

Edit: Ich habe einen LED-Streifen, wo je nach Gegebenheit unterschiedliche LED-kombinationen leuchten sollen. Da dachte ich es ist das einfachste, alle in ein Array und da mit einer for-Loop durchzugehen.

Vielleicht ist hier "typedef union" das passende Stichwort.
Passend über union vereinigt kann man die Struktur von 2 Seiten betrachten.
Einmal als 2 Einzelarrays und andererseits als 1 großes Array.
Irgendein "Merge", oder so, ist dann nicht mehr nötig

Hallo,

jetzt wird der Nebel klarer. Du möchtest den Inhalt von mehreren arrays in ein array kopieren.

Dann mußt Du ein array mit Indexnummer auslesen und den Wert in das neue array an eine Indexnummer schreiben.
Die Indexnummern mußte dann passend hochzählen.

array03[9] = array01[4];

würde den Wert von array01 Position 5 (Index4, wird von 0 an gezählt) in das array03 an Position 10 (Index9) kopieren. Die Indexnummer mußte mit einer Variable hochzählen.

Array vorher mit passender Größe +1 anlegen.

Edit:
was combie schreibt kenne ich noch nicht, sollte man auch mal ausprobieren. :wink:

Doc_Arduino: Ich denke genau das was du hast, habe ich in der Funktion oben gemacht. Array 1 und 2 wollen jedoch nicht in die Funktion rein.

Doc_Arduino:
Edit:
was combie schreibt kenne ich noch nicht, sollte man auch mal ausprobieren. :wink:

Hier mal ein Beispiel:

struct einzelarrays
{
    int A[4];
    int B[5];
};

typedef union verbund
{
   einzelarrays einzelne;
   int C[9];
};

verbund riesenarray =  {166, 167, 168, 169, 180, 181, 182, 183, 184} ;



void setup() 
{
  Serial.begin(9600);
}

int i = 0;
int j = 0;
int k = 0;

void loop() 
{
  
  if(i<9)
  {
    Serial.print("gross ");
    Serial.print(i);
    Serial.print(" ");
    Serial.println(riesenarray.C[i++]);
  }else if(j<4)
  {
    Serial.print("A ");
    Serial.print(j);
    Serial.print(" ");
    Serial.println(riesenarray.einzelne.A[j++]);
  }else if(k<5)
  {
    Serial.print("B ");
    Serial.print(k);
    Serial.print(" ");
    Serial.println(riesenarray.einzelne.B[k++]);
  }
}

An den Bezeichnern kann man noch arbeiten... :grin:
Aber das Prinzip sollte damit klar werden.

Hallo,

wegen Deiner Funktion. Du legst array3 lokal an und möchtest das zurückgeben. Das funktioniert so glaube ich auch nicht. Du müßtest das schon global anlegen wie die anderen auch. Damit kannste Dir auch das mit dem sizeof sparen. Dann mußte nur noch mit den Indexnummer jonglieren. Zum debuggen hilft auch Zwischenwerte von allen möglichen seriell ausgeben.

Combies struct sieht auch gut aus. :wink:

Doc_Arduino:
Combies struct sieht auch gut aus. :wink:

Danke für die Blumen.

Der wirkliche Vorteil ist, dass nix kopiert werden muss.
Und kopieren bedeutet immer doppelter Speicherverbrauch.
RAM ist knapp.

In PHP, oder so, wäre das Merge kein Problem, da kommts auf ein paar MB Ram nicht an.

Hallo,

hab das parallel zu Dir noch zu Ende gebracht. Ich schau mir Dein struct morgen in Ruhe genauer an. RAM sparen ist immer gut. Muß mich immer neu reindenken. Jeder hat seine Lieblingsbefehle bzw. Programmierstiel, auch wenn meiner nicht effizient ist. jurs jongliert auch mit struct's nur so rum als wenn er im Leben nichts anderes gemacht hat. :wink: Positiv gemeint. In seine RTC Mega-Funktion muß ich mich auch immer wieder neu einlesen. Mit der Zeit wird das noch, hoffe ich. :smiley:

Das ist jetzt nur zur Vollständigkeit, wie gesagt.

int array01[4] = {166, 167, 168, 169} ; 
int array02[5] = {180, 181, 182, 183, 184} ;
int array03[9];
 
void setup() {
  Serial.begin(9600);  
}
 
 
void loop() {
 arraymerge1to3();
 arraymerge2to3();
 array03_Ausgabe();
 
}  // end loop


void arraymerge1to3()  {
  
  // inhalt von Array 1 in 3
  for (int i=0; i<4; i++) {
    array03[i] = array01[i];   
  }
}  // end function


void arraymerge2to3()  {
  int IndexA3 = 4;
  
  // inhalt von Array 2 in 3
  for(int i=0; i<5; i++) {
    array03[i+IndexA3] = array02[i] ;
  }  
}  // end function


void array03_Ausgabe()  {	          // ausgabe von Array 3 zur kontrolle
  for(int i=0; i<9; i++) {
    Serial.print(F("Indexnummer: ")); Serial.print(i);
    Serial.print(F("  Wert: ")); Serial.println( array03[i] );
  }
}  // end function

Statt mit der union geht's auch so:

int gesamtarray[9] = {100, 101, 102, 103, 104, 200, 201, 202, 203 };
int* teil1 = gesamtarray; // 5 Elemente
int* teil2 = gesamtarray+5; // 4 Elemente nach teil1

Serial.println( teil2[0] ) ; // liefert "200"
Serial.println( teil2[2] ) ; // liefert "202"
teil2[3] = 999; // überschreibt die 203 in gesamtarray[8]

Das ist ja alles Toll und underschön, aber wie bekomme ich nun zwei Arrays in eine Funktion und eines wieder raus? Es gibt ca. 80 Arrays (vor Setup erstellt) mit 2-20 Integern drin, von denen je nach dem zwei stück zusammengesetzt werden sollen.

, aber wie bekomme ich nun zwei Arrays in eine Funktion und eines wieder raus?

Gar nicht!
Sowohl rein(Parameter), als auch raus(return) kannst du nur einfache Datentypen übergeben.
Z.B Zeiger auf Arrays
Aber keine Arrays.

Ok der Pythonweg ist also nicht möglich. Was schlagt ihr vor?
Ich wollte es als Funktion machen, weil ich vier Positionen im Programm habe wo Arrays zusammengesetzt werden sollen.

staivoup:
Wie kann ich mein Vorhaben erreichen?

Code zum Mergen von zwei Integer-Arrays:

int array01[4] = {166, 167, 168, 169} ; 
int array02[5] = {180, 181, 182, 183, 184} ;
int array03[9];

void arrayMerge( int* arr1, int arr1Size, int* arr2, int arr2Size, int* arrGesamt)
{
  memcpy(arrGesamt,arr1, arr1Size);
  memcpy(&arrGesamt[arr1Size/sizeof(int)],arr2,arr2Size);
}

Aufruf im Programm dann mit:

arrayMerge(array01,sizeof(array01),array02,sizeof(array02),array03);

Das aufnehmende 'array03' mus dabei groß genug sein, um die Inhalte beider Arrays aufzunehmen, eine Bereichsüberprüfung findet nicht statt. Wenn die Voraussetzung nicht erfüllt ist und 'array03' zu klein sein sollte, bekommst Du einen Buffer-Overflow mit nicht vorhersehbaren Auswirkungen auf den Ablauf Deines Programms.

Vielen Dank, das "memcpy" sieht gut aus. Ich teste es heute Abend.

Nur eine Frage: Bei dem zweiten memcpy ist ein "&" vor der Variable, was sagt das aus?

http://www.cplusplus.com/reference/cstring/memcpy/

Der Ausdruck mit dem & liefert eine Adresse auf ein Element mitten im Array.
Diese Adresse entspricht dem Zeiger, welcher von memcpy als erster Parameter erwartet wird.

staivoup:
Vielen Dank, das "memcpy" sieht gut aus. Ich teste es heute Abend.

Nur eine Frage: Bei dem zweiten memcpy ist ein "&" vor der Variable, was sagt das aus?

Wie combie schon schrieb, wird mit dem Adressoperator & und dem Index festgelegt, ab welcher Adresse der zweite Schreibvorgang in das resultierende Array erfolgen soll. Die memcpy-Funktion erwartet immer Pointeradressen auf einen Speicherbereich.

Den ersten Schreibvorgang könnte man statt so:

  memcpy(arrGesamt,arr1, arr1Size);

auch so schreiben:

  memcpy(&arrGesamt[0],arr1, arr1Size);

Ok, vielen Dank. Ich muß darüber nachdenken.

Edit: Der Zeiger von dem Combie sprach und jurs im Beispiel brachte: http://www.uni-duesseldorf.de/HHU/math_nat_fak/WE/physik/laserphy/Cplusplus/Vorlesung5