Hallo,
ich würde gerne mehrere Positionen eines Arrays parallel beschreiben.
Hier ein Beispiel in Pseudocode:
byte LED_st[] = {
0,0,0,0,0,3};
LED_st = {1,3,2,1,x,x};
Die Postionen an denen ein "x" steht, sollen unangetastet bleiben.
Das gewünschte Ergebnis wäre somit:
LED_st == {1,3,2,1,0,3};
Klar könnte ich einfach..
LED_st[0] = 1;
LED_st[1] = 3;
LED_st[2] = 2;
LED_st[3] = 1;
..schreiben, doch geht das bzgl. der Schreibweise nicht auch etwas kompakter?
Gruß Chris
Wenn die zu beschreiben Stellen einen durchgehenden Bereich abdecken geht das mit memcpy():
http://www.cplusplus.com/reference/cstring/memcpy/
byte original[] = { 1, 2, 3, 4, 5 };
byte toCopy[] = { 0, 0, 0 }
memcpy(original + 1, toCopy, 3);
Ergebnis: { 1, 0, 0, 0, 5 }
Aber das geht damit nicht:
byte LED_st[] = { 0,0,0,0,0,3};
LED_st = {1,x,2,x,x,x};
Cool! 
Danke.
Achtung, das funktionietrt nur bei Variablen vom Typ BYTE oder CHAR, nicht vom Typ INT oder LONG ecc.
2. Achtung Du arbeitest direckt mit dem Speicherinnhalt. Wenn Du eine Fehler machst (Zb falsche Adresse nimmst oder falsche Länge) dann üerschreibst du Irgend eine Variable.
Grüße Uwe
Ok. Wie würde man dies dann z.B. im Fall von int lösen?
Für meinen Fall (Byte) passt es nun zunächst einmal.
Gruß Chris
Du musst nur den 3. Parameter anpassen, der die Anzahl der zu kopierenden Bytes angibt:
int original[] = { 1, 2, 3, 4, 5 };
int toCopy[] = { 0, 0, 0 }
memcpy(original + 2, toCopy, 3 * sizeof(int);
Ergebnis: { 1, 2, 0, 0, 0 }
Das "original + 2" bezieht sich auf die Indices. Ist also unabhängig vom Datentyp.
sizeof(int) = 2, aber so kann man es leichter auf andere Datentypen anpassen
Hallo,
ich bins noch einmal. Ich verstehe eine Klinigkeit noch immer nicht.
Anbei zwei Beispiele..
Hier sollen die ersten fünf Speicherstellen von main_LED_st mit dem Inhalt von sw_e_1 beschrieben werden.
byte sw_e_1[5] = {
1,0,0,0,0 };
byte main_LED_st[6] = {
0,0,0,0,0,0};
memcpy(main_LED_st, sw_e_1, 5 * sizeof(byte));
Hier soll etwas passieren, wenn der Inhalt der beiden angegebenen Arrays nicht identisch ist.
byte old_LED_st[6] = {
0,0,0,0,0,0};
byte main_LED_st[6] = {
0,0,0,0,0,0};
if (memcmp(old_LED_st, main_LED_st, sizeof(old_LED_st)))
{
}
Was ist nicht verstehe ist in beiden Fällen der sizeof-Teil.
Ich verstehe nicht, warum sich einmal eine Datengröße (Byte) in der Klammer nach sizeof befindet, und einmal der Name eines der beteiligten Arrays.
5 * sizeof(byte) sizeof(old_LED_st)
Evtl. habe ich beim zusammenstellen der benötigten Informationen auch nur etwas falsch abgetippt und eines der Beispiele ist fehlerhaft.?
Ich bitte (nochmals) um Aufklärung.
Gruß Chris
Chris72622:
Ich verstehe nicht, warum sich einmal eine Datengröße (Byte) in der Klammer nach sizeof befindet, und einmal der Name eines der beteiligten Arrays.
Hallo,
das erste Beispiel liefert Dir 5 mal die Größe des Datentyps Byte, hier also 5 Byte, das zweite Beispiel liefert Dir die Größe des gesamten Arrays, hier also 6 Byte.
Wenn Du willst, lies mal hier ab dem Abschnitt "sizeof()".
Gruß,
Ralf
EDIT:
Ok, memcmp() passt doch so. Sorry. Es geht da alles ungleich 0 true ist. Ich würde aber != 0 dahinter schreiben. Dann sieht man auf den ersten Blick, dass man Ungleichheit meint.
Wegen sizeof():
memcpy(main_LED_st, sw_e_1, sizeof(st_we)); sollte auch gehen
Das hängt auch damit zusammen wie viel man aus dem Array kopieren will. Wenn man das ganze Array kopieren will ist sizeof(array) natürlich einfacher. Aber es geht so oder so, solange die Anzahl der Bytes passt.
Es gibt aber auch Fälle in denen man nicht sizeof(array) machen kann. z.B. wenn man nur einen Pointer auf ein Array hat und Teile von zwei-dimensionale Arrays. Dann gibt sizeof() nur die Größe des Pointers zurück (hier 2)
Serenifly:
memcpy(main_LED_st, sw_e_1, sizeof(st_we)); sollte auch gehen
Meinst Du..
memcpy(main_LED_st, sw_e_1, sizeof(sw_e_1))
..?
Gruß Chris
Ja. Sorry. Copy/paste Fehler 
Bei sizeof() hier immer die Größe der Quelle angegeben.
Dank Dir.
Gruß Chris
Wie kann man denn ein Array komplett mit "neuen" Werten füllen, ohne ein weiteres Array für die "Füllung" zu nutzen?
Beispiel:
int tolles_Array[] = {1,2,3,4};
Ich möchte erreichen, dass es nach der "Befüllung" so aussieht:
tolles_Array[] == {8,3,6,6};
Kann man dies einfach so erreichen (Achtung: Pseudocode)?
tolles_Array[0-3] = {8,3,6,6};
Gruß Chris
Geht nicht. Wäre nett, aber die Initalisierungs-Klammern kann man nur einmal benutzen wenn das Array angelegt wurde, da das bei der Compilierung geschieht und nicht zur Runtime.
Man kann nur alle Elemente mit einer Anweisung auf den gleichen Wert setzen, aber nicht auf verschiedene.
Du kannst dir vielleicht eine Funktion dafür schreiben
void fillArray(byte* destination, byte e1, byte e2, byte e3, byte e4)
{
destination[0] = e1;
....
}
Ist natürlich nicht flexibel was die Länge des Arrays betrifft
Super Tipp.
Manchmal ist die Lösung einfach einfach.
Danke.
Wenn ich mir diese Funktion gebaut habe..
void e_sw(byte e1, byte e2, byte e3, byte e4, byte e5)
{
main_LED_st[0] = e1;
main_LED_st[1] = e2;
main_LED_st[2] = e3;
main_LED_st[3] = e4;
main_LED_st[4] = e5;
}
..darf ich dann..
e_sw(1,2,3,,5);
..scheiben, wenn ich nicht möchte, dass sich..
main_LED_st[3]
..ändert?
Gruß Chris
Nein. Du musst schon alle Parameter übergeben. Du kannst bei dem Datentyp des Parameters auf int umsteigen, damit man negative Zahlen hat. Dann kannst du das machen:
void e_sw(int e1, int e2, int e3, int e4, int e5)
{
if(e1 >= 0)
main_LED_st[0] = e1;
}
Wenn du dann -1 übergibst, wird nichts geändert. Die Wandlung von int auf byte geht automatisch. Ist nicht wirklich schön, aber es funktioniert.