Ich möchte ein mehrdimensioneles Array erzeugen wobei die Dimensionen während der Laufzeit bestimmt werden. Zum Beispiel:

dim1, dim2, dim3 = f(a,b,c);

Und dann:

float array[dim1][dim2][dim3];

Wenn die Dimensionen im Bereich von ca. 4x4x4 sind funktioniert das Programm. Sobald die Dimensionen im Bereich von 100x100x100 liegen, bekomme ich einen "Segmentation fault".

Da einige Arrays fünf oder mehr Dimensionen haben, möchte ich for-Schleifen vermeiden.

Wie müsste also eine Speicherzuweisung (z.B. mit malloc) aussehen, damit ich keine "Segmentation fault" bekomme?

Vielen Dank schon mal,
Adrian

...oder Du benutzt vector<vector<vector<int> > >

...oder Du baust Dir ein 3D-Array nach a la

template<typename T>
class array3d
{
   std::vector<T> elements_;
   std::size_t size1_;
   std::size_t size2_;
   std::size_t size3_;

public:
   explicit array3d(std::size_t s1=0, std::size_t s2=0, std::size_t s3=0);

   T      & operator()(std::size_t i1,std::size_t i2,std::size_t i3);
   T const& operator()(std::size_t i1,std::size_t i2,std::size_t i3) const;

   std::size_t size1() const;
   std::size_t size2() const;
   std::size_t size3() const;

   void swap(array3d & with) {
     using std::swap;
     elements_.swap(with.elements_);
     swap(size1_, with.size1_);
     swap(size2_, with.size2_);
     swap(size3_, with.size3_);
   }

   array3d& operator=(array3d x) {
     this->swap(x);
     return *this;
   }
};

template<typename T>
inline swap(array3d<T> & a, array3d<T> & b){a.swap(b);}

u.s.w.

Gruß,
SP