dynamische mehrdimensionale Arrays wie statische Arrays ansprechen?

[HaWe]

hallo,
wie kann man dynamische mehrdimensionale Arrays wie statische Arrays ansprechen?
(C-code, aber streng genomen mit cpp kompiliert)

z.B: ich habe einen statischen Array
double arrayst[100][30]
und brauche einen weiteren gleich großen dynamischen
double arraydyn[100][30]

memory allozieren könnte ich per
double *mem = (double*) malloc(100*30*sizeof(double));

aber wie kriege ich das jetzt sauber in einen 2-dim array?
per union?

union a { 
  double *mem;
  double arraydyn[100][30];
}


a.mem=(double*) malloc(100*30*sizeof(double));

for (int i=0; i<100; i++) {
  for (int j=0; j<30; j++)  {
   a.arraydyn[i][j]=arrayst[i][j]*0.123;
  }
}

wäre das so korrektes "C"?

Oder geht es weniger umständlich mit C++ und new oder auch ganz anders?

[Rumgucker]

Moin Helmut,

ich würde mehrdimensionale Arrays möglichst vermeiden, denn irgendwann weiß man nie so genau, was der Compiler da eigentlich indiziert. Lieber klare Verhältnisse schaffen:

#define X		100
#define Y		30
#define IND(x,y)	((x * X) + y)

double arrayst[X * Y] = {47.11, 0.815};
double *arraydyn = (double*)malloc(X*Y*sizeof(double));

for (int i=0; i < X; i++) {
  for (int j=0; j < Y; j++)  {
   arraydyn[IND(i,j)]=arrayst[IND(i,j)]*0.123;
  }
}

Wenn das nicht Deinen Geschmack trifft, setz ich mich zum Rumspielen mal an den Compiler.

Viele Grüße

Wolfgang

[HaWe]

hallo,
danke, aber gerade die dyn. mehrdim. Arrays sind unbedingt wichtig, damit der bestehende, für stat. arrays geschriebene Code 1:1 übenommen werden kann - ansonsten wäre es einfach.
Ich bin allerdings nicht sicher, ob mein Code mit den unions wirklich 100% korrekt ist - oder ob es noch einfachere Wege gibt.

(wichtig: es ist der von Arduino verwendete gpp C++14 Compiler!)

[Rumgucker]

Hallo Helmut,

so wird Dein Code geschluckt

double arrayst[100][30];

union {
  double *mem;
  double arraydyn[100][30];
} a;


a.mem=(double*) malloc(100*30*sizeof(double));

for (int i=0; i<100; i++) {
  for (int j=0; j<30; j++)  {
   a.arraydyn[i][j]=arrayst[i][j]*0.123;
  }
}

Ich versuch ihn mal zu vereinfachen.

Viele Grüße

Wolfgang

[HaWe]

ich musste den Code jetzt testweise für den ESP8266 "downsizen", offenbar hat der bei weitem zu wenig RAM für heap.
In meiner union-Def. war offenbar auch ein Fehler, ich habe deinen Code mal für mich angepasst:

#define LINE 20
#define ROW  10

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println();
  Serial.println("Serial() started");

  float arraystat[LINE][ROW ];

  union {
    float *mem;
    float arraydyn[LINE][ROW ]; // 10*20*4=800 bytes
  } a;


  a.mem = (float*) malloc(LINE * ROW  * sizeof(float));

  for (int i = 0; i < LINE; i++) {
    for (int j = 0; j < ROW ; j++) {
      arraystat[i][j]=i*(j*1000);
    }
  }

  for (int i = 0; i < LINE; i++) {
    for (int j = 0; j < ROW ; j++) {
      a.arraydyn[i][j] = arraystat[i][j] * 0.01;
    }
  }

  for (int i = 0; i < LINE; i++) { 
    yield();
    for (int j = 0; j < ROW ; j++) {
      Serial.println (a.arraydyn[i][j]);
    }
  }


}

void loop() {


}

- - - Aktualisiert - - -

Sieht gut aus! (edit: zumindest auf den 1. Blick laut Serial.print)
Jetzt wäre nur noch die Frage, ob's auch 2-dim ohne unions geht...

[Rumgucker]

Hallo Helmut,

Sieht gut aus!

Ich bin noch nicht so ganz überzeugt. Ich denke, dass Dein Union auf einen sinnlosen 3000 double-Speicher zeigt, der dann einfach nie gebraucht wrid, weil er von dem malloc-Zeiger umgangen wird.

Jetzt wäre nur noch die Frage, ob's auch 2-dim ohne unions geht...

Daran grübele ich gerade.

Viele Grüße

Wolfgang

[HaWe]

Und mir ist auch noch nicht klar, ob die union a wirklich dynamisch im heap angelegt wird (und nicht im stack).
eigentlich müsste es ja im Code per
a->arraydyn[][] gehen, nicht per a.arraydyn[][]
oder nicht?