C Programm Fehler mit extraneous old-style parameter-list

H

hatmax1

Grünschnabel
Hallo leute. Habe an der FH Informatik als Pflichtfach und muss ein Programm schreiben dass einen springenden Ball simuliert. Ich habe es geschrieben aber bekomme es aufgrund dieses Fehlers im lcc compiler nicht zu laufen. Den compiler müssen wir übrigens benutzen.
Vielleicht kann ja mal jemand drüberschauen und mir auf anhieb sagen was an den fall(i), feder(i) und hoch(i) funktionen nicht passt.

gruß max
Code: 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "bmp.h"


#define name
#define PATH "e:\\uni\\ti2\\ball2\\name.bmp"


// Groesse des Bildes
#define XDIM 640
#define YDIM 960

// Farbe fuer Koordinatensystem
#define COLOR_C 0,0,0

// Farbe fuer Geschwindigkeit
#define COLOR_V 255,0,0

// Farbe fuer Hoehe
#define COLOR_H 0,255,0

// Erdanziehung
#define G (9.81f)

/* Prototypen */


double einlesend(char * ausgabe);
void plot(int c, double * y, int xn, int yn, int dimx, int dimy, int r, int g, int b);
void koordsys(int xn, int yn,int dimx,int dimy, int r, int g, int b);
double mind(double c, double * vec);
double maxd(double c, double * vec);
int fall(int);
int elast(int);
int	hoch(int);

int main(int argc, char * argv[]){
	/* Parameter fuer Simulation */
	double bmass = 1;			// Ballmasse in kg
	double brad  = 0.05;		// Ballradius in m
	double feder = 1000;		// Federkonstante in N/m
	float tstep = 0.001;		// Schrittweite der Simulation
	double tend = 50;			// Simulationszeit in s
	float  t	=0;
	float h = 5;				// Fallhoehe in m
	float v = 0;				// Anfangsgeschwindigkeit in m/s
	float tmom=0;
	float tges=0;

	int veclength = (int) tend / tstep;
	int vvec[3001];					// Dynamisches Array fuer Geschwindigkeit
	int hvec[3001];					// Dynamisches Array fuer Hoehe

	int i=0;
	int j;

	/*---- Eingabe ----*/

	puts("Simulation eines Balls");
	puts("Eingabe der Parameter fuer den Ball:");
	puts("name der datei eingeben:");
	puts("Parameter fuer Simulation");


	bmass = einlesend("Masse (kg): ");
	brad  = einlesend("Radius (m): ");
	feder = einlesend("Federkonstante in N/m: ");
	h     = einlesend("Fallhoehe (m): ");
	v     = 0;
	tend  = einlesend("Dauer der Simulation (s): ");


	/*---- Verarbeitung ----*/
	// Speicher fuer Ergebnisvectoren besorgen

	vvec[0] = v;
	hvec[0] = h;

	for(tmom=0;tend+tstep<=1;)
		{


		i=fall(i);
		i=elast(i);
		i=hoch(i);

		vvec[i] = v;
		hvec[i] = h;
	};


	//Freier Fall bis Hoehe gleich Radius
	int fall(i);
	{
		tmom=0;
		for(i=j+1;tges+tstep<=tend;i++)
			{ hvec[i]=hvec[0]+0.5*G*tmom*tmom;
			  vvec[i]=G*tmom;
			  tmom+=tstep;
			  if(hvec[i]<=brad)
				  {
					  j=i;
					  tges=tges+tmom;
					  hvec[i]=brad;
					  vvec[i]=G*tmom;
					  break;
					}
				}
				return i;
			}

	//Elastische Feder wenn Hoehe kleiner Radius

					  int elast(i);
					  {
						  tmom=0;
						  for(i=i+1;tges+tstep<=t;i++)
							  {
								  tmom+=tstep;
								  vvec[i]=vvec[i-1]+tstep*(G+(feder*(brad-hvec[i-1]))/bmass);
								  hvec[i]=hvec[i-1]+vvec[i]*tstep+0.5*(G+(feder*(brad-hvec[i]))/bmass)*tstep*tstep;
								  if(hvec[i]>=brad)
									  {
										  hvec[i]=brad;
										  vvec[i]=-vvec[j];
										  tges=tges+tmom;
										  break;
										}
									}
									return i;
								}

	//Ball bewegt sich wieder aufwärts

		int hoch(i);
		{
			tmom=0;
				for(i=i+1;tges+tstep<=t;i++)
			{
				tmom+=tstep;
				hvec[i]=hvec[i-1]+vvec[i-1]*tstep+0.5*G*tstep*tstep;

				vvec[i]=vvec[i-1]+G*tstep;
				if(vvec[i]<=0)
							{
							tges=tges+tmom;
						hvec[i]=hvec[0];
						vvec[i]=0;
					break;
			}
		}
		return i;
	}














	/*---- Ausgabe (Bild) ----*/

	/* Neue Grafikdatei erzeugen */
	bmpNew(XDIM,YDIM);

	//bmpLine(0,0,10,10, 0,0,0);

	/* Hoehe einzeichnen */
	plot(veclength, hvec, 20, 520, 600, 420, COLOR_H);
	koordsys(20, 520,600,420,COLOR_C);

	plot(veclength, vvec, 20, 20, 600, 420, COLOR_V);
	koordsys(20, 20,600,420,COLOR_V);


	printf("Bild nach %s gespeichert\n",PATH);
	puts("Info:");
	puts("Oben im Bild: Hoehe");
	bmpSave(PATH);

	free(vvec);
	free(hvec);

	return 0;
}


