Probleme mit Stack

[Stephan3]

wie müsste ich das denn dann deklarieren bzw. initialisieren? ich mach es bisher so:

float x1[200];
float x2[200];
float t[1500];

for(int i=1,j=1,k=1;i<200,j<200,k<1500;i++,j++,k++)
{
    x1[i] = i;
	x2[j] = j;
	t[k] = k;
}

kenn mich leider noch nicht sooo gut mit c++ aus...

vielen dank für hilfe Stephan

[interpreter]

float *x1 = new float[200];
float *x2 = new float[200];
float *t  = new float[1500];

Der Rest bleibt gleich, nur das du am Ende den Speicher wieder freigeben solltest:
delete[] x1;
delete[] x2;
delete[] t;

[HumeSikkins]

otze schrieb:

leg die arrays mal auf dem heap über new an

Wenn man schon auf den einzigen Vorteil von Arrays verzichten muss, dann sollte man wirklich wirklich std::vector benutzen.

[Stephan3]

es geht leider immer noch nicht... beim kompilieren und linken gibts keine probleme, beim starten der exe aber leider schon. sind immer andere fehlermeldungen: grad kam diese: "Unbehandelte Ausnahmen in testkonstanten.exe: 0xC0000005: Access Violation"

Ich kopier hier mal den Quellcode rein... vielleicht seht ihr ja irgendwelche fehler oder habt verbesserungsvoschläge wie ich das problem lösen kann... hab die berechnungen jetzt schon heruntergefahren auf weniger als 100.000 ...
Vielleicht liegts ja auch an dos dass das ganze net geht...

hier der quellcode:

#include <iostream.h>
#include <math.h>

int main() 
{
	const double C = 3e+8;
	const double PI = 3.141592654;
	// wichtig

	double lamda1 = 100e-9, lamda2 = 200e-9, lamda3 = 300e-9, lamda4 = 400e-9, lamda5 = 500e-9, lamda6 = 600e-9;
	double t1 = 5e-14;
	double a1 = 1 * lamda1, b1 = 2 * lamda1, c1 = 3 * lamda1, d1 = 4 * lamda1, e1 = 5 * lamda1, f1 = 6 * lamda1;
	double a2 = 1 * lamda1, b2 = 2 * lamda1, c2 = 3 * lamda1, d2 = 4 * lamda1, e2 = 5 * lamda1, f2 = 6 * lamda1;
	// Werte die sich ändern bzw. die der Nutzer eingibt

  	double *x1 = new double[100]; 
	double *x2 = new double[100]; 
	double *t  = new double[1500]; 

	for(int i=1,j=1,k=1;i<100,j<100,k<1500;i++,j++,k++)
	{ 
		x1[i] = i * lamda1;
		x2[j] = j * lamda1;
		t[k] = k * ( sqrt ( ( x1[1] - a1 ) * ( x1[1] - a1 ) + ( x2[1] - a2 ) * ( x2[1] - a2 ) ) ) / C;
	}

	// alle x1 und x2 werte initialisieren

	double *z0 = new double[10000];
	double *z1 = new double[10000];
	double *z2 = new double[10000];
	double *z3 = new double[10000];
	double *z4 = new double[10000];
	double *z5 = new double[10000];
	double *z6 = new double[10000];

	int s=0,m=0,n=0,o=0,p=0,q=0,r=0;

			for(j=1;j<100;j++)
			{

				for(i=1;i<100;i++)
				{
					s++,m++,n++,o++,p++,q++,r++;	

					z1[m] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda1 ) - ( sqrt ( ( x1[i] - a1 ) * ( x1[i] - a1 ) + ( x2[j] - a2 ) * ( x2[j] - a2 ) ) ) / lamda1 ) );
					z2[n] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda2 ) - ( sqrt ( ( x1[i] - b1 ) * ( x1[i] - b1 ) + ( x2[j] - b2 ) * ( x2[j] - b2 ) ) ) / lamda2 ) );
					z3[o] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda3 ) - ( sqrt ( ( x1[i] - c1 ) * ( x1[i] - c1 ) + ( x2[j] - c2 ) * ( x2[j] - c2 ) ) ) / lamda3 ) );
					z4[p] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda4 ) - ( sqrt ( ( x1[i] - d1 ) * ( x1[i] - d1 ) + ( x2[j] - d2 ) * ( x2[j] - d2 ) ) ) / lamda4 ) );
					z5[q] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda5 ) - ( sqrt ( ( x1[i] - e1 ) * ( x1[i] - e1 ) + ( x2[j] - e2 ) * ( x2[j] - e2 ) ) ) / lamda5 ) );
					z6[r] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda6 ) - ( sqrt ( ( x1[i] - f1 ) * ( x1[i] - f1 ) + ( x2[j] - f2 ) * ( x2[j] - f2 ) ) ) / lamda6 ) );

					z0[s] = z1[m] + z2[n] + z3[o] + z4[p] + z5[q] + z6[r];
				}

			}

	// Berechnung der Intensität

	for(s=0;s<100;s++)
	{
		cout << z0[s] << "\n";
	}

	// Werte aus dem Heap löschen

	delete[] x1; 
	delete[] x2; 
	delete[] t; 

	// Werte aus dem Heap löschen

	return 0;
}

