array übergeben

blurry333

Hallo ,

wie gehts richtig ?

#include <iostream>

using namespace std;

void funk(int* p){cout<<"Funktioniert"; }

int main()
{

	int arr[3][4]={4,2,1};

	funk(arr);  // geht nicht :(

}

"Geht nicht" ist keine Fehlerbeschreibung.

yahendrik

funk(&arr[0][0]);
// oder
funk(arr[0]);

Besser: Die Dimensionen ebenfalls übergeben:

void funk(int* p, size_t dim1, size_t dim2)

Und dann int einer verschachtelten Schleife (mit x und y) per p[y*dim2+x] zugreifen.

Argh: Variablenname korrigiert.

Kóyaánasqatsi

Das Problem ist, dass die Funktion immer wissen muss wie viele Dimensionen das Array hat. Für dein 2D-Array würde ich einfach einen doppelten Zeiger nehmen...

blurry333

funk(int** p)

geht auch nicht !!

Gibt es irgendeine Möglichkeit !!

Ich dachte eigentlich immer der Arrayname ist vom Typ int*
Aber scheinbar doch nicht .

CStoll

Kóyaánasqatsi schrieb:

Für dein 2D-Array würde ich einfach einen doppelten Zeiger nehmen...

Dir ist schon klar, daß die automatische Array-zu-Zeiger Umwandlung nur in einer Dimension funktioniert?

@blurry: Damit die Funktion korrekt arbeiten kann, muß sie einen Zeiger auf int-Arrays bekommen: void func(int* arr[3]); (hoffe ich, könnte auch eine 4 sein). Aber in C++ sollte man eher weniger mit blanken Arrays und Zeigern hantieren - stattdessen sind STL-Container (std::vector<>, std(::tr1)::array<> etc) praktischer.

blurry333

void func(int* arr[3])

geht auch net.

Kóyaánasqatsi

CStoll schrieb:

Kóyaánasqatsi schrieb:

Für dein 2D-Array würde ich einfach einen doppelten Zeiger nehmen...

Dir ist schon klar, daß die automatische Array-zu-Zeiger Umwandlung nur in einer Dimension funktioniert?

Funktioniert doch:

void test(int sizeA, int sizeB, int **b)
{ }

int main(int argc, char* argv[])
{
int a[5][7];
test(5, 7, (int**)a);
return 0;
}

Ich weiß nicht genau was du meinst.

314159265358979

Wenn ich weiß, dass der c-string "\xB8\x00\x00\x00\x00\xC3" einer asm-Funktion entspricht, die 0 zurückgibt, kann ich auch das machen mit einem Cast. Es geht um implizierte Konvertierungen.

CStoll

Kóyaánasqatsi schrieb:

Ich weiß nicht genau was du meinst.

Und hast du mal versucht, in der Funktion etwas mit dem übergebenen Array zu machen.

@blurry: Riskiere es blos nicht, die Fehler genauer in Worte zu fassen. Es könnte ja sein, daß dir dann jemand helfen kann

Kóyaánasqatsi

CStoll schrieb:

Kóyaánasqatsi schrieb:

Ich weiß nicht genau was du meinst.

Und hast du mal versucht, in der Funktion etwas mit dem übergebenen Array zu machen.

Auf die schnelle:

#include <iostream>

void test(int sizeA, int sizeB, int **b)
{
	for(int n = 0; n < sizeB; ++n)
	{
		for(int i = 0; i < sizeA; ++i)
		{
			b[i][n];
		}
	}
}

int main()
{
	int a[5][7];
	test(5, 7, (int**)a);

	test;

	return 0;
}

CStoll

Ich rede nicht von irgendwelchen noop-Spielereien, die jeder Amateur-Compiler wegoptimieren kann, sondern von echten Zugriffen - und da macht sich der Cast nicht besonders gut.

PS: Mit den richtigen Parametern sieht es schon wesentlich besser aus.

Ethon

#include <iostream>
#include <array>

template<std::size_t Size1, std::size_t Size2>
void funk(std::array<std::array<int, Size1>, Size2>& p)
{
  cout<<"Funktioniert";
}