/*
 * Zeichnet die Punkte in y mit linien verbunden auf ein Bild
 * Parameter
 * 	c		: Anzahl der Werte im Array y
 * 	y		: Array mit den Zu plottenden Werten
 * 	xn		: Beginn des Plottens x-Wert
 *  yn		: Beginn des Plottens y-Wert
 *  dimx	: Breite des Plottfeldes
 *  dimy	: H?he des Plottfeldes
 *  r,g,b	: Farbwert mit denen der Graph geplottet wird
 */
void plot(int c, double * y, int xn, int yn, int dimx, int dimy, int r, int g, int b){
	int ynull, scalex;
	double ymin, ymax, scaley;
	double oldy,newy;
	int   oldx,newx, i;

	// Minimaler und Maximaler Wert die zu Plotten sind
	ymin = mind(c,y); ymax = maxd(c,y);

	// Skalierung in x und y Richtung (ceil aufrunden)
	scaley = (double) dimy / (ymax - ymin);
	scalex = ((double)c / (double)dimx);

	// Nullpunkt fuer Koordinatensystem
	ynull = yn;		// Unterster Punkt des Zeichenbereichs
	if(ymin < 0){
		ynull += (-ymin) * (dimy/(ymax-ymin));	// Nullpunkt fuer Koordinatensystem => (xn,ynull)
	}

	// Nulllinie Zeichnen
	bmpLine(xn,ynull,xn+dimx,ynull, r, g, b);

	oldx = xn;			// Beginn des Zeichnens
	oldy = (double)ynull + (y[0] * scaley);

	for(i = 1; i < c; i++ ){

		if((i%(scalex)) == 0){		// jeden scalex-ten wert zeichnen
			newx = oldx+1;
			newy = (double) ynull + (y[i] * scaley);

			// Linie Zeichnen
			bmpLine(oldx,oldy,newx,newy, r,g,b);

			oldx = newx;
			oldy = newy;
		}

	}
}



/*
 * Maximalwert im Array ermitteln
 * Parameter
 * c	: Anzal der Felder in vec
 * vec	: Array
 *
 * Rueckgabe
 * Groesster Wert im Array
 */
double maxd(double c, double * vec){
	int i;				// laufvariable
	int max=0xffffffff;	// kleine moegliche Zahl (32bit)
	for(i=0; i<c; ++i){
		if(vec[i] > max)
			max = vec[i];
	}
	return max;
}

/*
 * Minimalwert im Array ermitteln
 * Parameter
 * c	: Anzal der Felder in vec
 * vec	: Array
 *
 * R?ckgabe
 * Kleinster Wert im Array
 */
double mind(double c, double * vec) {
	int i;					// laufvariable
		int min=0x7fffffff;	// groesste moegliche Zahl
		for(i=0; i<c; ++i){
			if(vec[i] < min)
				min = vec[i];
		}
		return min;
}


/*
 * Zeichnet Abzisse und Ordinate mit Pfeilspitzen
 * Paramerter
 * 	xn	: x-Ursprung
 *  yn	: y-Ursprung
 * 	dimx: Breite
 *  dimy: Hoehe
 * 	r,g,b: Farbwerte
 */
void koordsys(int xn, int yn,int dimx,int dimy, int r, int g, int b) {
	// Abzisse
	bmpLine(xn,yn, xn+dimx,yn,r,g,b);
	// Ordinate
	bmpLine(xn,dimy+yn,xn,yn, r,g,b);

	// Pfeilspitzen
	// Abzisse
	bmpLine(xn+dimx, yn, xn+dimx-10, yn+5, r, g, b);
	bmpLine(xn+dimx, yn, xn+dimx-10, yn-5, r, g, b);

	// Ordinate
	bmpLine(xn,yn+dimy, xn-5, yn+dimy-10, r, g, b);
	bmpLine(xn,yn+dimy, xn+5, yn+dimy-10, r, g, b);
}

