Hi zusammen
Ich möchte ein Array einer Variable übergeben und bekomme es aufgrund
der verlangten Arraygrösse durch den Compiler nicht hin.
Um ein Array zurück zu geben, muss man sich einem Trick bedienen.
Dazu habe ich ein struct definiert. Ich habe das irgendwo aus dem
Internet.
Mein Ziel ist es ein Summenarrayaus 3 verschiedenen Arrays zu bilden .
Die Summe soll aber nur zwischen limitIndexLeft und Right gebildet
werden.
Das ist also auch letztendlich meine tatsächliche Arraylänge.
Im Main habe ich aber das Problem, dass ich nie weiss wie lang das Array
ist, da limitIndexLeft und Right unterschiedlich sein können. Wenn ich
den Array im struct einfach gross genug mache, funktioniert das auch
nicht. Das bringt ja auch nichts, da ich ja die Länge der beiden Arrays
direkt verändere. Also die des zurückgegebenen und die des neuen im
main, da beide selbige Variable nutzen.
Wie löse ich das am Besten?
1. sumArray wird in main(!) dynamisch erzeugt und nicht in der
Summenfunktion.
2. Es werden die Indexlimits beachtet.
3. Der Zähler t sorgt dafür, dass der Index bei 0 beginnt.
4. Eine zusätzliche Struct als "Trick" wird nicht verwendet
Vielen Dank
Das funktioniert bei mir jetzt.
Nun frage ich mich aber, warum die Länge meines sumarrays nicht richtig
ausgegeben wird.
Das sollte so doch gehen, bekomme aber den Wert = 2?!
Hans schrieb:> uint16_t getArrayLength(uint16_t *array)> {> ... sizeof(array)> }
Du übergibst der Funktionen einen Zeiger auf ein Array und fragst dann
dessen Größe ab. Des geht deswegen nicht, weil Arrays keine
Größeninformation enthalten.
Die Größe musst du als zweiten Parameter übergeben, so wie es zum
Beispiel auch bei memcpy() gemacht wird.
Hans schrieb:> getArrayLength(uint16_t *array)> {> uint16_t arrayLength;>> arrayLength = sizeof(array)/sizeof(array[0]);
Welchen Datentyp hat "array"? Wie groß ist er?
Welchen Datentyp hat "array[0]"? Wie groß ist er?
Hans schrieb:> val = getArrayLength(sumArray);
Wie oben schon angedeutet: sizeof() liefert bei Pointern nicht die Größe
des Arrays, sondern die Speichergröße des Pointers. Auf einem AVR sind
das 2 Bytes, auf 32-Bit-Systemen in der Regel 4 Bytes.
Schreibe doch einfach:
1
val=limitIndexRight-limitIndexLeft;
Das ist die Anzahl der Member in Deinem Summenarray. Die Funktion
getArrayLength() kannst Du Dir komplett sparen. Denk doch nicht so
kompliziert. ;-)
P.S.
Das obige gilt nur, wenn als Index limitIndexRight ausgeschlossen ist.
Du hast nämlich klammheimlich die Aufgabenstellung geändert:
Vorher: Array läuft von limitIndexLeft bis limitIndexRight ínklusive.
Nachher: Array läuft von limitIndexLeft bis limitIndexRight exklusive.
Wenn inklusive, musst Du das "+ 1" wieder mit reinnehmen und in der
for-Schleife die Bedingung wieder auf "<=" ändern.
val ändert sich dann natürlich auch:
Hallo zusammen
Ich denke im Moment deshalb so kompliziert, weil zur Zeit zB
limitIndexRight = 146
limitIndexLeft = 6
Das gibt eine Arraylänge von 140
Beginnend mit t=0 ergibt der letzte Index 139
Aber Index 140 ergibt jetzt bei mir so wie oben den richtigen Wert..
Das gibt es ja nicht.
Ansehen, kann ich das auch nicht wirklich direkt, weil die ArrayVariable
in einer Funktion (main) steckt.
Und ja:
sizeof von sumArray ergbit die Speichergrösse also 140x16bits =
280Bystes
sizeof von sumArray[0] ergibt 2 Bytes
280/2 = 140
Also warum 2?
Hans schrieb:> Also warum 2?
Weil du eben nicht "sizeof(sumArray)" gemacht hast sondern
"sizeof(array)" und "array" trotz seines verwirrenden Namens gar kein
Array, sondern ein Zeiger ist.
Ok, entschuldigt micht für die Fragen, aber dann müsste aber das
funktionieren:
im main:
uint16_t sumArray[limitIndexRight - limitIndexLeft];
calcSumArrayValues(arraydiffLS1, arraydiffLS2, arraydiffLS3, sumArray);
val = sizeof(sumArray)/sizeof(sumArray[0]);
Das Ergebnis 2 kann ich mir dann also so erklären, dass der Pointer die
Speichergrösse 4Bytes hat und die Pointerwert array[0] = 2Bytes
4/2 gibt 2
Richtig?
Hans schrieb:> val = sizeof(sumArray)/sizeof(sumArray[0]);
Warum so umständlich?
Da du das Array vorher explizit auf diese Größe festgelegt hast, genügt
doch:
> Das Ergebnis 2 kann ich mir dann also so erklären, dass der Pointer die> Speichergrösse 4Bytes hat und die Pointerwert array[0] = 2Bytes>> 4/2 gibt 2> Richtig?
So ist es.
Frank M. schrieb:> val = limitIndexRight - limitIndexLeft;Jörg W. schrieb:> val = (limitIndexRight - limitIndexLeft) * sizeof(uint16_t);
Was will der TO? Die Anzahl der Array-Member oder die Größe des
dynamischen Arrays in Bytes?
Nach den verzweifelten Versuchen mit
"sizeof(sumArray)/sizeof(sumArray[0])" zu urteilen, will er doch eher
die Anzahl und nicht die Größe, oder?
Aber da könnte Hans uns mal aufklären.
Ich hatte geschrieben, dass mir die differenz aus rechts u links nichts
bringt.
Da ich den wert im letzten index überprüfen wollte wollte ich es durch
siteof ermitteln ob das auch wirklich so übernommen wurde
dass mein letzter Index 140 ist macht ja iwie keinen Sinn. Müsste ja
nach t beginnend mit 0 höchstens 139 sein. deshalb
Hans schrieb:> Ok, entschuldigt micht für die Fragen, aber dann müsste aber das> funktionieren:> im main:> uint16_t sumArray[limitIndexRight - limitIndexLeft];> calcSumArrayValues(arraydiffLS1, arraydiffLS2, arraydiffLS3, sumArray);> val = sizeof(sumArray)/sizeof(sumArray[0]);>>
Bleibt also noch warum val hier 0 ist.
Das ist nun aber wirklich kein Zeiger mehr in den ein array zerfällt..
Hans schrieb:> dass mein letzter Index 140 ist macht ja iwie keinen Sinn. Müsste ja> nach t beginnend mit 0 höchstens 139 sein. deshalb
val ist die Größe des Summenarrays, also 140.
Wenn Du jetzt noch in main() eine Schleife über das Summenarray machen
möchtest:
1
uint8_tidx;
2
3
val=limitIndexRight-limitIndexLeft;// val ist 140
4
5
for(idx=0;idx<val;idx++)// idx geht von 0 bis 139
6
{
7
// mache etwas mit sumArray[idx]
8
}
Kann aber sein, dass ich noch nicht verstehe, was Du überhaupt willst.
Jetzt noch eine Bemerkung dazu:
Hans schrieb:> Bleibt also noch warum val hier 0 ist.
Hier ein vollständig übersetzbarer Beispiel-Code:
1
#include<stdio.h>
2
#include<stdint.h>
3
4
uint16_tlimitIndexLeft=7;
5
uint16_tlimitIndexRight=22;
6
7
intmain()
8
{
9
uint16_tsumArray[limitIndexRight-limitIndexLeft];
10
uint16_tval;
11
12
val=sizeof(sumArray)/sizeof(sumArray[0]);
13
printf("%d\n",val);
14
return0;
15
}
1
$ cc a.c && ./a.out
2
15
Das funktioniert also wie erwartet.
val kann dann 0 werden, wenn limitIndexLeft == limitIndexRight.
Ich habe leider keine Ahnung, welche Werte und Typen Deine (globalen?)
Variablen limitIndexLeft und limitIndexRight haben, denn darüber hast Du
Dich bisher ausgeschwiegen.