int main()
{
  std::array<std::array<int, 4>, 3> arr;
  funk(arr);                                       
}

Fixed

krümelkacker

Kóyaánasqatsi schrieb:

void test(int sizeA, int sizeB, int **b);

int main()
{
	int a[5][7];
	test(5, 7, (int**)a);
	return 0;
}

Lieber Kóyaánasqatsi, das, was Du da von Dir gegeben hast, lässt sich zwar wegen des Casts kompilieren, ist aber völlig unbrauchbar. Der Cast ist äquivalent zu einem reinterpret_cast von int(*)[7] zu int**. Es hat einen Grund, warum Dich der Compiler diese Konvertierung nicht ohne einen reinterpret_cast durchführen lässt. Ein Zeiger auf ein 7-elementiges int-Array ist eben kein Zeiger auf einen int-Zeiger.

blurry333

ein mehrdimensionales array von char wird aber doch auch mit einem char** übergeben. Siehe nur argv .

blurry333 schrieb:

ein mehrdimensionales array von char wird aber doch auch mit einem char** übergeben. Siehe nur argv .

Nein.

argv ist ein Array von char*

Bei einem mehrdimensionales Array liegen alle Elemente hintereinander im Speicher, wobei der ganze rechte Index am schnellsten wechselt.

char a[3][4] liegt im Speicher als a00, a01, a02 a03, a10, a11, a12, a13, a20, a21, a22 ,a23.

Damit entspricht a einem char*

Wenn du ein char a[z][s] hast, kannst du auf das Element a[i][j] auch mit *(a+i*s+j) zugreifen

blurry333

argv[0]
argv[1]
argv[2]
  .
  .
 usw

werden mit char** argv übergeben

krümelkacker

blurry333 schrieb:

ein mehrdimensionales array von char wird aber doch auch mit einem char** übergeben. Siehe nur argv.

Das kommt auf Deine Definition von "mehrdimensionales Array" an. Ich verwende diesen Begriff erst gar nicht. Eindeutiger ist da schon "Array von Arrays" versus "Array von Zeigern".

int   w[5][7];   // 5-elementiges Array von 7-elementigen Arrays
int (*x)[7] = w; // Zeiger auf 7-elementiges Array (zeigt auf das erste Element von w)

int  *y[5];      // 5-elementiges Array von Zeigern
int **z = y;     // Zeiger auf Zeiger (zeigt auf das erste Element von y)

Per array-to-pointer decay kommt man von w nach x und von y nach z. Und da Zeiger keine Arrays sind, macht

int **silly = (int**)w;

absolut keinen Sinn.

Das einzige, was w,x,y,z, gemeinsam haben ist, dass man zweimal den []-Operator drauf anwenden kann. Wenn das schon ausreicht, um von "zweidimensionalen Arrays" zu sprechen, dann bist Du leider unpräzise, blurry333; denn man weiß dann nicht wirklich, was für ein Speicherlayout Du Dir vorstellst.

Irgendwas noch unklar? Dann guckt doch am besten mal in einem schlauen Buch nach, statt Fehlinformationen aus bescheidenen Tutorials zu extrahieren oder sie selbst zu produzieren.

Wutz

CStoll schrieb:

@blurry: Damit die Funktion korrekt arbeiten kann, muß sie einen Zeiger auf int-Arrays bekommen:
void func(int* arr[3]);

Das ist kein Zeiger auf int-Arrays sondern ein Array von Zeigern auf int.
Ein Zeiger auf ein int-Array sieht so aus:

void func(int (*arr)[3]);

krümelkacker

blurry333 schrieb:

argv[0]
argv[1]
argv[2]
  .
  .
 usw
werden mit char** argv übergeben

Ja und? argv verweist auf (das erste Element) ein(es) Zeiger-Array(s). Bei

int foo[5][7];

gibt es kein Zeiger-Array. foo ist ein Array von Arrays. Du kannst jetzt noch ein Zeiger-Array einführen:

int* za[] = { foo[0], foo[1], foo[2], foo[3], foo[4] };
int** p = za;

dann zeigt p aber nicht auf irgendwas in foo sondern auf das erste Element des Zeiger-Arrays za.

Haben wir's jetzt?