Speicherprobleme bei sehr großen struct arrays

mngbd schrieb:

Janjan schrieb:

Richtig: Programm vernünftig designen.

Gute Idee. Aber ist es denn vernünftiges Design, 450900 unnötige Zeiger zu haben, die nur Probleme machen, und über 450900 mal malloc() und free() aufzurufen?

Nein. Habe ich auch nie behauptet.

mngbd

mngbd schrieb:

Janjan schrieb:

Richtig: Programm vernünftig designen.

Gute Idee. Aber ist es denn vernünftiges Design, 450900 unnötige Zeiger zu haben, die nur Probleme machen, und über 450900 mal malloc() und free() aufzurufen?

Stimmt gar nicht. Die innerste Dimension ist ja ein zusammenhängender Bereich von Strukturen und nicht von Zeigern. Die Zahl ist 1503.

Jürgen123

hm also das programm mit ein paar kommentaren kann man hier anschaun: http://docs.google.com/View?id=dgvm7qcx_0qbg2x8gg

ist mir klar dass das alles nicht gut programmiert ist, es muss auch nich total effizient sein nur wäre gut wenn es laufen würde und mir n ergebnis ausspuckt. (gut die rechenzeit dürfte gerne etwas geringer:) )
es wäre natürlich besser gewesen die felder der structs dynamisch je nach bedarf zu erstellen, das übersteigt aber meine kenntnisse und wie gesagt, solang der computer bei der berechnung nicht abstürzt ises ok:)

FrEEzE2046

Da sind aber ein paar Syntaxfehler drin. Kompiliert doch so gar nicht. Wenn die Größe pro Array nur 5 ist (wegen n = 5), dann ist das auch nicht zu groß für den Stack.

Bei 750.000 sieht's da schon anders aus. Ganz nebenbei: Die Einrückung ist der Horror.

Jürgen123

super ne:) da merkt man einfach dass da n pro am werke war.
jetzt läufts...

Jürgen123

Danke an alle für die tips,
falls mal jemand das gleiche problem hat, hier ne lösung die funktioniert:

#ifndef HEADER_H
#define HEADER_H

#define N=10;
typedef struct {
 int lala;
 int blabla;
} my_type_t;

my_type_t *** best;
my_type_t ** batch;

#endif // HEADER_H

#include <stdio.h>
#include <stdlib.h>
#include "header.h"

void init_2d(my_type_t *** var_2d, const int size_x, const int size_y) {
	int i;

	*var_2d = (my_type_t **) malloc(size_x * sizeof(my_type_t *));
	for (i = 0; i < size_x; i++) {
		(*var_2d)[i] = (my_type_t *) malloc(size_y * sizeof(my_type_t));
	}
}

/*
 * Initialize dynamic 3-Dimensional Array of Type "my_type_t"
 */
void init_3d(my_type_t **** var_3d, const int size_x, const int size_y, const int size_z) {
	int i;

	*var_3d = (my_type_t ***) malloc(size_x * sizeof(my_type_t **));

	for (i = 0; i < size_x; i++) {
		init_2d(&(*var_3d)[i], size_y, size_z);
	}
}

int main(void){
int i,j;
init_2d(&batch, N, N);
init_3d(&best, N, N, N);
// mach was damit:)

for (i = 0; i < N; i++) {
		free(batch[i]);
	}
	free(batch);
	for (i = 0; i < N; i++) {
		for (j = 0; j < N; j++) {
			free(best[i][j]);
		}
		free(best[i]);
	}
	free(best);
return 0;
}

#define X_WIDTH 5
#define Y_WIDTH 5
#define Z_WIDTH 5
#define ARR_3D(arr,x,y,z) arr[x*X_WIDTH+y*Y_WIDTH+z]

int main(void){
  int x,y,z,c=0;
  int *arr = malloc(X_WIDTH*Y_WIDTH*Z_WIDTH);
  if(!arr)
    return 1;

  for(x=0;x<X_WIDTH;x++)
    for(y=0;y<Y_WIDTH;y++)
      for(z=0;z<Z_WIDTH;z++)
        ARR_3D(arr,x,y,z) = c++;

  for(x=0;x<X_WIDTH;x++)
    for(y=0;y<Y_WIDTH;y++)
      for(z=0;z<Z_WIDTH;z++)
        printf("%d:%d:%d %d",x,y,z,ARR_3D(arr,x,y,z));

  free(arr);
  return 0;
}

so klappts evtl. auch

lg lolo

[quote="noobLolo"]
int *arr = malloc(X_WIDTH*Y_WIDTH*Z_WIDTH*sizeof(int));
[/cpp]

#define ARR_3D(arr,x,y,z) arr[x + y*X_WIDTH + z*X_WIDTH*Y_WIDTH]

so sollt der index stimmen.

#define ARR_4D(arr,x,y,z,i) arr[x + y*X_WIDTH + z*X_WIDTH*Y_WIDTH + i*X_WIDTH*Y_WIDTH*Z_WIDTH]