Hi,

ich habe gerade eben erfahren müssen, dass es in C leider keine Referenzparameter gibt, sondern dass statt dessen Zeiger verwendet werden müssen.

Nun habe ich das als C Anfänger auch umgesetzt, allerdings schimpft mein Compiler (gcc) dass ich eine "Übergabe von inkomptiblen Zeigertyp" habe, was meiner einer nun gar nicht einesehen kann.

Wäre schön, wenn jemand mir da weiter helfen könnte

void load([B]int* grauwert[])[/B] {

	int count,tmp_int,zahler;

	char c,tmp[3];

	FILE *f1;

	f1=fopen("256*256.txt","r");


	count=0;

	zahler=0;

	while (zahler<65536){

		c=getc(f1);

		if ((c!='\t')&&(c!= '\n')) {

			count++;

			tmp[count-1]=c;

		}

		else {

			switch (count) {

				case 3:tmp_int=(tmp[0]-'0')*100+(tmp[1]-'0')*10+(tmp[2]-'0');break;

				case 2:tmp_int=(tmp[0]-'0')*10+(tmp[1]-'0');break;

				case 1:tmp_int=(tmp[0]-'0');break;

			}

			tmp[0]=0; tmp[1]=0; tmp[2]=0;

			[B](*grauwert[zahler])=tmp_int;[/B]

			count=0;

			++zahler;

		}

	}

	fclose(f1);

}	


int main() {


 int Nx, Ny;

 int graustufe[/*Nx*Ny*/256*256];										

 fftw_complex *fftArray;

 fftw_plan forw, backw;

 fftArray = (fftw_complex*) fftw_malloc(Ny*Nx*sizeof(fftw_complex));	



[B]

 load(&graustufe);	[/B]	// Übergabe des Argumentes 1 von load von inkompatiblem zeigertyp

...											

Mhhh, Ok, nach diversen ausschreitungen meinerseits habe ich bemerkt, dass

graustufe auch ein Zeiger sein sollte, wenn ich die Adresse übergeben will.

 int * graustufe;

(Warum eigentlich, kann ich etwa nicht die Adresse einer einfachen Variable übergeben? *verwirrt bin*) Allerdings bekomme ich statt dessen einen anderen schönen Fehler: unverträgliche implizite Deklaration der eingebauten Funtion >>malloc<< wenn ich den Zeiger initialisieren will.

int main() {

...	

 int * graustufe;

 graustufe = (int*) malloc(65536*sizeof(int));

Schlagt mich, aber knapp 5 Zeilen drunter steht EXAKT das gleiche für einen anderen Zeiger, und der Compiler schluckt es:

fftw_complex *fftArray;

...

 fftArray = (fftw_complex*) malloc(/*Ny*Nx*/256*256*sizeof(fftw_complex));

	

:eek

So, wie du sie deklariert hast, erwartet deine load-Funktion keinen Zeiger auf ein Array, sondern ein Array von Zeigern.

Eine Funktion, die einen Zeiger auf ein Array als Parameter hat, sieht so aus:

void foo( int(* bar)[2] );

Du musst die Größe des Arrays in diesem Fall angeben. Das Ganze ist aber für dein Problem sowieso egal, weil Arrays ohnehin nicht "by value" übergeben werden. Array-Parameter werden nicht kopiert, sondern sind (auch in C) immer "by reference". Genauer gesagt zerfallen Array-Parameter immer zu Zeigern. Das bedeutet unter anderem auch, dass die Größeninformation beim Aufruf verloren geht.

int main() {

...	

 int * graustufe;

 graustufe = (int*) malloc(65536*sizeof(int));[/CODE]


Schlagt mich, aber knapp 5 Zeilen drunter steht EXAKT das gleiche für einen anderen Zeiger, und der Compiler schluckt es:
Kann ich nicht reproduzieren. Hast du <stdlib.h> eingebunden? Zeig doch bitte mal ein vollständiges Minimalbeispiel, das den Fehler reproduziert.


Du solltest dir übrigens abgewöhnen, den Rückgabewert von malloc zu casten. In C ist das nicht notwendig, und kann Fehler verdecken.

Oh, vielen Dank für die Antwort, ich hab unter der Woche wohl keine Zeit, aber am WE werd' ich mich mal an diese malloc Sache ransetzen, sehr mysteriös.

Das das Array gleich als Referenz übergeben wird, ist natürlich sehr angenehm, hätte ich gar nicht gedacht, wird am WE auch umgesetzt.

Und mal eine kleine Frage hinterher: Was genau heißt "malloc casten"?

Ich muss gestehen, Zeiger an und für sich sind für mich programmistisches Neuland, noch mehr als C, insofern hatte ich mich bisher strickt an diverse Beispiele im Netz gehalten. :eek

Und mal eine kleine Frage hinterher: Was genau heißt "malloc casten"?

Ein Cast ist eine explizite Typumwandlung. Dabei schreibt man den Typ, in den umgewandelt werden soll, in Klammern vor den umzuwandelnden Ausdruck.

In deinem Fall wandelst du den Ausdruck malloc(65536*sizeof(int)) explizit in int* um. Das ist hier aber gar nicht notwendig. malloc liefert einen void* zurück, der in C implizit in jeden anderen Zeigertyp konvertierbar ist, also auch in int*. Das (int*) ist also überflüssig.

malloc ist erstmal eine "dumme" Funktion. Dü teilst mit, wieviel byte er allokieren soll und malloc gibt dir die Anfangsadresse dieses Speicherblocks zurück. Da malloc keine Ahnung, was du speichern willst, ist der Datentyp void*. Bei manchen compilern musst du zwingend sagen, was gespeichert wird, wenn du den Speicherbereich zuweisen musst.

angenommen du willst ein dynamisches int array mit 10 elementen:

int *pstart = (int*) malloc(10 * sizeof(int));

malloc ist erstmal eine "dumme" Funktion. Dü teilst mit, wieviel byte er allokieren soll und malloc gibt dir die Anfangsadresse dieses Speicherblocks zurück. Da malloc keine Ahnung, was du speichern willst, ist der Datentyp void*. Bei manchen compilern musst du zwingend sagen, was gespeichert wird, wenn du den Speicherbereich zuweisen musst.

Echt?

Bei welchen C(!)-Compilern muss man malloc casten ?

Nach meinem Wissensstand castet man malloc nicht.

Sie auch: Question 7.7b

Das ´Malloccasten ist ANSI-C++.

Interesannt ist nebenbei, dass alle Beispiele, die ich im Netz gefunden habe, die malloc erläutern, auch das gecaste enthalten.

Nun gut, wieder etwas schlauer!

Habe jetzt übeigens den Code mal fremdcompiliert, hat wunderbar geklappt...

Nach neuaufsetzen des eigenen Compilers gings dann auch bei mir...

Am WE test ich dann, ob die Array-Referenzen auch funktionieren. *hoff*