Using streamsize for the size of an array is not working

Question

I somehow can't get it right to use std::streamsize to create an array.

// determine file size
file.ignore(std::numeric_limits<std::streamsize>::max());
std::streamsize length = file.gcount();
file.clear();
file.seekg(0, std::ios_base::beg);

// read data into buffer
std::array<char, length> buffer;
file.read(buffer.data(), length);

// copy the game into memory
std::copy(buffer.begin(), buffer.end(), memory.begin() + 0x200);

Error (translated from German)

The expression must be a constant value

Does anyone have any ideas on solving this problem? Any help is appreciated!

2

Don't use an array, use a vector. – Mar 01 '17 at 17:24

score 3 · Accepted Answer · edited May 23 '17 at 12:17

3

You can only pass constexpr values as template parameters, which clearly isn't possible in this case given that the size is known only at runtime.

The underlying problem here is that you are using the wrong tool for the job: std::array encapsulates a statically allocated array, whose size must be known at compile time. If you need dynamic allocation, use std::vector.

For a more in-depth comparison between std::vector and std::array see std::vector versus std::array in C++

edited May 23 '17 at 12:17

Community

1
1

answered Mar 01 '17 at 17:26

Matteo Italia

123,740
17
206
299

Oh ok then it makes sense not being able to use std::array, thanks :) – Urasam Mar 01 '17 at 17:39

Remy Lebeau · Answer 2 · 2017-03-02T09:10:39.840

You don't need to use file.ignore(), you can use file.seekg() to get the file size:

// determine file size
file.seekg(0, std::ios_base::end);
std::streamsize length = file.tellg();
file.seekg(0, std::ios_base::beg);

Or, just use a platform-specific API function, like GetFileSize() on Windows or stat() on Linux (or equivilents).

That said, std::array is a fixed-length array, you have to specify its size at compile-time. For dynamic allocations at runtime, use std::vector instead:

// read data into buffer
std::vector<char> buffer;
buffer.resize(length);
file.read(buffer.data(), length);

Or, simply read the file into the target memory directly and avoid the temp buffer altogether:

// read game file into memory
file.read(memory.begin() + 0x200, length);

Or, even skip retrieving the file size at all:

// read game file into memory
std::copy(
    std::istreambuf_iterator<char>(file),
    std::istreambuf_iterator<char>(),
    memory.begin() + 0x200
);

In any case, be sure to watch out for memory overflows! Make sure memory is large enough to hold the entire file data.

Thanks for the different approaches! Is there a big difference between the last two? Is one better than the other (e.g. in performance) — Urasam, Mar 02 '17 at 08:38
I imagine doing a larger block read will have better performance than doing single-byte reads. But use a profiler to make sure. — Remy Lebeau, Mar 02 '17 at 09:12

Using streamsize for the size of an array is not working

2 Answers2