/*
 * Liest von der Tastatur einen Double wert ein
 * Gelingt die Eingabe nicht so wird zur erneuten Eingabe aufgefordert.
 * Parameter
 * 	ausgabe	: Info die dem Benutzer praesentiert wird
 * Rueckgabe
 * 	eingelesener Double-Wert
 */
double einlesend(char * ausgabe) {
	double d;

	// Benutzerinfo ausgeben
	printf("%s",ausgabe);

	// Wert von der Tastatur einlesen
	while(scanf("%lf",&d) != 1) {
		printf("Fehler beim Einlesen, bitte nocheinmal: ");
		while('\n' != getchar()){}
	}

	// Wert zurueckliefern
	return d;
}
 
Hi.

Du mußt den Typ der Parameter bei den Funktionsdefinitionen angeben. Und nach der schließenden Klammer der Paramterliste darf kein Semikolon stehen:
C++: 
int fall(int i) {
   ...
}
Gruß
 
Wenn ich keine Semikolons setze dann zeigt mit mein Compiler den Fehler missing semicolon an. Wenn ich sie setze kirge ich eine abnormal program termination. Er sagt mir dann etwas von segment violation.

Woran kann das liegen. Werte einlesen über die tastatur funktioniert, aber weiter gehts nichtmehr. Ebenso schafft er es nicht eine bmp zu erzeugen. Geschweige denn dort etwas reinzuzeichnen. Brauche ganz dringend Hilfe. Das Programm muss bis Montag funktionieren.

Gruß Max. Hier nochmal der aktuelle code:
Code: 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "bmp.h"



#define PATH "e:\\uni\\ti2\\programm2\\lcc1\\test.bmp"


// Groesse des Bildes
#define XDIM 2048
#define YDIM 2048

// Farbe fuer Koordinatensystem
#define COLOR_C 0,0,0

// Farbe fuer Geschwindigkeit
#define COLOR_V 255,0,0

// Farbe fuer Hoehe
#define COLOR_H 0,255,0

// Erdanziehung
#define G (9.81f)

// Prototypen

int i;
int fall(int i);			// Funktion berechnet Werte während dem freien Fall und speichert diese in h[]
int feder(int i);			// Funktion berechnet Werte während dem Bodenkontakt und speichert diese in h[]
int hoch(int i);				// Funktion berechnet Werte während dem Aufwaertsflug und speichert diese in h[]
//void pruefung(void);			// Funktion prueft die Eingabe auf zulaessige Werte
double einlesend(char * ausgabe);
void plot(int c, double * y, int xn, int yn, int dimx, int dimy, int r, int g, int b);
void koordsys(int xn, int yn,int dimx,int dimy, int r, int g, int b);
void zeichnen(void);

int j, klausel;				// i,j Zaehlvariablen, klausel fuer Sicherheitsabfrage in pruefung()

	double h=0;
	double m=0;
	double r=0;
	double k=0;
	double tges=0;
	double tmom=0;
	double t=0;




float g=-9.81;
double tstep=0.001;	// Erdbeschl. und Zeitschritt DeltaT
double veclength=0;


float vvec[3001],hvec[3001];			// Vektoren zum speichern von Hoehe und Geschw.
//char name[15],extension[]=".bmp",einlesen[20];		// name fuer Dateiname, extension zum Endung ankopieren,
													// einlesen fuer Variableneingabe







void main ()

{

	puts("Parameter fuer die Simulation");

	 m =einlesend("Bitte Masse des Balls eingeben");
	 r =einlesend("Bitte Radius des Balls eingeben");
	 h =einlesend("Bitte Fallhohe eingeben");
	 k =einlesend("bitte Federkonstante eingeben");
	 t =einlesend("bitte Betrachtungszeitraum festlegen");




			vvec[0]=0;

			for(tmom=0;tges+tstep<=t;)		// Schleife laeuft solange tges+DeltaT <= eingegebene Zeit
					{
						i=fall(i);			// i nimmt letzte Position im Array h[] und v[] ein
						i=feder(i);
						i=hoch(i);
						j=i;
								}
						zeichnen();


}


double einlesend(char * ausgabe)
			{ double d;
			printf("%s",ausgabe);
			scanf("%lf",&d);


			return d;
			}



