分割文件並將數據傳遞給其他類

Question

在我當前的項目中，我有很多不同格式的二進制文件。其中有幾個作爲簡單的檔案，因此我試圖想出一個很好的方法將提取的文件數據傳遞給其他類。

這是我目前的做法的一個簡單的例子：

class Archive { 
    private: 
     std::istream &fs; 
     void Read(); 
    public: 
     Archive(std::istream &fs); // Calls Read() automatically 
     ~Archive(); 
     const char* Get(int archiveIndex); 
     size_t GetSize(int archiveIndex); 
}; 

class FileFormat { 
    private: 
     std::istream &fs; 
     void Read(); 
    public: 
     FileFormat(std::istream &fs); // Calls Read() automatically 
     ~FileFormat(); 
}; 

存檔類基本分析存檔和讀取存儲的文件到char指針。 爲了從Archive加載第FileFormat文件，我將目前使用下面的代碼：（請注意，在存檔一些文件可能有其他的檔案，但不同的格式）

std::ifstream fs("somearchive.arc", std::ios::binary); 
Archive arc(fs); 
std::istringstream ss(std::string(arc.Get(0), arc.GetSize(0)), std::ios::binary); 
FileFormat ff(ss); 

讀取二進制數據時，我使用了一個BinaryReader類的功能，如這些：

BinaryReader::BinaryReader(std::istream &fs) : fs(fs) { 
} 

char* BinaryReader::ReadBytes(unsigned int n) { 
    char* buffer = new char[n]; 
    fs.read(buffer, n); 
    return buffer; 
} 

unsigned int BinaryReader::ReadUInt32() { 
    unsigned int buffer; 
    fs.read((char*)&buffer, sizeof(unsigned int)); 
    return buffer; 
} 

我喜歡這種方法的簡單，但我目前有很多內存兒的掙扎rors和SIGSEGVs，我擔心這是因爲這種方法。一個例子是當我在一個循環中重複創建和讀取一個檔案時。它適用於大量迭代，但過了一段時間，它開始讀取垃圾數據。

我對你的問題是，如果這種方法是可行的（在這種情況下，我問我做錯了什麼），如果不是，有什麼更好的方法嗎？

Answer 1

在OP中的代碼缺陷是：

1. 您分配堆內存，並從你的函數中返回一個指針。這可能會導致內存泄漏。你沒有泄漏問題（現在），但是在設計你的課程時你必須記住這些東西。
2. 處理Archive和FileFormat類時，用戶始終必須考慮到存檔的內部結構。基本上它會影響數據封裝的想法。

當你的類框架的用戶創建一個存檔對象時，他只是得到一個方法來提取一些原始數據的指針。然後用戶必須將這些原始數據傳遞給完全獨立的類。你也將有不止一種FileFormat。即使不需要注意處理這種系統的泄漏堆分配，也會非常容易出錯。

讓我們嘗試將一些面向對象的原則應用於任務。您的存檔對象是不同格式文件的容器。因此，存檔的等價得到（）一般應返回文件對象，而不是一個指向原始數據：

//We gonna need a way to store file type in your archive index 
enum TFileType { BYTE_FILE, UINT32_FILE, /*...*/ } 

class BaseFile { 
public: 
virtual TFileType GetFileType() const = 0; 
/* Your abstract interface here */ 
}; 

class ByteFile : public BaseFile { 
public: 
ByteFile(istream &fs); 
virtual ~ByteFile(); 
virtual TFileType GetFileType() const 
{ return BYTE_FILE; } 
unsigned char GetByte(size_t index); 
protected: 
/* implementation of data storage and reading procedures */ 
}; 

class UInt32File : public BaseFile { 
public: 
UInt32File(istream &fs); 
virtual ~UInt32File(); 
virtual TFileType GetFileType() const 
{ return UINT32_FILE; } 
uint32_t GetUInt32(size_t index); 
protected: 
/* implementation of data storage and reading procedures */ 
}; 


class Archive { 
public: 
Archive(const char* filename); 
~Archive(); 
BaseFile* Get(int archiveIndex); 
{ return (m_Files.at(archiveIndex)); } 
/* ... */ 
protected: 
vector<BaseFile*> m_Files; 
} 

Archive::Archive(const char* filename) 
{ 
    ifstream fs(filename); 

    //Here we need to: 
    //1. Read archive index 
    //2. For each file in index do something like: 
    switch(CurrentFileType) { 
    case BYTE_FILE: 
      m_Files.push_back(new ByteFile(fs)); 
      break; 
    case UINT32_FILE: 
      m_Files.push_back(new UInt32File(fs)); 
      break; 
    //..... 
    } 
} 

Archive::~Archive() 
{ 
    for(size_t i = 0; i < m_Files.size(); ++i) 
     delete m_Files[i]; 
} 

int main(int argc, char** argv) 
{ 
    Archive arch("somearchive.arc"); 
    BaseFile* pbf; 
    ByteFile* pByteFile; 

    pbf = arch.Get(0); 

    //Here we can use GetFileType() or typeid to make a proper cast 
    //An example of former: 

    switch (pbf.GetFileType()) { 
    case BYTE_FILE: 
     pByteFile = dynamic_cast<ByteFile*>(pbf); 
     ASSERT(pByteFile != 0); 
     //Working with byte data 
     break; 
    /*...*/ 
    } 

    //alternatively you may omit GetFileType() and rely solely on C++ 
    //typeid-related stuff 

} 

那只是可以簡化您的應用程序檔案的使用類的一個總體思路。

請記住，良好的類設計可以幫助您防止內存泄漏，代碼澄清等。但是，無論你有什麼類，你仍然會處理二進制數據存儲問題。例如，如果您的存檔存儲了64字節的字節數據和8個uint32，並且您以某種方式讀取了65個字節而不是64個字節，則讀取以下整數將會給您帶來垃圾。您可能還會遇到對齊和排序問題（如果您的應用程序應該在多個平臺上運行，則後者非常重要）。儘管如此，良好的課堂設計可能會幫助您制定更好的代碼來解決這些問題。

Answer 2

這是要求麻煩從你的函數傳遞一個指針，並希望用戶知道要刪除它，除非函數名稱很明顯這樣做，例如，一個以單詞create開頭的函數。

所以

Foo * createFoo(); 

很可能是創建一個對象，用戶必須刪除的功能。

對於初學者來說，一個優選的解決方案是返回std::vector<char>或允許用戶將std::vector<char> &傳遞給函數，並且將字節寫入其中，並在必要時設置其大小。 （如果在可以重複使用相同緩衝區的地方進行多次讀取，這會更有效）。

你還應該學習const正確性。

至於你的「一段時間後它填滿垃圾」，你在哪裏檢查文件的結尾？