Maximale Array Größe beim Avrgcc?

Also soweit ich weiß ist die Array Größe durch "int" begrenzt.

Gruß

Theoretische Antwort: Die Grösse eines Arrays dürfte in C eigentlich nur 
vom verfügbaren Speicher abhängen und schlimmstenfalls noch von den 
Adressierungsgepflogenheiten der Zielarchitektur.

Praxisbezogene Antwort: Keine Ahnung, ich war mit Arrays noch nie dort, 
wo die Grösse nicht mehr reichte. Probier's halt aus und schau, welches 
die begrenzenden Faktoren sind.

Schlaumeierische Antwort: Wenn die Datenmenge gross wird, kommt der 
Zeitpunkt, wo malloc nützlich wird. Memoryleaks, seid willkommen!

Je nachdem wieviel Ressourcen Dir dein AVR bietet. Wenn Du Dein Array im 
SRAM ablegst ist es durch die Groesse des SRAMs abzueglich dem, was Du 
sonst noch brauchst (z.B. Stack) begrenzt. Andernfalls begrenzt durch 
die Groesse des verwendeten Speichers.

Und weiter? Wie gross ist dein Array, wie gross ist dein Flash und was 
ist da sonst noch so alles drin?

avrlover wrote:
> Ich hab es mit PROGMEM im Flash abgelegt. Aber der Compiler beschwert
> sich darüber das es zu groß ist

Code und literare Fehlermeldung, dann kann man eventuell was dazu sagen. 
Mit pauschalen Aussagen kann keiner was anfangen.

Da die Adress/Indexrechnung in 16 Bit mit Vorzeichen durchgeführt wird, 
kann ein Array nicht grösser werden als 32767 Bytes. Egal ob in RAM oder 
ROM.

Wer den Grund dafür nachvollziehen will: Die Berechnung der Differenz 
zweier Adressen wie in:
  basetype_t *p, *q;
  ptrdiff_t delta = p - q;
darf man sich intern so vorstellen:
  ptrdiff_t delta = (char *)p - (char *)q;
  delta /= sizeof(basetype_t);
Und ptrdiff_t ist notwendigerweise vorzeichenbehaftet. Wenn das ein 
16bit int ist, landet man zwanglos bei einem Limit von 32767, auch dann 
wenn basetype_t kein char ist.

Und wer sich fragt, warum das Limit nicht 32768 ist: Bei einem array[N] 
existiert zwar keine Element array[N], aber für dessen Adresse muss
  &array[0..N-1] < &array[N]
gelten.

Abhilfe, allgemeine Form: Statt
  basetype_t array[N];
mit N%K==0 verwendet man
  basetype_t array1[N/K], array2[N/K], ... arrayK[N/K];
  basetype_t array[K] = { array1, array2, ... arrayK };
und teilt den Index entsprechend auf:
  array[i/(N/K)][i%(N/K)]
was man in einem Makro verstecken kann.

In der Praxis sollte man statt mit einer teuren Division allerdings mit 
Subtraktion arbeiten.

Hm... naja. Muss man halt zwei Arrays verwenden und feddich :D

Ich geh mal davon aus, diese 32768 Bytes beziehen sich auf den Array 
allgemein, also unabhängig, wie viele "Dimensionen" ich hab...
d.h. array1[32768] geht nicht und array2[1024][32] geht ebensowenig wie 
array3[32][32][32]...

Yep, Tippfehler. Korrekt ist
  basetype_t *array[K] = { array1, array2, ... arrayK };
dann geht's.