void zeichnen()
	{
		int hmom,vmom;				// Ganzzahlvariablen zum Plotten der Werte
		tmom=0;
		bmpNew(XDIM,YDIM);			// definiere Bild mit 2048*2048 Pixel
			for(i=0;tmom/1000<=t;i++)	// durchlaeuft alle Zeitschritte bis Gesamtzeiterreicht wurde
			{
				hmom=hvec[i]*100;			// skaliert Hoehe, da Hoehe in m berechnet wird, d.h. 100 Pixel entsprechen 1m
				vmom=vvec[i]*100;			// skaliert Geschw, da Geschw in m/s berechnet wird, d.h. 100 Pixel entsprechen 1m/s
				tmom++;
			for(j=-2;j<=2;j++)
			{
				bmpSetPixel(tmom+j,hmom+1024+j, 255, 0, 0);			// plotte Hoehe und 4 darumliegende Pixel fuer dickere Linien
				bmpSetPixel(tmom+j,vmom+1024+j, 0, 255, 0);			// plotte Geschw und 4 darumliegende Pixel
			}
			}
			bmpBoldLine(0,1024,2048,1024,0,0,0);					// Nulllinie der Hoehe, bzw Zeitachse
			for(i=-1000;i<=1000;i+=100)
				{
				bmpLine(0,1024+i,2048,1024+i,0,0,0);				// Hoehenlinien, jede Linie entspr. 1m
				bmpLine(1000+i,1004,1000+i,1044,0,0,0);				// Zeitabschnitte, jeder Zeitstrich entspr. 0.1s
				}
					bmpBoldLine(0,0,0,2048,0,0,0);							// Hoehenachse
										//strcat(name,extension);									// fuegt Endung .bmp an Bildname
					bmpSave(PATH);											// speichert die Bitmap

}






int fall(int i)
{

	tmom=0;
	for(i=j+1;tges+0.0001<=t;i++)
		{
		hvec[i]=hvec[0]+0.5*G*tmom*tmom;			// berechnet von h[0] ausgehend einzelne Hoehen- und Geschwindigkeitswerte
		vvec[i]=g*tmom;
		tmom+=0.001;
		if(hvec[i]<=r)							// Ausstiegsklausel wenn die Resthoehe kleiner als der Radius ist
			{								// --> dann durch Programmablauf wechsel in nächste Funktion (bodenkontakt)
			j=i;
			tges=tges+tmom;					// Gesamtzeit wird auf momentanen Wert gesetzt
			hvec[i]=r;							// letzte Werte des Arrays mit exakt berechneten Werten beschreiben (sonst krumme Werte)
			//vvec[i]=g*tmom;
			break;
			}

		}
	return i;

}

int feder(int i)
{
	tmom=0;
	for(i=i+1;tges+0.0001<=t;i++)
		{
		tmom+=0.001;
		vvec[i]=vvec[i-1]+tstep * (g + (k*(r-hvec[i-1]))/m);				// berechnet immer ausgehend vom vorherigen Arraywert den nächsten
		hvec[i]=hvec[i-1]+vvec[i]*tstep+0.5*(g + (k*(r-hvec[i-1]))/m)*tstep*tstep;
		if(hvec[i]>=r)
			{
			hvec[i]=r;
			vvec[i]=-vvec[j];				// letzte Werte des Arrays mit exakt berechneten Werten beschreiben (sonst krumme Werte)
			tges=tges+tmom;

			break;
			}
		}
	return i;
}

int hoch(int i)
{
	tmom=0;
	for(i=i+1;tges+0.0001<=t;i++)
		{

		tmom+=0.001;
		hvec[i]=hvec[i-1]+vvec[i-1]*tstep+0.5*g*tstep*tstep;		// berechnung ausgehend vom letzten Arraywert
		vvec[i]=vvec[i-1]+g*tstep;

		if(vvec[i]<=0)
			{
			tges=tges+tmom;
			hvec[i]=hvec[0];			// letzte Arraywerte wieder auf Anfangswerte setzen
			vvec[i]=0;
			break;
			}
		}
	return i;

}
 
hatmax1 hat gesagt.:
Wenn ich keine Semikolons setze dann zeigt mit mein Compiler den Fehler missing semicolon an.
Zum Vergrößern anklicken....
Wo? (du kennst den Unterschied zwischen Deklaration und Definition?)
hatmax1 hat gesagt.:
Wenn ich sie setze kirge ich eine abnormal program termination. Er sagt mir dann etwas von segment violation.
Zum Vergrößern anklicken....
Wo? Hast du schon den Debugger verwendet?
hatmax1 hat gesagt.:
Woran kann das liegen. Werte einlesen über die tastatur funktioniert, aber weiter gehts nichtmehr. Ebenso schafft er es nicht eine bmp zu erzeugen. Geschweige denn dort etwas reinzuzeichnen. Brauche ganz dringend Hilfe. Das Programm muss bis Montag funktionieren.

Gruß Max. Hier nochmal der aktuelle code:
Zum Vergrößern anklicken....
Schließ den Code bitte mal in [c]...[/c] ein, so ist es einfach nur unleserlich. Wer soll sich das denn ankucken?

Gruß
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück