Feld über ein Feld legen

[Andreas Fertl (Gast)]

Hi Leute,

ich würde gerne ein Feld über ein Feld legen (um Speicherplatz zu
sparen). Und zwar so...

Das Ursprungsfeld ist:

short Test[512];

und das kleinere Feld, welches ich 4 mal darüberlegen will ist:

short TestSmall[128];

Ich möchte nämlich nur auf 128 Werte eine Operation ausführen.

Ein
TestSmall=&Test[0];
OperationOnTestSmall();
TestSmall=&Test[128];
usw.
funktioniert natürlich nicht.

Aber, so im Prinzip hätte ich es gerne, da ich dann ganz einfach auf
die Feldinhalte zugreifen und meiner OperationOnTestSmall schön
übergeben.

Wie macht man denn sowas?
Kann ich das nur mit nem Pointer machen?
Dadurch würde dann der schöne Zugriff über [x] wegfallen.
Ein Feld ist doch eigentlich auch nur ein Pointer...

Güße Andreas

[Andreas S. (andreas) (Admin)]

TestSmall ist einfach nur ein Zeiger, du musst kein neues Array
definieren. Probier's mal mit
short *TestSmall;

[Jens D. (jens)]

2 dimensionales array??
aber ich verstehe den sinn nicht..
warum du damit speicherplatz sparst??

ob du:
512BIT schreibst
oder 128 128 128 128 BIT ist doch das gleiche oder?

[Michael Wilhelm (Gast)]

So richtig erschließt sich mir der Sinn auch nicht, aber so geht es:

union
{
  unsigned char test[512];
  unsigned char test1[128];
  unsigned char test2[128];
  unsigned char test3[128];
  unsigned char test4[128];
}
beispiel;

Hab ich eben kompiliert, 512 Byte RAM mehr.

MW

[Unbekannter (Gast)]

@Michael,

nein, so geht das nicht ganz. Der Ansatz ist zwar gut, aber die
Umsetzung hat ein kleinen Fehler.

So wie ich Andreas verstanden habe, will er die vier kleineren Felder
unabhängig voneinander haben. Also so:

union
{
  short test[512]
  short small[4][128]
} 
beispiel;

Oder:

union
{
  short test[512];
  struct
  {
    short test1[128];
    short test2[128];
    short test3[128];
    short test4[128];
  } 
  small;
}
beispiel;

Oder, oder, oder... Möglichkeiten gibt's viele...

[Andreas Fertl (Gast)]

Mhm, habs mir auch nochmal durch den Kopf durchgehen lassen.
Und mit der Union überlegt...

Wie lautet hier denn der code Tag im Forum?

union
{
  unsigned short gross[512];
  struct
  {
    short klein1[128]         : 16;
    short klein2[128]         : 16;
    short klein3[128]         : 16;
    short klein4[128]         : 16;
  } kleinzugriff;
}grosszugriff;


So wäre es möglich...
@Unbekannter
Muss ich nicht die Speicherbreite im struct angebn?

Nur brauch ich dafür viel Code.

Die Sache ist die, ich will ne FFT über 128 Werte laufen lassen.
Insgesamt habe ich aber 512 Werte.
Eigentlich könnte ich hergehen und die Werte aus dem 512er Feld
kopieren in ein 128er Feld. FFT machen und dann zurück in das 512er
Feld.
Das dauert länger (umkopieren) und braucht mehr Speicher. [128] Feld.
Wenn ich das Feld in 4 Teile aufteile, entfällt das ganze. Ich brauche
die Ursprungsdaten des A/D Wandlers nicht mehr.

Das isst der gedanke dahinter.

Nur ist es so dass mein Feld nicht 512 Werte hat sondern 6192 = 54 *
128 Werte. Müsste also viel Code schreiben um die jeweilige FFT auf das
jeweilge Feld ausführen zu lassen.

[Rolf Magnus (Gast)]

> Mhm, habs mir auch nochmal durch den Kopf durchgehen lassen.
> Und mit der Union überlegt...
>
>
> Wie lautet hier denn der code Tag im Forum?

Klikce einfach bei meinem Posting auf des kleine Fragezeichen oben. Da
steht dann, wie's geht.

> union
> {
>   unsigned short gross[512];
>   struct
>   {
>     short klein1[128]         : 16;
>     short klein2[128]         : 16;
>     short klein3[128]         : 16;
>     short klein4[128]         : 16;
>   } kleinzugriff;
> }grosszugriff;

Wozu immer die Bitfelder? Der short ist doch schon 16bit groß. In C99
nimmt man übrigens am besten int16_t aus <stdint.h>.

> So wäre es möglich...
> @Unbekannter
> Muss ich nicht die Speicherbreite im struct angebn?

Was für eine Speicherbreite?

> Nur brauch ich dafür viel Code.

Wofür?

> Die Sache ist die, ich will ne FFT über 128 Werte laufen lassen.
> Insgesamt habe ich aber 512 Werte.
> Eigentlich könnte ich hergehen und die Werte aus dem 512er Feld
> kopieren in ein 128er Feld. FFT machen und dann zurück in das
> 512er Feld.
> Das dauert länger (umkopieren) und braucht mehr Speicher. [128]
> Feld.
> Wenn ich das Feld in 4 Teile aufteile, entfällt das ganze. Ich
> brauche die Ursprungsdaten des A/D Wandlers nicht mehr.
>
> Das isst der gedanke dahinter.

Dafür brauchst du das ganze aber doch gar nicht. Da reicht auch ein
Zeiger auf das erste Byte des 128er-Feldes. Also:

short* TestSmall;

TestSmall = Test + 128 * IndexKleinesFeld;
OperationOnTestSmall();

> Nur ist es so dass mein Feld nicht 512 Werte hat sondern 6192 = 54
> * 128 Werte. Müsste also viel Code schreiben um die jeweilige FFT
> auf das jeweilge Feld ausführen zu lassen.