3dimensionales array

coon

Hallo Leute,
Ich habe mal wieder eine Frage
und zwar:
Ein Programm soll 3 Punkte einlesen (x|y)
aus diesen 3 Koordinaten ein Dreieck 'konstruieren' und den
-Umfang
-Schwerpunkt
berechnen.
Ich habe dieses bereits mit simplen arrays gelöst und habe jetzt vor das ganze mit einem 3d array zu lösen. Ich habe früher mit php programmiert und versucht das ganze in c umzusetzen. Leider funktioniert diese Syntax nicht so ganz in c...
Vielleicht könnt ihr mir helfen.
Mein Quelltext:

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
float rechnung_umfang(int*,int);

float rechnung_schwerpunkt(int*,float*,int);

int main(){
	int i=3,koord[i],x,y,zaehler;
	float schwerpunkt[2],umfang;
	for(zaehler=0;(zaehler+1)<=i;zaehler++){
		printf("\nBitte Geben Sie den X- und Y-Wert fuer Zahl %i ein: ",(zaehler+1));
		scanf("%i,%i",&x,&y);
		koord[zaehler]={x,y};
	}
	umfang=rechnung_umfang(koord,i);
	rechnung_schwerpunkt(koord,schwerpunkt,i);
	printf("\nUmfang: %.2f \nSchwerpunkt: ( %.2f | %.2f )",umfang,schwerpunkt[0],schwerpunkt[1]);
	return 0;
}
float rechnung_umfang(int* koord,int i){
	int zaehler,xdif,ydif;
	//printf("\ni=%i",i);
	float umfang=0;
	for(zaehler=0;(zaehler+1)<=i;zaehler++){
		if((zaehler+1)==i){
			xdif=abs(koord[zaehler][0]-koord[0][0]);
			ydif=abs(koord[zaehler][1]-koord[0][1]);
		}
		else{
			xdif=abs(koord[zaehler][0]-koord[zaehler+1][0]);
			ydif=abs(koord[zaehler][1]-koord[zaehler+1][1]);
		}
		//printf("\nxdif: %i,ydif: %i",xdif,ydif);
		umfang+=sqrt(float(xdif*xdif+ydif*ydif));
	}
	return umfang;
}

float rechnung_schwerpunkt(int* x,int* y,float* schwerpunkt,int i){
	int zaehler,summex=0,summey=0;
	for(zaehler=0;(zaehler+1)<=i;zaehler++){
		summex+=x[zaehler];
		summey+=y[zaehler];
	}
	//printf("\nsummex=%i, summey=%i",summex,summey);
	schwerpunkt[0]=float(summex)/i;
	schwerpunkt[1]=float(summey)/i;
	return 1;
}

Schau dir mal die struct an.
Du brauchst für die Rechnung im 3D-Koordinatensystem kein 3D-Array.

coon

ich weiß nicht ganz was du meinst...
wie ich bereits erwähnte, ich habe es schon mit zwei arrays x und y gemacht, wollte es jetzt aber mit einem 3d array machen sodass ich:
(1.pos.|x1|y1)
(2.pos.|x2|y2)
... usw habe

also so war mein bisherige code mit 2 arrays:

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
float rechnung_umfang(int*,int*,int);

float rechnung_schwerpunkt(int*,int*,float*,int);

int main(){
	int i=3,x[i],y[i],zaehler;
	float schwerpunkt[2],umfang;
	for(zaehler=0;(zaehler+1)<=i;zaehler++){
		printf("\nBitte Geben Sie den X- und Y-Wert fuer Zahl %i ein: ",(zaehler+1));
		scanf("%i,%i",&x[zaehler],&y[zaehler]);		
	}
	umfang=rechnung_umfang(x,y,i);
	rechnung_schwerpunkt(x,y,schwerpunkt,i);
	printf("\nUmfang: %.2f \nSchwerpunkt: ( %.2f | %.2f )",umfang,schwerpunkt[0],schwerpunkt[1]);
	return 0;
}
float rechnung_umfang(int* x,int* y,int i){
	int zaehler,xdif,ydif;
	//printf("\ni=%i",i);
	float umfang=0;
	for(zaehler=0;(zaehler+1)<=i;zaehler++){
		if((zaehler+1)==i){
			xdif=abs(x[zaehler]-x[0]);
			ydif=abs(y[zaehler]-y[0]);
		}
		else{
			xdif=abs(x[zaehler]-x[zaehler+1]);
			ydif=abs(y[zaehler]-y[zaehler+1]);
		}
		//printf("\nxdif: %i,ydif: %i",xdif,ydif);
		umfang+=sqrt(float(xdif*xdif+ydif*ydif));
	}
	return umfang;
}

