c++ dynamisches array?!? big problem...

CodeFinder

Das andere 'i' wird direkt darüber definiert und ist 0 (sieht zum mindestens in Seinem Code so aus).

@CodeFinder:
Ja beim debuggen bekomm ich immer AccessViolation errors... genau an der Stelle wos sonst immer abstürzt...
was meinst du mit std::vector? wos soll ich das verwenden?

Danke,
mfg

CStoll

progsepp schrieb:

@CodeFinder:
Ja beim debuggen bekomm ich immer AccessViolation errors... genau an der Stelle wos sonst immer abstürzt...

Und an welcher Stelle genau ist das? (hast du mal überprüft, ob lnumTriangle nicht gleich 0 ist?)

was meinst du mit std::vector? wos soll ich das verwenden?

Anstelle deiner blanken Arrays:

struct SECTOR
{
    vector<TRIANGLE> triangle;
    vector<CIRCLE> circle;
    vector<CYLINDER> cylinder;

/*  long lnumTriangle;
    long lnumCircle;
    long lnumCylinder;
    long lnumObjects;

    TRIANGLE *triangle;
    CIRCLE *circle;
    CYLINDER *cylinder;
*/  
};

int lnumTriangle=2;
int lnumCircle=2;
int lnumCylinder=2;
sSector0.triangle.resize(lnumTriangle);
sSector0.circle.resize(lnumCircle);
sSector0.cylinder.resize(lnumCylinder)];

(btw, beim Durchsehen deines Codes ist mir noch etwas aufgefallen - du hast die Zähler-Werte 'lnum...' deines SECTOR nicht initialisiert)

genau bei der forschleife sind die access violations... also wenn ich auf triangle... zugreife.

wenn ich den code abändere:

struct SECTOR
{
long lnumTriangle;
long lnumCircle;
long lnumCylinder;
long lnumObjects;

vector<TRIANGLE> triangle;
vector<CIRCLE> circle;
vector<CYLINDER> cylinder;

/TRIANGLE triangle[10];
CIRCLE circle[10];
CYLINDER cylinder[10];/

};

sSector0.triangle.resize(inumTriangle);
sSector0.circle.resize(inumCircle);
sSector0.cylinder.resize(inumCylinder);

bekomm ich 85 fehler; von wegen triangle sei kein object von sector usw...

CStoll

Welches ist denn der erste Fehler der dabei auftritt?

Ich würde spontan tippen auf "nicht deklarierter Bezeichner vector" - wenn ich richtig liege: du mußt <vector> includen und an den Namensraum std:: denken:

#include <vector>
using std::vector;
...//der Rest wie gehabt

