Question

参考此问题：Efficient way of reading a file into an std::vector<char>? 我需要一个执行以下操作的函数：

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

所以函数从offset到offset + count读入vector;

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 Voigt

我写了两个简单的函数：

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();
}

之后你可以将char数组推入向量中。

将文件的一部分读入std :: vector <char>？</char>的有效方法

2 个答案: