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?
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
Du übergibst nur die Anfangsadressen der zwei Arrays. Die Funktion weiss nicht, wie groß sie sind.
( sizeof ( int array[] ) geht nicht )
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
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.
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.
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. Positiv gemeint. In seine RTC Mega-Funktion muß ich mich auch immer wieder neu einlesen. Mit der Zeit wird das noch, hoffe ich.
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
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.
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.
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.
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.
