[c/c++]Brett vorm kopf / Ich will ein Feld zurückgeben...

[Hannnibal]

Moin,
folgendes:

int** buildDistances (Daten daten[],int size) {
int distances[size][size];
int temp;
for (int x=0; x < size ;x++) {
for (int y=0; y < size ;y++) {
temp=getDistance(daten[x],daten[y]);
distances[x][y]=temp;
distances[y][x]=temp;
}
}
return distances;
}

Tut nicht...
cannot convert `int (*)[((size - 1) + 1)]' to `int**' in return
Es wär mal nett wenn mir jemmand erklärt wie das geht ;).
Ich bin nämlich eher der java mensch...:(
mfg

edit es geht noch weiter...
Wie übernehme ich das feld das die fkt zurückliefert im Hauptprogramm?
int **distance=buildDistances(daten);
So wohl nicht? :]

[i_hasser]

Geht nicht, weil distances eine lokale Variable ist die du über ihre Werte zurückgibst.

Theoretisch (!) würde 'return &&distances' klappen, dummerweise ist die lokale Variable aber sowieso ungültig wenn du die Funktion verlässt.

Was auch nicht gehen dürfte: 'int distances[size][size]' - lokale Variablen müssen eine vorgegebene Größe besitzen.

Also praktisch kannst du das so lösen:


int** buildDistances (Daten daten[],int size) {
int temp;

//int distances[size][size];
int **distances=new int*[size];
for(temp=0;temp<size;temp++) distances[temp]=new int[size];

for (int x=0; x < size ;x++) {
for (int y=0; y < size ;y++) {
temp=getDistance(daten[x],daten[y]);
distances[x][y]=temp;
distances[y][x]=temp;
}
}
return distances;
}


Du könntest auch nur eine Dimension nehmen (mit größe size*size) und die Indize per x/size+y berechnen.

Multidimensionale Arrays sind unter C so eine Sache, wesentlich einfacher dürfte sich ein Vektor machen.

[Hannnibal]

Moin,
THX i_h :).
falls es interessiert...nach einigem zeiger biegen (und brechen) und suchen bin ich hierdrauf gestossen:

Wir wollen hier kurz auf die dynamische Speicherverwaltung vorgreifen und eine weitere Technik zur dynamischen Erzeugung mehrdimensionaler Felder schildern. Der operator new type[N] gibt einen Zeiger auf das erste Element eines linearen Speicherbereiches von N Variablen des Typs type zurück. Um ein zweidimensionales Feld von, sagen wir, Dimension NM zu erzeugen, kann man zunächst einen Speicherbereich von NM Elementen anfordern. Dann kann man ein Hilfsfeld von Pointern einrichten, die auf die Positionen der Variablen a[i][0] verweisen, i Ein weiterer Zeiger auf die erste Position dieses Hilfsfeldes kann syntaktisch wie ein zweidimensionales Feld behandelt werden. Dieser kann dann auch unproblematisch an Unterprogramme weitergereicht werden und erlaubt damit die Übergabe dynamisch angelegter Felder.

void f(int **a); // function expecting 2D array
// ...
int nx, ny;
std::cin >> nx >> ny; // read dimensions
int **array; // pointer to first element of
// the 'secondary' array
array = new int *[nx]; // create memory for nx pointers to int
array[0] = new int[nx*ny];
// nx*ny elements in the entire array,
// array[0] is a pointer to the first
// ``row'' of ny elements and equals
// the pointer to the beginning of the
// entire array
for(int i=1; i < ny; i++ )
array[i] = array[0] + i * ny;
// points to i'th segment of ny integers

if ( nx > 23 && ny > 10 )
array[23][10] = 17; // ok if 23 < nx and 10 < ny

f( array ); // OK, array is int **, but subscripting
// behaves as if it were a 2D field

Diese Technik läßt sich für Felder mit beliebig vielen Indizes anwenden und führt dann zu entsprechend hohem Grad der verwendeten Z
http://www.ica1.uni-stuttgart.de/~hilfer/de/lehre/100-online/skriptum/node54.html
Das klapt sehr gut...es ist zwar ein wenig kompliziert das feld zu setzten aber man kann es dafür super an fkt weitergebn...
Ach ja, ich liebe einfach c... *buck*
mfg