(btw, die lnum... Member brauchst du nicht wirklich - die Anzahl deiner Dreiecke etc kannst du besser über sSector0.triangles.size() ermitteln (das macht weniger Aufwand als wenn du ständig von Hand nachzählen müsstest)

so jetzt hat er compiliert...
allerdings wenn ich wieder auf die variablen zugreifen will, zag violation error.

ich hab aber auch probiert auf die in der Sector struktur deklarierten lnum... zuzugreifen, das funktioniert, nur ebm auf die dynamischen will er einfach nicht.

CStoll

Achte mal auf die Reihenfolge, in der du durch das Programm läufst - hast du die Größe der vector<>en gesetzt, BEVOR du versucht hast, etwas in ihnen zu lesen?

(ein default-konstruierter vector<> ist leer - also ist es in dem Zustand verboten, irgendwas aus seinen Innereien herauszulesen)

ja hab ich alles gemacht... ich verstehs einfach nicht...
danke

CStoll

Mit den paar Fragmenten versteh' ich's auch nicht. Zeig doch mal ein zusammenhängedes Programm, in dem dein Problem auftritt.

also wie gehabt die deklaration:

struct KOPOS
{
	float fx,fy,fz;
	float ftx,fty;
};

struct TRIANGLE
{
	KOPOS kopos[3];
	int iTex;
	float alpha;
	float r,g,b;
};

struct CIRCLE
{
	KOPOS kopos;
	float rad;
	int iTex;
	float alpha;
	float r,g,b;
};

struct CYLINDER
{
	KOPOS kopos;
	float inrad;
	float outrad;
	float length;
	int iTex;
	float alpha;
	float r,g,b;
};

struct SECTOR
{
	long lnumTriangle;
	long lnumCircle;
	long lnumCylinder;
	long lnumObjects;

	TRIANGLE *triangle;
	CIRCLE *circle;
	CYLINDER *cylinder;

};

SECTOR sSector0;

dann die zuweisung:

char* fgetsN(FILE* fFile)
{
	char* cbuffer=(char*)malloc(256);
	while(!feof(fFile))
	{
		fgets(cbuffer,255,fFile);
		if((cbuffer[0]!='\n')&&(cbuffer[0]!='/')&&(cbuffer[0]!=' '))
			return (char*)cbuffer;
	}

	return (char*)"_eof_";

}

GLvoid GL_Load_Objects()
{
	FILE* fObjects;
	fObjects = fopen("data\\model.txt", "r");
	char* buffer=(char*)malloc(256);
	char cObject[256];
	char cBitmapPathBuf[256];

	while(!feof(fObjects))
	{

		 buffer=fgetsN(fObjects);

		 sscanf(buffer,"NUMTRIANGLE %d\n",&inumTriangle);
		 sSector0.lnumTriangle=inumTriangle;

		 buffer=fgetsN(fObjects);
		 sscanf(buffer,"NUMCIRCLE %d\n",&inumCircle);
		 sSector0.lnumCircle=inumCircle;

		 buffer=fgetsN(fObjects);
		 sscanf(buffer,"NUMCYLINDER %d\n",&inumCylinder);
		 sSector0.lnumCylinder=inumCylinder;

		break;

	}

	sSector0.triangle= new TRIANGLE[inumTriangle];
	sSector0.circle= new CIRCLE[inumCircle];
	sSector0.cylinder= new CYLINDER[inumCylinder];

	int numtriangle=0;
	int numcircle=0;
	int numcylinder=0;

	sSector0.lnumObjects=sSector0.lnumTriangle+sSector0.lnumCircle+sSector0.lnumCylinder;

	while(!feof(fObjects))
	{

		 buffer=fgetsN(fObjects);

		 sscanf(buffer,"BITNUM %i",&bitnum);

		 for(int i=0; i<bitnum; i++)
		 {
			buffer=fgetsN(fObjects);
			sscanf(buffer,"BITTEX %s\n",&cBitmapPathBuf);
			strcpy(cBitmapPath[i],cBitmapPathBuf);

		 }

		break;

	}

	float fx,fy,fz;
	float ftx,fty;
	float r,g,b;
	float alpha;
	int itex;
	float rad,inrad,outrad,length;

	while(true)
	{
		buffer=fgetsN(fObjects);

		if(!strcmp(buffer,"_eof_"))
			break;

		strcpy(cObject,"");
		sscanf(buffer,"OBJECT %s\n",&cObject);

		if(!strcmp(cObject,"TRIANGLE"))
		{
			buffer=fgetsN(fObjects);
			sscanf(buffer,"TEX %i\n",&itex);
			sSector0.triangle[numtriangle].iTex=itex;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"ALPHA %f\n",&alpha);
			sSector0.triangle[numtriangle].alpha=alpha;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"RGB %f %f %f\n",&r,&g,&b);

			sSector0.triangle[numtriangle].r=r;
			sSector0.triangle[numtriangle].g=g;
			sSector0.triangle[numtriangle].b=b;

			for(int i=0; i<3; i++)
			{
				buffer=fgetsN(fObjects);
				sscanf(buffer, "%f %f %f %f %f", &fx, &fy, &fz, &ftx, &fty);
				sSector0.triangle[numtriangle].kopos[i].fx=fx;
				sSector0.triangle[numtriangle].kopos[i].fy=fy;
				sSector0.triangle[numtriangle].kopos[i].fz=fz;

				sSector0.triangle[numtriangle].kopos[i].ftx=ftx;
				sSector0.triangle[numtriangle].kopos[i].fty=fty;
			}

			numtriangle++;

		}
		else if(!strcmp(cObject,"CIRCLE"))
		{
			buffer=fgetsN(fObjects);
			sscanf(buffer,"TEX %i\n",&itex);
			sSector0.circle[numcircle].iTex=itex;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"ALPHA %f\n",&alpha);
			sSector0.circle[numcircle].alpha=alpha;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"RGB %f %f %f\n",&r,&g,&b);

			sSector0.circle[numcircle].r=r;
			sSector0.circle[numcircle].g=g;
			sSector0.circle[numcircle].b=b;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"RAD %f\n",&rad);
			sSector0.circle[numcircle].rad=rad;

			buffer=fgetsN(fObjects);
			sscanf(buffer, "%f %f %f %f %f", &fx, &fy, &fz, &ftx, &fty);
			sSector0.circle[numcircle].kopos.fx=fx;
			sSector0.circle[numcircle].kopos.fy=fy;
			sSector0.circle[numcircle].kopos.fz=fz;

			sSector0.circle[numcircle].kopos.ftx=ftx;
			sSector0.circle[numcircle].kopos.fty=fty;

			numcircle++;	

		}
		else if(!strcmp(cObject,"CYLINDER"))
		{
			buffer=fgetsN(fObjects);
			sscanf(buffer,"TEX %i\n",&itex);
			sSector0.cylinder[numcylinder].iTex=itex;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"ALPHA %f\n",&alpha);
			sSector0.cylinder[numcylinder].alpha=alpha;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"RGB %f %f %f\n",&r,&g,&b);

			sSector0.cylinder[numcylinder].r=r;
			sSector0.cylinder[numcylinder].g=g;
			sSector0.cylinder[numcylinder].b=b;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"INRAD %f\n",&inrad);
			sSector0.cylinder[numcylinder].inrad=inrad;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"OUTRAD %f\n",&outrad);
			sSector0.cylinder[numcylinder].outrad=outrad;

			buffer=fgetsN(fObjects);
			sscanf(buffer,"LENGTH %f\n",&length);
			sSector0.cylinder[numcylinder].length=length;

			buffer=fgetsN(fObjects);
			sscanf(buffer, "%f %f %f %f %f", &fx, &fy, &fz, &ftx, &fty);
			sSector0.cylinder[numcylinder].kopos.fx;
			sSector0.cylinder[numcylinder].kopos.fy;
			sSector0.cylinder[numcylinder].kopos.fz;

			sSector0.cylinder[numcylinder].kopos.ftx;
			sSector0.cylinder[numcylinder].kopos.fty;

			numcylinder++;	
		}
		else
			break;

	}

	fclose(fObjects);

}

