Deklaration einer fstream/ofstream Variable führt zu crash



  • 😕 😕 😕
    HI!
    Ich habe ein relativ großes Projekt. In einer Klassenmethode brauche ich ganz normal einen Stream zu einer Datei. Nur leider crasht der Stream das komplette Programm. Egal ob ichs nur so mache:

    ofstream filestream;
    filestream.open(path,ofstream::binary);
    

    oder so

    ofstream filestream(path,ofstream::binary);
    

    Der crasht einfach bei der Deklaration...keine Ahnung woran das liegen kann...Compilerfehler?

    Der Absturz ist eine read-Accessviolation.

    In der gleichen Funktion ist er mir vorher schonmal gecrasht, weil ich Speicher allokiert habe....Ist hier mein Heap + Stack kaputt???

    Keine Ahnung mehr was ich machen soll...

    Gruß,
    Kevin



  • Meines wissen muss da noch irgendwo ios_base::out hin



  • Hatte ich anfangs drinnen...braucht man aber in dem Fall nicht da der Name ofstream ja schon sagt, dass es nach "draußen" geht...Fehler muss wo anders liegen...Compilerbug? 😕



  • hmm, ich habe nachgeschaut und du hast recht man kann es weglassen las mal ios::binary zu testzwecken weg und mach nur filestream.open("file");

    Ich habe noch mal in der MSDN nachgeschaut und eventuell hilft dir der dritte Parameter.

    (Sonst gibt es immer noch dir C Methode 😉 )



  • Das Problem ist nicht das open sondern die Deklaration! Der schmiert mir bei der Deklaration ab...das ganze Projekt hat Probleme mit der Speicherverwaltung...eventuell weil ich es aus MSDEV 6 zu .NET konvertiert habe...es ist doch nicht normal, dass auch (in einer anderen Funktion der selben Klasse) ein "char* bla = new char[10]" zum Crash führt....

    Da nur ich das Programm benutze und der Crash im Debugmodus nicht auftritt, könnte ich es ja im Debugmodus benutzen...finde es aber unschön..welche C-Methode meinst du? FILE?



  • Der Bug tritt übrigens auch nur dann auf, wenn ich die Funktion aus der Funktion aufrufe, in der es die Allokiercrashes gibt/gab...wenn ich sie aus cleanen Funktionen aufrufe bleibt alles sauber 😕
    Super

    Kevin



  • Das ist allerdings merkwürdig, ich meinte das mit FILE, den ich hatte vor kurzem auch ein Problem mit dem Auslesen von Datein, habs dann durch das umstellen auf FILE gelöst.



  • Hi Surkevin, am besten programmierst du alles nochmal neu und dann vernünftig.



  • Dieser Thread wurde von Moderator/in cd9000 aus dem Forum WinAPI in das Forum C++ verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.



  • das is vernünftig gecodet...glaubs mir...denke es hängt mir der konvertierung VS 6.0 -> .NET zusammen... 😕



  • Also ich würde dir raten (unter der vorraussetung das wirklich keine Code Fehler da ist), erstelle ein neues Projekt und binde deine ganzen Datein da nochmal ein. Damit solltest du eigentlich Fehler des Kompillers umgehen. Sonst kannst du dir zum testen auch mal Dev-Cpp laden und den Code dort versuchen zu kompelieren.



  • ich bin mir sehr sicher, dass der fehler nicht von mir kommt, da unter MS Dev6 keine Crashes waren!
    Kevin



  • Was hast du da denn überhaupt konvertiert??? Die Linker Hilsdatein oder was? Den der Code an sich muss sich ja nicht verändern oder benutzt du MFC oder etwas ähnliches??



  • alles reine WINAPI...msdev hat das konvertieren übernommen



  • jetzt crasht er wieder beim allokieren...gibt doch net....der crasht genau beim allokieren von speicher für textures...mit malloc und auch mit new....hier mal die Funktion:

    void CXFile::Convert(CModel& Object, char * path, DX_Object& dd_obj, D3DXVECTOR3 position, D3DXVECTOR3 lookat)
    	{
    
    		//char* blubb = new char[10];
    		//delete blubb;
    
    		LPDIRECT3DVERTEXBUFFER9 m_meshvertexbuffer;
    		LPDIRECT3DINDEXBUFFER9 m_meshindexbuffer;
    		D3DVERTEXBUFFER_DESC m_vertexdesc;
    		D3DINDEXBUFFER_DESC m_indexdesc;
    
    		ModelFormatHeader m_meshheader;
    
    		//TVertex *v;
    
    		DWORD *dwIndicies32 = NULL;
    		WORD *dwIndicies16 = NULL;
    
    		TModelVertex *polygon = NULL;
    
    		VOID *pVertex = NULL;
    		VOID *pIndex = NULL;
    
    		//Get Materials/Textures
    
    		if(m_pMesh == NULL  || matMaterials == NULL)
    		{
    			MessageBox(dd_obj.hwnd, "Mesh wurde noch nicht erstellt!", 0, 0);
    		}
    
    		//		char debug[256];
    
    		if(m_pMesh->GetVertexBuffer(&m_meshvertexbuffer) != D3D_OK)
    		{
    			MessageBox(dd_obj.hwnd, "Laden der Meshvertizen schlug fehl :(", 0, 0);
    		}
    
    		if(m_pMesh->GetIndexBuffer(&m_meshindexbuffer) != D3D_OK)
    		{
    			MessageBox(dd_obj.hwnd, "Fehler ;)", 0, 0);
    		}
    
    		if(m_meshvertexbuffer->GetDesc(&m_vertexdesc) != D3D_OK)
    		{
    			MessageBox(dd_obj.hwnd, "Infos schlugen fehl - klasse!", 0, 0);
    		}
    
    		if(m_meshindexbuffer->GetDesc(&m_indexdesc) != D3D_OK)
    		{
    			MessageBox(dd_obj.hwnd, "Infos schlugen fehl - klasse!", 0, 0);
    		}
    
    		DWORD dIndiciesSize = 0;
    		BOOL bLowBit = TRUE;
    
    		BOOL bXYZ = FALSE;
    		BOOL bRHW = FALSE;
    		BOOL bNormals = FALSE;
    		BOOL bTex = FALSE;
    		BOOL bDiffuse = FALSE;
    		BOOL bSpecular = FALSE;
    		BOOL bPointSize = FALSE;
    
    		DWORD dwVertexSize = NULL;
    
    		DWORD dwFVFCode = NULL;		
    
    		if(m_vertexdesc.FVF & D3DFVF_XYZ)
    		{
    			bXYZ = TRUE;
    			dwVertexSize += 3*sizeof(float);
    			dwFVFCode |= D3DFVF_XYZ;
    		}
    		else if(m_vertexdesc.FVF & D3DFVF_XYZRHW)
    		{
    			bXYZ = TRUE;
    			bRHW = TRUE;
    			dwVertexSize += 4*sizeof(float);
    			dwFVFCode |= D3DFVF_XYZRHW;
    		}
    
    		if(m_vertexdesc.FVF & D3DFVF_NORMAL)
    		{
    			bNormals = TRUE;
    			dwVertexSize += 3*sizeof(float);
    			dwFVFCode |= D3DFVF_NORMAL;
    		}
    
    		if(m_vertexdesc.FVF & D3DFVF_TEX1)
    		{
    			bTex = TRUE;
    			dwVertexSize += 2*sizeof(float);
    			dwFVFCode |= D3DFVF_TEX1;
    		}
    
    		if(m_vertexdesc.FVF & D3DFVF_DIFFUSE)
    		{
    			bDiffuse = TRUE;
    			dwVertexSize += 1*sizeof(DWORD);
    			dwFVFCode |= D3DFVF_DIFFUSE;
    		}
    
    		if(m_vertexdesc.FVF & D3DFVF_PSIZE)
    		{
    			bPointSize = TRUE;
    			dwVertexSize += 1*sizeof(float);
    			dwFVFCode |= D3DFVF_PSIZE;
    		}
    
    		if(m_vertexdesc.FVF & D3DFVF_SPECULAR)
    		{
    			bSpecular = TRUE;
    			dwVertexSize += 1*sizeof(DWORD);
    			dwFVFCode |= D3DFVF_SPECULAR;
    		}
    
    		if(dwFVFCode == m_vertexdesc.FVF)
    		goto works;
    
    		MessageBox(0, "Converting failed! FVF is not supported!", 0, 0);
    		return;
    works:
    
    		DWORD dwVertices = (m_vertexdesc.Size/dwVertexSize);		
    
    		BYTE* vertices = new BYTE[dwVertexSize*dwVertices];
    
    		if(m_indexdesc.Format == D3DFMT_INDEX32)
    		{
    
    			bLowBit = FALSE;
    
    			dwIndicies32 = new DWORD[((m_indexdesc.Size)/sizeof(DWORD))];
    			dwIndicies16 = new WORD[((m_indexdesc.Size)/sizeof(DWORD))];
    
    			if(m_meshindexbuffer->Lock(0, m_indexdesc.Size, (void**)&pIndex, D3DLOCK_READONLY) != D3D_OK)
    			{
    				MessageBox(dd_obj.hwnd, "gibts net", 0, 0);
    			}
    
    			memcpy(dwIndicies32, pIndex, m_indexdesc.Size);
    
    			m_meshindexbuffer->Unlock();
    
    			for(int i = 0; i < (signed)((m_indexdesc.Size)/sizeof(DWORD)); i++)
    			{
    				dwIndicies16[i] = (signed)dwIndicies32[i];
    			}
    
    			dIndiciesSize = ((m_indexdesc.Size)/sizeof(DWORD)*sizeof(WORD));
    
    		}
    		else
    		{
    
    			bLowBit = TRUE;
    
    			dwIndicies16 = new WORD[((m_indexdesc.Size)/sizeof(WORD))];
    
    			if(m_meshindexbuffer->Lock(0, m_indexdesc.Size, (void**)&pIndex, D3DLOCK_READONLY) != D3D_OK)
    			{
    				MessageBox(dd_obj.hwnd, "gibts net", 0, 0);
    			}
    
    			memcpy(dwIndicies16, pIndex, m_indexdesc.Size);
    
    			m_meshindexbuffer->Unlock();
    
    			dIndiciesSize = m_indexdesc.Size;
    
    		}
    
    		polygon = new TModelVertex[dwVertices];
    
    		if(m_meshvertexbuffer->Lock(0, m_vertexdesc.Size, (void**)&pVertex, D3DLOCK_READONLY) != D3D_OK)
    		{
    			MessageBox(dd_obj.hwnd, "Der Vertexbuffer konnte beim Konvertieren nicht gelockt werden!", "Error!", 0);
    		}
    
    		memcpy(vertices, pVertex, m_vertexdesc.Size);
    
    		m_meshvertexbuffer->Unlock();
    
    		//Convert the XFile Vertices to our Vertices
    		TVertex* v = new TVertex[dwVertices];
    
    		MessageBox(0, "Alles aus dem Mesh gelesen", 0, 0);
    
    		{for(int i = 0; i < (int)dwVertices; i++)
    		{
    			if(bXYZ)
    			memcpy(&v[i].position, (BYTE*)vertices + i*dwVertexSize, sizeof(D3DXVECTOR3));
    
    			if(bTex)
    			memcpy(&v[i].tu, (BYTE*)vertices + i*dwVertexSize + dwVertexSize - 2*sizeof(float), 2*sizeof(float));
    		}}
    
    		MessageBox(0, "Alles Teil kopiert", 0, 0);
    
    		//Convert to TModelPolygon
    
    		{for(unsigned int i = 0; i < dwVertices; i++)
    		{
    			polygon[i].v = v[i];
    		}}
    
    		{for(unsigned int i = 0; i < ((dIndiciesSize/sizeof(WORD))/3); i = i + 3)
    		{
    			D3DVECTOR vNormal = GetTriangeNormal(&D3DXVECTOR3(v[dwIndicies16[i]].position.x, v[dwIndicies16[i]].position.y, v[dwIndicies16[i]].position.z), 
    				&D3DXVECTOR3(v[dwIndicies16[i + 1]].position.x, v[dwIndicies16[i + 1]].position.y, v[dwIndicies16[i + 1]].position.z),
    				&D3DXVECTOR3(v[dwIndicies16[i + 2]].position.x, v[dwIndicies16[i + 2]].position.y, v[dwIndicies16[i + 3]].position.z));
    
    			if(!bTex)
    			{
    				v[dwIndicies16[i]].tu = 0;
    				v[dwIndicies16[i]].tv = 0;
    
    				v[dwIndicies16[i + 1]].tu = 1;
    				v[dwIndicies16[i + 1]].tv = 1;
    
    				v[dwIndicies16[i + 2]].tu = 0;
    				v[dwIndicies16[i + 2]].tv = 1;
    			}
    
    			v[dwIndicies16[i]].nx = vNormal.x;
    			v[dwIndicies16[i]].ny = vNormal.y;
    			v[dwIndicies16[i]].nz = vNormal.z;
    
    			v[dwIndicies16[i + 1]].nx = vNormal.x;
    			v[dwIndicies16[i + 1]].ny = vNormal.y;
    			v[dwIndicies16[i + 1]].nz = vNormal.z;
    
    			v[dwIndicies16[i + 2]].nx = vNormal.x;
    			v[dwIndicies16[i + 2]].ny = vNormal.y;
    			v[dwIndicies16[i + 2]].nz = vNormal.z;
    		}}
    
    		//Get Length of TextureText
    		int iLength = 0;
    		{
    			for(int i = 0; i < (signed)m_MaterialsCount; i++)
    			{
    				if(matMaterials[i].pTextureFilename != NULL)
    				{
    					//MessageBox(0, matMaterials[i].pTextureFilename, "wtf", 0);
    
    					DeletePathOfTexture(matMaterials[i].pTextureFilename);
    					//MessageBox(0, matMaterials[i].pTextureFilename, 0, 0);
    					iLength = iLength + strlen(matMaterials[i].pTextureFilename) + strlen("\xd");
    				}
    				else
    				{
    					iLength = iLength + strlen("\xd");
    				}
    			}
    		}
    
    		char debug[256];
    		wsprintf(debug, "Textureslength: %i", iLength);
    		MessageBox(0, debug, 0, 0);
    

    Hier crashts:

    textures = (char*)malloc(iLength + 256);  //CRAAAAAAAAASH
    
    		MessageBox(0, "und los gehts", 0, 0);
    		//Set Textures
    		ZeroMemory(textures, iLength+255);
    
    		MessageBox(0, "1", 0, 0);
    
    		{
    			for(int i = 0; i < (signed)m_MaterialsCount; i++)
    			{
    				if(matMaterials[i].pTextureFilename != NULL){
    					strcat(textures, matMaterials[i].pTextureFilename);
    				}
    				strcat(textures, "\xd");
    				//MessageBox(0, "STRCAT", 0, 0);
    
    			}
    		}
    		MessageBox(0, "2", 0, 0);
    
    		//SetMaterials
    		m_usedMaterials = new D3DMATERIAL9[m_MaterialsCount];
    		{
    			for(int i = 0; i < (signed)m_MaterialsCount; i++)
    			{
    				m_usedMaterials[i] = matMaterials[i].MatD3D;
    				m_usedMaterials[i].Ambient = m_pMeshMaterials[i].Diffuse;
    			}
    		}
    
    		MessageBox(0, "3", 0, 0);
    
    		for(int i = 0; i < (signed)m_MaterialsCount; i++)
    		{
    			for(int count = attribrange[i].VertexStart; count < (signed)(attribrange[i].VertexStart + attribrange[i].VertexCount); count++)
    			{
    				polygon[count].ID = i;
    			}
    		}
    
    		MessageBox(0, "4", 0, 0);
    
    		m_meshheader.cb = sizeof(ModelFormatHeader);
    		m_meshheader.iPolygons = ((dIndiciesSize/sizeof(WORD))/3);
    		m_meshheader.iVersion = 1;
    		m_meshheader.iVertizes = dwVertices;
    		m_meshheader.iSizeOfVertizes = (dwVertices*sizeof(TModelVertex));
    		m_meshheader.iSizeOfIndexbuffer = dIndiciesSize;
    		m_meshheader.iSizeOfTextures = strlen(textures)*sizeof(char);
    		m_meshheader.iSizeOfMaterials = sizeof(D3DMATERIAL9)*m_MaterialsCount;
    		m_meshheader.cameralookat = lookat;
    		m_meshheader.cameraposition = position;
    
    		Object.WriteModelFile(path, polygon, dwIndicies16, m_meshheader, 
    			m_meshheader.iSizeOfVertizes, m_meshheader.iSizeOfIndexbuffer, textures, m_usedMaterials);
    
    		MessageBox(dd_obj.hwnd, "Successfully saved the Modelfile", "SUCCESS!", 0);
    
    		delete [] v;
    		delete [] dwIndicies16;
    		if(!bLowBit)
    		{
    			delete [] dwIndicies32;
    		}
    		delete [] polygon;
    		free(textures);
    		delete [] vertices;
    
    	}
    


  • ok ich spiel erst seit ner woche mit c++ rum aber mal so out of the blue:
    ich denke es haengt mit dem var namen filestream zusammen - compiler hat wohl probleme mit der gleichnamigen .net klasse FileStream.
    hoffe das hilft !!



  • hi, ne *g* daran kann das nicht liegen 🙂
    muss ein Bug in meinem .NET sein...bei nem Kumpel von mir verreckt es nämlich nicht wenn er es kompiliert...hat ne neuere .NET - Version!
    Danke trotzdem
    Kevin


Log in to reply