Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » FileStream EOF vor Dateiende

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
02.09.2008, 02:05 Uhr
~FunMaker
Gast


ich habe folgendes Problem: Ich habe eine Datei die mit (mir bekannten) Daten gefüllt ist
----------------
Nun lese ich die Daten aus, das funktioniert auch soweit ganz gut bis ich auf irgendein Sonderzeichen stoße - dann bricht das Lesen der Datei ab so als wäre das Zeichen eine Art EOF Zeichen.

- FAString besteht immer aus 4Bytes Integer (Länge des Strings) und dem String

Hier das Format:

4 Byte ----- Länge von Chararray:
V Byte ----- Chararray

1 Byte -----byte

4 Byte ------ integer
4 Byte ------ integer

4 Byte ------ integer
4 Byte ------ integer

4 Byte ------ integer
4 Byte ------ integer (größe der PNG Datei)
X Byte ------ PNG-Datei innerhalb dieser Datei


Code:

CAIPReader::CAIPReader(std::string FileName)
{
    this->CFileIO::CFileIO(FileName);

    std::string AIP_String = ReadFAString(); //OK
    byte Type = ReadByte(); //OK
    int Height = ReadInteger(); //OK
    int Width = ReadInteger(); //OK
    int SingleHeight = ReadInteger(); //OK
    int SingleWidth = ReadInteger(); //OK
    int FrameCount = ReadInteger(); //OK

    //Hier PNG Load
    //>>>>>>>>>>>>>

    int PNGSize = ReadInteger(); //OK

    byte *PNGFile;
    PNGFile = new byte[PNGSize];
    ReadFile(PNGFile,PNGSize); //NICHT OK, anstatt 1454 Bytes liest er nur 5
    //<<<<<<<<<<<<<
}

CFileIO::CFileIO(std::string &FileName)
{
    Stream = new std::fstream();
    Stream->open(FileName.c_str(),std::ios_base::in || std::ios_base::out || std::ios_base::binary);
}

byte CFileIO::ReadByte()
{
    char memblock;
    Stream->read(&memblock,1);
    return (byte) memblock;
}

int    CFileIO::ReadInteger()
{
    char memblock[4];
    Stream->read(memblock,4);
    int Output;
    CopyMemory(&Output, memblock,4);
    return Output;
}

std::string CFileIO::ReadFAString()
{
    //length
    char memblock[4];
    Stream->read(memblock,4);
    int Count;
    CopyMemory(&Count,memblock,4);

    //String
    char *Str;
    Str = new char[Count];
    Stream->read(Str,Count);
    std::string Output = "";

    for (int i = 0; i < Count ; i++)
    {
        Output = Output + Str[i];
    }

    delete[] Str;
    return Output;
}

void CFileIO::ReadFile(void* Buffer, int Size)
{

    int bla = Stream->readsome((char*) Buffer,Size);
      //bestimmtes Zeichen lässt Datei "Enden" - dadurch nur Mist und eof und sonstwas
    if (bla < Size) Global->Error("Hier zuwenig gelesen");

}




und hier die Datei die ich lesen will (HEX da ganz viele Sonderzeichen nicht als Text im Forum benutzt werden können)


Code:

00000000h: 04 00 00 00 54 65 73 74 01 80 00 00 00 80 00 00
00000010h: 00 40 00 00 00 40 00 00 00 04 00 00 00 AE 05 00
00000020h: DB C7 BD B9 6A 00 89 50 4E 47 0D 0A 1A 0A 00 00
00000030h: 00 0D 49 48 44 52 00 00 00 80 00 00 00 80 08 06
00000040h: 00 00 00 C3 3E 61 CB 00 00 05 75 49 44 41 54 78
....




das es ein Zeichen ist was das ganze auslößt ist nur eine starke Vermutung da wenn ich das Zeichen rauslösche er mehr bytes liest
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
02.09.2008, 22:43 Uhr
xXx
Devil



C++:
const std::string CFileIO::ReadFAString()
{
    // length
    Stream->read(reinterpret_cast<char*>(&Count), sizeof(int));
  
    //String
    char* ptr_buffer(new char[Count + 1]);
    Stream->read(ptr_buffer, Count);
    ptr_buffer[Count] = 0;

    const std::string copy(ptr_buffer);
    
    delete[] ptr_buffer;

    return copy;
}
so wäre doch z.B. diese Funktion sinvoller, oder?


C++:
CFileIO::CFileIO(std::string const & FileName)
{
    Stream = new std::fstream();
    Stream->open(FileName.c_str(), std::ios_base::in | std::ios_base::out | std::ios_base::binary);
}
so auch das besser

und:

C++:
const int CFileIO::ReadInteger()
{
    int temp(0);
    Stream->read(reinterpret_cast<char*>(&temp), sizeof(int));
    return temp;
}


konsequent daraus folgern:

C++:
template <typename data_type>
const data_type CFileIO::Read()
{
    data_type tmp;
    Stream->read(reinterpret_cast<char*>(&tmp), sizeof(data_type));
    return tmp;
}

template <>
const std::string CFileIO::Read()
{
     // length
    Stream->read(reinterpret_cast<char*>(&Count), sizeof(int));
  
    //String
    char* ptr_buffer(new char[Count + 1]);
    Stream->read(ptr_buffer, Count);
    ptr_buffer[Count] = 0;

    const std::string copy(ptr_buffer);
    
    delete[] ptr_buffer;

    return copy;
}
Dann kannst du einfach aufrufen:

C++:
CFileIO file;
int width = file.Read<int>();
std::string name = file.Read<std::string>();
und fertig

Was mir aber noch nicht klar ist ... warum erzeugst du deinen Filestream aufm Heap? Stack is doch vollkommen i.o.?

Dieser Post wurde am 02.09.2008 um 22:44 Uhr von xXx editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: