# Ansi c: Initialisierung eines Arrays zunächst unbekannter Dimension



## mopele (28. Dezember 2004)

Hallo,
 ich muss für mein Physikstudium, als Programmieranfanger, eine n-dimensionale "schnelle Fourrier Transformation" in ansi C schreiben. Das Programm soll in der Lage sein, einen Array zuvor nicht festgelegter Dimension aus einer Datei zu lesen, welcher dann später transformiert werden soll. Prinzipiell besteht die Datei aus einem Kopf und den Daten für den Array, welche formlos aneinander gereiht sind. Der Kopf definiert sich wie folgt: die erste Zahl entspricht der Anzahl der Dimensionen des zu füllenden Arrays, darauf folgen bei n Dimensionen n Integers, welche die Länge des Arrays bezüglich der jeweiligen Dimensionen angeben. Soweit so gut. Das spätere Einlesen, so denke ich bekomme ich hin, Probleme habe ich allerdings mit der Initialisierung des Arrays. (Einen riesigen, hochdimsionalen Array zu benutzen, der alle Fälle bewältigen soll, käme sicherlich nicht in Frage).
 Vielleicht hat jemand eine Idee oder ähnliches schon mal geschrieben. Mir wärs eine grosse Hilfe
 Grüsse

 ach, falls es von bedeutung ist: ich benutze einen einfachen Texteditor (KWrite) und den GCC.


----------



## Thomas Darimont (28. Dezember 2004)

Hallo!

Schau doch mal hier:
http://www.pronix.de/modules/C/openbook/c_programmierung_17.php
Gruß Tom


----------



## MetallDragon (28. Dezember 2004)

Ich weiss nicht, ob ich deine Frage richtig verstanden habe. Aber evtl solltest du mit Vektoren arbeiten. Das sind grob gesagt dynamisch erweiterbare Arrays.
Man könnte z.B erst mal reinschreiben, was man ausliesst und dann später die Grösse bestimmen.
Ich hoffe, dass dir das was hilft.


----------



## mopele (29. Dezember 2004)

Danke zunächst mal für den link. ich weiß jetzt wie man Speicherplatz fuer einen Array reserviert und diesen dynamisch erweitert. Allerding ist der Kern meines Problems weitestgehend unangetastet gebieben. 
 Ich würde gerne die Initialisierung eines Arrays erst beim Einlesen der Daten aus einer Datei vornehmen, da in dieser Datei selbst die Dimension und Grösse des Arrays vorgegeben ist.

 Ein Beispiel:
 Inhalt der Datei:
 2      
 3 4  
 1 2 3 4 5 6 7 8 9 10 11 12
 Die 2 in der ersten Zeile gibt die Dimension des Arrays vor. Die Ints in der zweiten Zeile besagen hier: Der Array hat 3 Zeilen und 4 Spalten, sodass er so aussieht:
 array[1][1]=1
 array[1][2]=2
  array[1][3]=3
  array[1][4]=4
 array[2][1]=5
 ....

  array[3][4]=12

 Das Programm soll jedoch auch höher Dimensionale arrays einlesen können. Das Einlesen habe ich schon, wenn auch wenig elegant, realisiert, das dynamische Initialisieren des Arrays, dessen Dimsion und Grösse aus der Datendatei mitausgelesen wird,  bereitet mir jedoch Probleme
 Gruß


----------



## PixelShader (29. Dezember 2004)

Warum nicht einfach so:
man nimmt eine 1. Dimensionale Array, und schreibt alle Daten hintereinander, wie in deiner Datei. Dann muss du die aus der Datei gelesenen Daten nicht mal umstrukturieren.

Welchen Datentyp nimmst du? Ich nimm mal float, dann wuerde das Array so aussehen:

```
float *Array;
```

Initialisierung des Arrays:

```
// Globale Variablen
int Dimensionen;  // Wird einfach aus der Datei gelesen
int *DimentsionMax; // Variable Array fur die "Dimension maximal Werte"
int ArraySize; // Die Groesse deiner Array

/* hier fullst du "Dimensionen" mit der Dimensionenanzahl (erste Zeile deiner Datei) */

DimensionMax = (int*)calloc(1, Dimensionen*sizeof(int)); // Dynamisch Speicher reservieren

/* hier fullst du "DimensionMax[]" mit den maximal Werten (zweite Zeile deiner Datei) */

// Die Groesse deiner hauptarray berechnen:
ArraySize = 1;
for(int i=0;i<Dimensionen;i++)
{
    ArraySize *= DimensionenMax[i];
}

Array = (float*) calloc(1, ArraySize*sizeof(float));

// Das einfullen des Arrays mit Daten:
for(i = 0; i < ArraySize;i++)
{
    Array[i] = /* lese naechste Zahl aus der Datei */;
}

// Kapiert  ;)
```

Beachte, dass du so eine foellig variable Anzahl an Dimensionen besitzst. Um so einen Zeiger auf irgendeine Zahl in deiner Array zu machen, musst du auch noch dafur eine variable Array erstellen, wo die Koordinaten in die Dimensionen alle geschpeichert sind.
z.B. ein 5-Dimensionaler Zeiger wird so aussehen:
int *Zeiger;
Zeiger[0] = x;
Zeiger[1] = y;
Zeiger[2] = z;
Zeiger[3] = a;
Zeiger[4] = b;

Also noch Hilfestellung beim Rauslesen aus der Array mit solchen variablen Zeigern (das Schreiben wird man wohl selbst hinkriegen):

```
// Dia Variablen von vorhin weden natuerlich immer gebraucht, und muessen als global deklariert sein.
ReadArray( int *Zeiger )
{
    int EchterZeiger=0; // Der dekodierter zeiger in unsere 1-Dimensonale Array
    int Abstand=1;    // Der Abstand zwischen Vektoren in diesem 1-Dimensianlem Array
    for(int i = 0; i < Dimensionen;i++)
    {
        EchterZeiger += Zeiger[i]*Abstand;
        Abstand *= DimensionMax[i];
    }
    return Array[EchterZeiger];
}
```


----------



## mopele (30. Dezember 2004)

Danke, ich weiß jetzt glaube ich wie ich es mache.
 Allerdings würde das Auslesen einer Spale, Reihe, Zeile etc. so wie du es vorgeschlagen hast nicht funktionieren. Die Varialble Abstand wäre nach Durchlaufen der Schleife gleich der Anzahl der Elemente meiner Datei und der Zeiger würde sonst wo hinzeigen. meintest du "Abstand +=...." anstatt "Abstand*=..." ?


----------



## PixelShader (30. Dezember 2004)

Hi,
Ich meinte schon "Abschtand *= ..." denn schau auf die vorherige Zeile. Da weise ich "EchterZeiger" zu und bereite in dieser Zeile "Abstand" auf den nächsten Loop vor.
Und, ja es ist richtig, "Abstand" ist am ende gleich der Anzahl der Elemente deiner Datei, oder gleich ArraySize.
Deine Behauptung würde stimmen, falls die beiden Zeilen vertauscht wären


----------