dann die verwendung:

GLvoid GL_Load_Lists()
{
	GL_Delete_Lists();
	GL_Reset();

	lListPos=glGenLists(sSector0.lnumObjects);
	lListRunner=lListPos;

	int i=0;
	GLfloat fpx,fpy,fpz,ftpx,ftpy,frad,finrad,foutrad,flength; 
	for(i=0; i<sSector0.lnumTriangle; i++)
	{
		glNewList(lListRunner,GL_COMPILE);
		glColor4f(sSector0.triangle[i].r,sSector0.triangle[i].g,sSector0.triangle[i].b,sSector0.triangle[i].alpha);
		if(sSector0.triangle[i].iTex>0)
		{
			glEnable(GL_TEXTURE_2D);
			glBindTexture(GL_TEXTURE_2D, texture[sSector0.triangle[i].iTex]);
		}
		else
			glDisable(GL_TEXTURE_2D);

		glBegin(GL_TRIANGLES);
		glNormal3f( 0.0f, 0.0f, 1.0f);
		for (int j=0; j<3; j++)
		{

				fpx = sSector0.triangle[i].kopos[j].fx;
				fpy = sSector0.triangle[i].kopos[j].fy;
				fpz = sSector0.triangle[i].kopos[j].fz;
				ftpx = sSector0.triangle[i].kopos[j].ftx;
				ftpy = sSector0.triangle[i].kopos[j].fty;
				glTexCoord2f(ftpx,ftpy); glVertex3f(fpx,fpy,fpz);

		}
		glEnd();
		glEndList();
		lListRunner++;
	}

	for(i=0; i<sSector0.lnumCircle; i++)
	{
		glNewList(lListRunner,GL_COMPILE);
		glColor4f(sSector0.circle[i].r,sSector0.circle[i].g,sSector0.circle[i].b,sSector0.circle[i].alpha);
		if(sSector0.circle[i].iTex>0)
		{
			glEnable(GL_TEXTURE_2D);
			glBindTexture(GL_TEXTURE_2D, texture[sSector0.circle[i].iTex]);
		}
		else
			glDisable(GL_TEXTURE_2D);

		fpx = sSector0.circle[i].kopos.fx;
		fpy = sSector0.circle[i].kopos.fy;
		fpz = sSector0.circle[i].kopos.fz;
		ftpx = sSector0.circle[i].kopos.ftx;
		ftpy = sSector0.circle[i].kopos.fty;
		frad = sSector0.circle[i].rad;

		glTexCoord2f(ftpx,ftpy);
		glTranslatef(fpx,fpy,fpz);
		gluSphere(gluobjects,frad,32,32);

		glEndList();
		lListRunner++;
	}

	for(i=0; i<sSector0.lnumCylinder; i++)
	{
		glNewList(lListRunner,GL_COMPILE);
		glColor4f(sSector0.cylinder[i].r,sSector0.cylinder[i].g,sSector0.cylinder[i].b,sSector0.cylinder[i].alpha);
		if(sSector0.cylinder[i].iTex>0)
		{
			glEnable(GL_TEXTURE_2D);
			glBindTexture(GL_TEXTURE_2D, texture[sSector0.cylinder[i].iTex]);
		}
		else
			glDisable(GL_TEXTURE_2D);

		fpx = sSector0.cylinder[i].kopos.fx;
		fpy = sSector0.cylinder[i].kopos.fy;
		fpz = sSector0.cylinder[i].kopos.fz;
		ftpx = sSector0.cylinder[i].kopos.ftx;
		ftpy = sSector0.cylinder[i].kopos.fty;
		finrad = sSector0.cylinder[i].inrad;
		foutrad = sSector0.cylinder[i].outrad;
		flength = sSector0.cylinder[i].length;

		glTexCoord2f(ftpx,ftpy);
		glTranslatef(fpx,fpy,fpz);
		gluCylinder(gluobjects,finrad,foutrad,flength,32,32);	

		glEndList();
		lListRunner++;
	}

	lListRunner=lListPos;
}

