Ich habe wieder mal ein Problem. Ich möchte ein Datei kopieren

Die Datei muss hierzu im Binary-Mode geöffnet, der Inhalt ausgelesen und dann kopiert werden.

Bisher habe ich versucht:

DateiKopieren(char quelle[], char ziel[])
{
ifstream infile(quelle, ios::binary);

	if(infile.good())
	{
		AnsiString S = ziel + ExtractFileName(AnsiString(quelle));
		int i = DateGroesseErmitteln(AnsiString(quelle));

		ofstream outfile(S.c_str(), ios::binary);

		if(outfile.good())
			outfile.write((char*)&infile, i);

		ShowMessage("Öffnen gelungen");

	outfile.close();
	}
}

Mir fehlt ein fstream Buffer wo ich den Inhalt erst einlesen kann!
Hat jemand ein Idee?

ich dachte dass mit diese Vorgehensweise könnte man auch die geöffnete Dateien (bzw. *.pst) kopieren, das ist leider nicht der Fall, obwohl unter VisualBasic sollte es auf diese Weise gehen:
http://www.vbarchiv.net/tipps/details.php?id=783

Ich denke es muss auch unter C++ möglich sein die geöffnete Dateien zu kopieren.
Die Frage ist mit welcher Methode?

in.seekg(ios::beg);

wieder zurücksetzen

in.clear();
in.seekg (0L, ios::beg);

char quelle[];
char ziel[];
AnsiString zS;
if(strlen(ziel) <= 3)
  /* AnsiString */zS = ziel + ExtractFileName(AnsiString(quelle));
else
    zS = AnsiString(ziel) + "\\"+ ExtractFileName(AnsiString(quelle));

ifstream in(quelle,ios_base::in | ios_base::binary);
in.clear();
in.seekg (0L, ios::beg);
ofstream out(zS.c_str(),ios_base::out | ios_base::binary);
out << in.rdbuf();
out.close();
in.close();

Ergebnis nach wie vor, negativ!

Sorry ich habe zS doppelt deklariert gehabt! 27.06.09

Der Quelldateiname ist "quelle[]".
Also volständig siet so aus:

void __fastcall TForm1::OffeneDateiKopieren(char quelle[], char ziel[])
{
	AnsiString zS;
	if(strlen(ziel) <= 3)
		zS = ziel + ExtractFileName(AnsiString(quelle));
	else
		zS = AnsiString(ziel) + "\\"+ ExtractFileName(AnsiString(quelle));

	ifstream in(quelle,ios_base::in | ios_base::binary);
	in.clear();
	in.seekg (0L, ios::beg);
	ofstream out(zS.c_str(),ios_base::out | ios_base::binary);
	out << in.rdbuf();
	out.close();
	in.close();
}
//---------------------------------------------------------------------------

Aufruf:

OffeneDateiKopieren(Edit1->Text.c_str(), Edit2->Text.c_str());

Wo Edit1-Text voller qualfizierter Pfad der Quelldatei vom OpenDialog und
Edit2->Text der Pfad des Ordners von BrowseForFolder ist.

Bei dem Kopieren wird die Zieldatei richtig angelegt, nur inhalt bleibt dann Null Bytes (wenn die Queldatei geöffnet ist).

OffeneDateiKopieren(char *quelle, char *ziel)

oder

OffeneDateiKopieren(String quelle, String ziel)

oder besser fürs Kopieren gleich

CopyFile
oder CopyFileTo

Danke für deine Vorschläge.
Der Sinn und Zweck Benutzung der Kalsse fstream ist um die geöffnete Dateien zu kopieren zu können. Natürlich kann man auch so schreiben wie Du vorschlägst, aber Ergebnis bleibt unverändert.
Methoden CopyFile() und CopyFileTo() kopiert keine geöffnete (.pst) oder (.gdb) Dateien, viele andere -> Word ,Excel, PDF, .... schon.

Darum das Problem bleibt nach wie vor offen.

fstream in, out;
in.open(datei1,ios::in|ios::binary);
out.open(datei2,ios::out|ios::binary);
unsigned char c;

while(1)
{
   in >> c;
   if(in.eof())
      break;
   out.put(c);
}
in.close();
out.close();

greetz KN4CK3R

leider das Ergebnis auch mit diesem Versuch ist negativ.
Danke trotzdem!

std::stream dürfte dir da kaum weiterhelfen. Denn die Sperre wird nicht von einer Funktion der C++ Schicht verursacht, sondern von Windows. Du wirst diese Sperre, wenn überhaupt möglich, auch nur mit Windows-Mitteln umgehen können.

bis bald
akari

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

Dieses Posting wurde automatisch erzeugt.

kann mir jemànd helfen?

#include <string>
#include <vector>

#include <windows.h>

using namespace std;

void copy_file( const string& source, const string& target )
{
	HANDLE hSource = ::CreateFile( source.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_BACKUP_SEMANTICS, NULL );
	if( INVALID_HANDLE_VALUE == hSource )
	{
		return;
	}
	HANDLE hTarget = ::CreateFile( target.c_str(), GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
	if( INVALID_HANDLE_VALUE == hTarget )
	{
		::CloseHandle( hSource );
		return;
	}
	const unsigned int BufferSize = 256 * 1024;
	vector<char> Buffer( BufferSize );
	DWORD dwReadCount = 0;
	DWORD dwWriteCount= 0;
	if( ::ReadFile( hSource, &Buffer[0], BufferSize, &dwReadCount, NULL ) )
	{
		while( dwReadCount != 0 )
		{
			::WriteFile( hTarget, &Buffer[0], dwReadCount, &dwWriteCount, NULL );
			::ReadFile( hSource, &Buffer[0], BufferSize, &dwReadCount, NULL );
		}
	}
	::CloseHandle( hSource );
	::CloseHandle( hTarget );
}

...weniger aufwändig wäre sich einfach durch ein Kommandozeilen-Tool die ShadowCopy-Arbeit abnehmen zu lassen (z.B. hobocopy)

Das stellt zwar sicher dass keiner die Datei ändern kann während du kopierst, aber dafür kann man auch keine Dateien kopieren, die irgendein Programm zum Schreiben offen hat.

Wenn dann müsste man zumindest FILE_SHARE_READ | FILE_SHARE_WRITE (und evtl. noch FILE_SHARE_DELETE) angeben - nur dann kann man eben nichtmehr sicher sein eine "unbeschädigte" Kopie des Files zu bekommen.

greetz