vielleicht hab ich auch irgendwas beim compiler falsch eingestellt oder es wurde irgendwas nicht richtig installiert... bin wie gesagt noch ziemlich neu beim programmieren und deswegen weiß ich noch net so bescheid...

wär echt froh wenn mir jemand helfen kann...
Vielen Dank schon mal im vorraus Stephan

[groovemaster]

Stephan3 schrieb:

for(int i=1,j=1,k=1;i<100,j<100,k<1500;i++,j++,k++)

Das funktioniert so nicht. Schau dir mal an wie der for-Schleifenkopf und der Komma Operator arbeiten.

[Stephan3]

vielen dank...
hab des eigentlich mal in nem buch gelesen dass des geht... aber anscheinend gehts doch net, weil etz funzt das programm so wie ich es mir vorstell... viel dank!!!
Stephan3

[groovemaster]

Es ist ja nicht so, dass alles nicht funktioniert. Aber die Bedingungen musst du mit logischen Operatoren verknüpfen, zB

i<100 && j<100 && k<1500

[newkid]

was mir auf anhieb auffällt, ist warum du das mit 3 variablen in der schleife machst? es reichen 2 oder sogar nur 1 variable.
Aber ich würde es mit 2 machen wenn du mich frägst.

x1[i] = i;                     // beide fangen bei 1 an und enden bei 200
    x2[j] = i;
    t[k] = k;                      // da hier bis 1500 ist es ok

[newkid]

beim 2ten hinsehen fällt mir eines auf

x1[100]

in der schleife muss dann int i = 0 anfangen und dann bis i>199
du machst ein array aber init. es nicht mit dem ersten sondern mit dem 2ten element da du in der scleife ja dann xi[i] hast. i ist bei dir am anfang i=1
Also musst du das abändern!

Das andere ist. BITTE benutze ein array. Ich habs dir in einem anderen Post schon geschrieben( der welcher verschoben wurde ). Bitte schau dir das nochmal genau an. arrays sind deine freunde. Denn du hast ja double lamda1 dann lamdal2 usw. Was machst du wenn es bis lamda 2001 geht? Oder bis 1 mille. deswegen ein array z.b. lamda[1000]
dann sprichst du es an mit lamda[0] =

Fazit: arrays sind deine freunde, mein freund ist der duden

[newkid]

ahhhh shifttaste hingekommen

i<200
also int i = 0; i<200 // wenn man es 200 mal machen will
i>199 ist doom // aaahhhhhhh

[newkid]

Stephan3 schrieb:

ich muss für ein programm mehr als 300.000 Berechnungen durchführen

Außerdem wird sich die anzahl der berechnungen mind. noch um den faktor 750 erhöhen, weil ich noch eine weitere variable "durchlaufen lassen muss"

und die berechnungen pro 1/25 sekunde stattfinden müssen.

Das ist doch nicht für ein schulprojekt, oder?

1. bei 300 000 berechnungen um Faktor 750 erhöht. hmmm tipp das mal bitte in den taschenrechner ein

2. 1/25 sec. // du arbeitest mit MFC? Wie willst du 1/25 genau jedesmal hinbekommen? weil du 1. keinen timer einsetzt und 2tens du das bei 1/25 auch normalerweise nicht mit timern hinbekommst.

Nicht das wir(ich) dir nicht helfen wollen(will), aber etwas mehr hintergrund wäre für uns(mich) nicht schlecht zu wissen.

