ich hab mir zu meinem windows explorer ein kleines plugin geschrieben,

es soll für mich wenn ich etwas lösche die datei vorher mit nullen überschreiben damit sie nicht wiederherstellbar sind,

soweit funktioniert das auch gut, aber was ich mich frage ist das:

wenn ich jetzt eine datei größer 2^32 byte löschen will.. also > 4.3~gb wie kriege ich dann die richtige dateigröße?

weil bis jetzt speichere ich die länge in einer int, und die ist standartmäßig bei mir als __int32 deklariert

File->seekg(std::ios::end);
		int Lenght = File->tellg();
		File->close();
		delete File;

Schau dir GetFileSizeEx aus der WinAPI an.

Dann überschreibe mit CreateFile/WriteFile/CloseFile die Datei.

MfG SideWinder

weil derzeitig mache ich es so das ich einen 1 mb großen buffer habe, durch den teile ich die file größe wenn dabei bei einer integer division 0 herrauskommt nehme ich die datei größe selbst als buffer größe, um das schreiben zu beschleunigen, ist es sinnvoller einen größeren buffer zu wählen?

hab grad ein problem, er überschreibt die dateien nur stellenweise,

also mal nen paar bytes richtig, nen paar bytes lässt er wieder aus.

gibt aber keinen fehler.

BOOL ( WINAPI Mine_DeleteFileW )( LPCTSTR lpFileName ){
	std::wstring FileName = lpFileName;
	HANDLE hFile = CreateFileW( FileName.c_str(),
								GENERIC_READ | GENERIC_WRITE, 
								FILE_SHARE_READ, 
								NULL, 
								OPEN_EXISTING,
								FILE_ATTRIBUTE_NORMAL,
								NULL );
	if ( hFile == INVALID_HANDLE_VALUE){
		OutputDebugStringW(L"File handle couldnt be opened");
	}else{
		__int64 Size;
		int NumWritten;
		if ( !GetFileSizeEx( hFile, (PLARGE_INTEGER)&Size ) ){
			OutputDebugStringW(L"Couldnt optain size of file");
		}else{
			OutputDebugStringA(IntToString(Size).c_str());
			char * Buffer;
			const int BufferSize = 1048576;// 1Mb	
			if ( Size >= BufferSize ){
				__int64 Rounds = Size / BufferSize;
				int Rest = ( Size - ( Rounds * BufferSize ) );
				Buffer = new char[BufferSize];
				std::fill(Buffer,Buffer+BufferSize,0);
				for ( __int64 i = 0; i < Rounds; i++ ){
					if ( !WriteFile( hFile, Buffer, BufferSize, (PDWORD)&NumWritten, NULL ) ){
						OutputDebugStringW(L"Write file broke inside loop");					 
						break;
					}
				}
				delete[] Buffer;
				if ( Rest != 0 ){
					Buffer = new char[Rest];
					std::fill(Buffer,Buffer+Rest,0);
					if ( !WriteFile( hFile, Buffer, Rest, (PDWORD)&NumWritten, NULL ) ){
						OutputDebugStringW(L"Write file broke inside rest");					 
					}
					delete[] Buffer;
				}
			}else{
				Buffer = new char[Size];
				std::fill(Buffer,Buffer+Size,0);
				if ( !WriteFile( hFile, Buffer, Size, (PDWORD)&NumWritten, NULL ) ){
					OutputDebugStringW(L"Write file broke inside small version");					 
				}
				delete[] Buffer;
			}
			FileName += L" was safe deleted : Wide";
			OutputDebugStringW(FileName.c_str());
		}
		CloseHandle(hFile);
	}

	return Real_DeleteFileW(lpFileName);
}

File->seekg(std::ios::end);
		int Lenght = File->tellg();

SideWinder schrieb:

Vor allem weil dein seekg()-Aufruf afaik nichtmal standardisiert ist (ergo nicht die Dateigröße zurückgeben muss).

Da muss ich mal ganz dumm nachfragen: Folgende Variante ist aber standardisiert und liefert 100%ig die Dateigröße (in Bytes)?

std::fstream file("test.txt");
file.seekg(0, std::ios::end);   // Lesezeiger auf Dateiende setzten
size_t fileSize = file.tellg(); // Zeigerposition abrufen (Offset zu Dateianfang in Bytes)