將文件的一部分讀入std :: vector的有效方法<char>？

Question

指的這個問題：Efficient way of reading a file into an std::vector<char>? 我需要做的事情followig功能：

void readFromFile(std::vector< unsigned char >& buffer, 
        string filename, 
        size_t offset, size_t count); 

所以從偏移從文件中讀取的功能，以抵消+算入載體;

void readFromFile(std::vector< unsigned char >& buffer, 
        string filename, 
        size_t offset, size_t count) 
{ 
    // get file size and reallocate the buffer 
    size_t fsize = filesize(filename); 
    buffer.reserve(buffer.size() + size); 

    // open the file 
    ifstream file(filename); 

    // first way 
    file.seekg(offset); 
    file.read(????) 

    // second way 
    istreambuf_iterator< unsigned char > from(file); 
    istreambuf_iterator< unsigned char > eof; 

    advance(from, offset); 
    copy(from, eof, back_inserter(buffer); 
} 

在第一種方法中，我不知道如何一次讀取文件。在第二種方式中，讀操作很慢，因爲我每字節讀取一個字節。

是更好的選擇嗎？

編輯

由於@Ben福格特

我寫了這兩個簡單的功能：

inline std::streamsize filesize(const std::string& filename) 
{ 
    std::ifstream in(filename, std::ifstream::in | std::ifstream::binary); 
    if (!in) throw std::invalid_argument 
    { 
     "filesize error: invalid filename" 
    }; 

    in.seekg(0, std::ifstream::end); 
    return in.tellg(); 

    // here the file is closed. so no need to restore the get pointer 
} 

inline std::streamsize filesize(std::ifstream& file) 
{ 
    file.seekg(0, std::ifstream::end); 
    const auto size = file.tellg(); 
    file.seekg(0);  // restore the get pointer 
    return size; 
} 

template< typename RAIter > 
inline void read_file(std::istream& file, 
         RAIter first, RAIter last, 
         std::streamsize offset = 0 
         ) 
{ 
    const auto size = last - first; 
    file.seekg(offset, std::ifstream::beg); 
    file.read(reinterpret_cast< char* >(&*first), size); 
} 

template<> 
inline void read_file(std::istream& file, 
         unsigned char* first, unsigned char* last, 
         std::streamsize offset /*= 0 no default argument in template spacalization. */ 
     ) 
{ 
    const auto size = last - first; 
    file.seekg(offset, std::ifstream::beg); 
    file.read(reinterpret_cast< char* >(first), size); 
} 

所以函數現在變得容易：

vector< unsigned char > buffer; 
// do something with buffer 

const string filename{ "blabla" }; 

const auto size = filesize(filename); 

// resize the buffer 
auto const OLD_LEN = buffer.size(); 
buffer.resize(OLD_LEN + size); 

size_t startOffset = 0;  // from where to star reading from file 
size_t cont = size;   // how manny bytes read from file 

// read filename from startOffset to startOffset + count, appendeing in buffer 
ifstream file(filename); 
read_file(file, 
      buffer.data() + OLD_LEN, 
      buffer.data() + OLD_LEN + count, 
      startOffset 
      ); 

Answer 1

auto old_end = buffer.size(); 
buffer.resize(old_end + blocksize); 

//... 

file.read(&buffer[old_end], blocksize); 
auto actual_size = file.gcount; 
if (actual_size < blocksize) buffer.resize(old_end + actual_size); 

Answer 2

這裏有一個快速高效的獲取角色的方式來自文件的光線。

char * arr; 
int len; 
// Function that opens a file, needing the file name 
void openFile(const char* fileName) 
{ 
ifstream file(fileName, ios::in); 

if(!file.is_open()) return; 

file.seekg(0, file.end); 
    // Get the length of the file 
len = file.tellg(); 
file.seekg(0, file.beg); 

arr = new char[len]; 
file.read(arr, len); 

file.close(); 
} 

之後，你可以將字符數組推到一個向量。