und schließlich die zeichenroutine:

GLvoid GL_Render_Scene()
{

	GL_Cls();
	GL_Reset();

	gluobjects=gluNewQuadric();
	gluQuadricNormals(gluobjects, GLU_SMOOTH);
	gluQuadricTexture(gluobjects, GL_TRUE);

	glPolygonMode(GL_BACK, GL_POLY_MODE);                     
	glPolygonMode(GL_FRONT, GL_POLY_MODE);

	glRotatef(ydrehwinkel,0,1,0);
	glRotatef(xdrehwinkel,1,0,0);

	GL_Set3DPos(xweg/iRunFactor-2.0f,yweg/iRunFactor+0.0f,zweg/iRunFactor-12.0f);     

	int i=0;

    // wenn dieser teil ausklammert ist, läuft es, wenn nicht, stürtzt es ab...
       glColor4f(sSector0.triangle[i].r,
                      sSector0.triangle[i].g,
                      sSector0.triangle[i].b,
                      sSector0.triangle[i].alpha);

   //
	for(i=lListPos; i<=sSector0.lnumObjects; i++)
	{
		glCallList(i);
	}

}

sonst wird nirgend darauf zugegriffen, wenn die variablen statisch deklariert sind, läufts auch perfekt...

danke,mfg

CStoll

Und wo ist das Hauptprogram, das alle Aktionen in die richtige Reihenfolge bringt?

PS: globale Variablen sind Böse

das ist der code:

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow)
{

	MSG		msg;

	if (!GL_CreateWindow("OpenGLWindow",false,640,480,16,0,30,0))
		return 0;

	CreateThread(NULL, 0, Action_Thread, NULL, 0, NULL);

	while(true) 
	{
		if(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) 
		{
			if(msg.message==WM_QUIT||msg.message==WM_CLOSE||msg.message==WM_DESTROY)
				break;
			else
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg); 
			}
		}
		else 
		{
			if(GetForegroundWindow()==hWnd) 
			{
				if (bkeys[VK_ESCAPE]) 
					break;
				else if(bkeys[VK_F5])
				{
					GL_Load_Objects();
					GL_Load_Lists();
					bkeys[VK_F5]=false;
				}
				else
				{
					GL_Render_Scene();
					GL_SwapBuffers(); 
					Sleep(iDelay);
				}

			}

			if(bkeys[VK_F1]) 
			{
				bkeys[VK_F1]=FALSE; 
    			GL_DestroyWindow(szAppName); 
				bFullScr=!bFullScr; 

				if (!GL_CreateWindow(szAppName,bFullScr,640,480,16,0,40,0))    
					return 0; 

			}

		}
	}

	GL_DestroyWindow(szAppName);
	return (msg.wParam);
}

Unter GL_CreateWindow wird die initglfunktion aufgerufen hier im detail:

int GL_InitGraphics(GLvoid)
{ 

	GL_Load_Objects();
	GL_Load_Textures();
	GL_Load_Lists();

	return TRUE;
}

mfg

PS: dass ich bei F5 nochmals die funktionen loadobject und loadlist aufrufe habe ich erst neulich eingebaut, seitdem ich mit statischen variblen arbeite, habe ich allerdings vorher auch nie eingebaut gehabt, also diesen teil eventuell weckdenken