[newkid]

also einen TIPP geb ich dir noch.

Schau mal in einem guten Buch nach, wie es mit den "lebensbereichen" einer variablen aussieht. oder geltungsbereichen oder wie auch immer.

Denn du schreibst oben in der schleife rein

u.a. int j = 0

dann unten in einer anderen schleife

j=0 // es muss int j = 0 heissen

Denn du hast in einer Schleife int i und j
Nach der Schleife gibts die Variablen nicht mehr.
Du musst also WIEDER int i und int j hinschreiben

ODER

Am Anfang des Prog. schreibst du int i und int j hin. oder int i,j;
Dann hast du diese in allen schleifen zur verfügung und kannst ein
j= 0 machen // denn er weiss das j typs int ist, da oben hingetippt.

[newkid]

Stephan3 schrieb:

for(j=1;j<100;j++)
			{
			
				for(i=1;i<100;i++)
				{
					s++,m++,n++,o++,p++,q++,r++;	
					
					z1[m] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda1 ) - ( sqrt ( ( x1[i] - a1 ) * ( x1[i] - a1 ) + ( x2[j] - a2 ) * ( x2[j] - a2 ) ) ) / lamda1 ) );
					z2[n] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda2 ) - ( sqrt ( ( x1[i] - b1 ) * ( x1[i] - b1 ) + ( x2[j] - b2 ) * ( x2[j] - b2 ) ) ) / lamda2 ) );
					z3[o] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda3 ) - ( sqrt ( ( x1[i] - c1 ) * ( x1[i] - c1 ) + ( x2[j] - c2 ) * ( x2[j] - c2 ) ) ) / lamda3 ) );
					z4[p] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda4 ) - ( sqrt ( ( x1[i] - d1 ) * ( x1[i] - d1 ) + ( x2[j] - d2 ) * ( x2[j] - d2 ) ) ) / lamda4 ) );
					z5[q] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda5 ) - ( sqrt ( ( x1[i] - e1 ) * ( x1[i] - e1 ) + ( x2[j] - e2 ) * ( x2[j] - e2 ) ) ) / lamda5 ) );
					z6[r] = sin ( 2 * PI * ( ( ( t[k] * C ) / lamda6 ) - ( sqrt ( ( x1[i] - f1 ) * ( x1[i] - f1 ) + ( x2[j] - f2 ) * ( x2[j] - f2 ) ) ) / lamda6 ) );
					
					z0[s] = z1[m] + z2[n] + z3[o] + z4[p] + z5[q] + z6[r];
				}
			

}

vielleicht hab ich auch irgendwas beim compiler falsch eingestellt oder es wurde irgendwas nicht richtig installiert... bin wie gesagt noch ziemlich neu beim programmieren und deswegen weiß ich noch net so bescheid...

im v****** Stephan

es heisst nicht vorraus sondern voraus

So zum "Problem". Ich will dich ja nicht fertig machen, sondern dir helfen indem ich dir aufzeige was alles falsch ist.

Du hast wie oben aufgezeigt 2 schleifen. Also rechnest du nicht "linear" sondern "quadratisch".

So zum "Problem"

1. warum nimmst du 2 schleifen, und somit quadratisch?
2. s=0
am anfang zählst du gleich eines hoch.
so wie es aussieht muss du am ende der schleife hochzählen, nicht gleich am anfang.

dann hast du in der i-schleife( die 2te halt) ein t[k] stehen. Was ist k? Du hast k nur einmal als zählvariable in einer schleife oben drinnen, ABER am ende der Schleife gibts es k nicht mehr! und Wenn du oben schon k hast dann bitte nicht hinschreiben

k=0 sondern int k = 0, oder soll MFC schätzen das es int sein soll?

Also als Tipp von mir. Gehe alleine nochmals alle Übungen durch. Wenn dir die elementarsten Dinge fehlen, dann wirds in Zukunfft nicht besser. Sprich du musst die "Basics" verstehen um an "heikleren" Dingen ranzugehen. Wenn in Zukunft Übungen kommen, welche noch schwieriger sind, dann hast du nicht in jeder 2ten zeile einen fehler sondern in jeder zeile 2 fehler.

[groovemaster]

Auch 'ne Art von Alleinunterhaltung.