float rechnung_schwerpunkt(int* x,int* y,float* schwerpunkt,int i){
	int zaehler,summex=0,summey=0;
	for(zaehler=0;(zaehler+1)<=i;zaehler++){
		summex+=x[zaehler];
		summey+=y[zaehler];
	}
	//printf("\nsummex=%i, summey=%i",summex,summey);
	schwerpunkt[0]=float(summex)/i;
	schwerpunkt[1]=float(summey)/i;
	return 1;
}

Du hast ein 2D-Array bei dem der eine Index die Koordinate (0=x,1=y) angibt und der ander Index ein Punktezähler ist.

Du kannst das erweitern indem du für z die 2 nimmst.

int i=3,koord[i][3], .. // i = 3 für 3 Punkte (Dreiecke) die 3 bei koord steht für 3 Koordinaten
    float schwerpunkt[3], ...  //  auch 3 für 3D
...
        scanf("%i%i%i",&x,&y, &z);
        koord[zaehler][0]= x;
        koord[zaehler][1]= y;
        koord[zaehler][2]= z;
...
        zdif=abs(koord[zaehler][2]-koord[0][2]);

Wenn du nicht weißt was eine struct ist, mach dich schlau in deinem Buch/Tutorial
Damit wird die Sache viel übersichtlicher.

coon

ok klar soweit.
nur weiß ich dann nicht ganz wie ich das 3d array übertrage an die Funktionen.
habe schon ein paar ansätze von anderen mit ** gesehen nur weiß ich nichts genaueres.

Auf die Schnelle noch mit structs

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef struct { float x,y,z; } koord;

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
float rechnung_umfang(koord*,int);

koord rechnung_schwerpunkt(koord*,int);

int main(){
    int i=3, zaehler;
    koord punkte[i];
    float umfang;
    koord schwerpunkt;

    for(zaehler=0;(zaehler+1)<=i;zaehler++){
        printf("\nBitte Geben Sie den X- und Y-Wert fuer Zahl %i ein: ",(zaehler+1));
        scanf("%f,%f",&punkte[zaehler].x,&punkte[zaehler].y);
    }
    umfang=rechnung_umfang(punkte,i);

    schwerpunkt = rechnung_schwerpunkt(punkte,i);
    printf("\nUmfang: %.2f \nSchwerpunkt: ( %.2f | %.2f )",umfang,schwerpunkt.x,schwerpunkt.y);
    return 0;
}
float rechnung_umfang(koord *punkte, int i){
    int zaehler,xdif,ydif;
    //printf("\ni=%i",i);
    float umfang=0;
    for(zaehler=0;(zaehler+1)<=i;zaehler++){
        if((zaehler+1)==i){
            xdif=abs(punkte[zaehler].x-punkte[0].x);
            ydif=abs(punkte[zaehler].y-punkte[0].y);
        }
        else{
            xdif=abs(punkte[zaehler].x-punkte[zaehler+1].x);
            ydif=abs(punkte[zaehler].y-punkte[zaehler+1].y);
        }
        //printf("\nxdif: %i,ydif: %i",xdif,ydif);
        umfang+=sqrt((xdif*xdif+ydif*ydif));
    }
    return umfang;
}

koord rechnung_schwerpunkt(koord *punkte,int i){
    int zaehler;
    float summex=0,summey=0;
    koord schwerpunkt;
    for(zaehler=0;(zaehler+1)<=i;zaehler++){
        summex+=punkte[zaehler].x;
        summey+=punkte[zaehler].y;
    }
    //printf("\nsummex=%i, summey=%i",summex,summey);
    schwerpunkt.x=summex/i;
    schwerpunkt.y=summey/i;
    return schwerpunkt;
}

Habe vorhin die Sicherheitsabfrage verpennt