Unerklärlicher Fehler beim kompilieren

Hi,

zumindest für uns ist die Fehlermeldung, die wir vom Compiler bekommen auch nach mehreren Stunden des Rumprobierens ein Rätsel.
Wir führen in einer Funktion zwei Arrays mit bestimmter Größe ein und übergeben diese z.B. an Funktionen, die einen int * erwarten. Das klappt auch alles, aber wenn wir diese Arrays gleichsetzen wollen, sagt gcc auf einmal, es wäre der falsche Datentyp...

/
*
*
*
*
*
\

#include "sortieren.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void ausgabe(int sortieren[],int groesse){
	int i=0;
	while(i<groesse){
		printf("%i\t",sortieren[i]);
		++i;
	}
	printf("\n\n");
	system("pause");

}
int * mergesort(int sortieren[],int groesse){
		int new[groesse];
		int left[groesse/2];
		int right[(groesse/2)+(groesse%2)];
		int i,j=-1;

	if(groesse>1){

		for(i=0;i<(groesse/2);++i){
			left[i]=sortieren[i];
		}
		left[i]='\0';
		for(i;i<groesse;++i){
			right[i-(groesse/2)]=sortieren[i];
		}
		right[i]='\0';
		left = mergesort(left,(groesse/2));
		right = mergesort(right,(groesse/2)+(groesse%2));
	}

	for(i=0;left[i]!='\0' && right[i]!='\0';++i){

		if(left[i]<=right[i]){
			new[++j] = left[i];
			new[++j] = right[i];
		}
		else{
			new[++j] = right[i];
			new[++j] = left[i];
		}
	}	
	if(left[i]!='\0')
		new[++j] = left[i];

	if(right[i]!='\0')
		new[++j] = right[i];

	new[++j]='\0';

	sortieren=new;

	return sortieren;
}

Der Compiler liefert dann folgendes:

sortieren.c: In function 'mergesort':
sortieren.c:44:8: error: incompatible types when assigning to type 'int[(unsigned int)(groesse / 2)]' from type 'int *'
sortieren.c:45:9: error: incompatible types when assigning to type 'int[(unsigned int)(groesse / 2 + groesse % 2)]' from type 'int *'

Das gleiche passiert übrigens, wenn wir schreiben

links=rechts

Dabei entspricht das doch genau der Schreibweise

&links[0]=&rechts[0]

Also weise ich einem int Pointer einen anderen int Pointer zu, wo ist bitte das Problem?!

Wir sind für jede Hilfe dankbar
Gruß,
Mark

Die Größe der Arrays ist unterschiedlich, eine Zuweisung ist somit nicht möglich, da z.B. ein int[5] nicht einem int[8] entspricht (unterschiedlicher Datentyp).

cooky451

left und right bezeichnen hier Arrays und keine Pointer. left zB. muss immer auf &left[0] zeigen und das darf sich auch nicht ändern.

Edit: Man sollte sich vielleicht mal auf EINE Sprache einigen. (Am besten Englisch)
Edit2: Die unten gezeigten Beispiele sind eine ganz schlechte Idee. Was soll

&left[0] = &right[0];

denn bewirken? Korrekt wäre:

int array[100];
int *pointer = array; // &array[0]

Einen so erstellen Pointer kann man jetzt auch auf etwas anderes zeigen lassen.

Aber das sollte doch egal sein, da ich mit dem Audruck links doch einfach den Pointer auf das erste Element des Arrays anspreche, also nur einem Pointer einen Pointer zuweise.

Außerdem liefert das hier den selben Fehler

int * mergesort(int sortieren[],int groesse){
		int new[groesse];
		int left[5];
		int right[5];
		int i,j=-1;

		left=right;
}

cooky451

hoshymann schrieb:

Aber das sollte doch egal sein, da ich mit dem Audruck links doch einfach den Pointer auf das erste Element des Arrays anspreche, also nur einem Pointer einen Pointer zuweise.

Außerdem liefert das hier den selben Fehler
int * mergesort(int sortieren[],int groesse){
		int new[groesse];
		int left[5];
		int right[5];
		int i,j=-1;
		
		left=right;
}

left und right müssen hier konstant sein. Jeder Ausdruck wie left = xxx ist ein Fehler.

Hm... ok, ist mir jetzt nicht ganz klar wieso, aber man kann offenbar keine Arrays einander zuweisen.
Habt ihr dann irgend ne andere Idee, wie man das erreichen kann, was wir möchten?

Ja, tut mir leid, aber wie ich die Dinger nenne, macht doch keinen Unterschied, solange ich mich an alles erinnere, oder?

Ach, da oben im Edit 2 steht ja was.
Ok, das probiere ich mal aus, danke!

cooky451

array1 = array2 im Sinne dass array1 alle Werte von Array2 haben soll:

#include <string.h>
int array1[10];
int array2[10};
memcpy(array1, array2, sizeof(array2));

Falls es um Pointer geht:

int array1[10];
int array2[10];
int *p1 = array1;
p1 = array2;

Wobei der ganze Code oben sehr nach "mergesort von irgendeiner Seite mit Pseudo-Code abgeschrieben" aussieht.. (sorry wenn ich euch da jetzt unrecht tuh)

^^ Ne, alter, damit hast du unser Vorgehen ziemlich genau beschrieben
Wobei Abgeschrieben übertrieben ist, wir haben und eben am Pseudocode orientiert, weil wir nicht wussten, wie wir die Arrays aufteilen sollen.
Und eigentlich ist es mit dieser rekursiven Methode ziemlich geschickt, finde ich. Nur dass es nicht funktioniert... ;P
Er scheint nicht oft genug aufzuteilen. Und bei zusammenführen stürzt er dann ab.

Aber zumindest haben wir jetzt kein Problem mehr beim kompilieren...