7

So normaly I do stuff like:

    std::ifstream stream;
    int buff_length = 8192;
    boost::shared_array<char> buffer( new char[buff_length]);
    stream.open( path.string().c_str(), std::ios_base::binary);
    while (stream)
    {
            stream.read(buffer.get(), buff_length);
            //boost::asio::write(*socket, boost::asio::buffer(buffer.get(), stream.gcount()));
    }
    stream.close();

I wonder how to read into unsigned char buffer ( boost::shared_array<unsigned char> buffer( new unsigned char[buff_length]);)

myWallJSON
  • 9,110
  • 22
  • 78
  • 149

1 Answers1

14

In a simplest form:

std::vector<unsigned char> vec(
      std::istreambuf_iterator<char>(std::cin)
    , std::istreambuf_iterator<char>()
    );

Replace std::cin with your actual stream.

The above is likely to do more than one memory allocation (for files larger than a very few bytes) because std::istreambuf_iterator<> is an input-iterator, not a random-access or a forward iterator, so the length of the file can't be measured by subtracting iterators like end - begin or calling std::distance(begin, end). It can be reduced to one memory allocation if the vector is created first empty, then std::vector<>::reserve() is called to allocate memory for the file length and finally range insert is called vec.insert(vec.end(), beg, end) with beg and end being std::istreambuf_iterator<> as above to read the entire file.

If the file size is more then a few kilo-bytes it may be most efficient to map it into the process memory to avoid copying memory from the kernel to user-space.

The reason std::istreambuf_iterator<char> is used is because the implementation uses std::char_traits<> which normally has specializations only for char and wchar_t. Regardless, the C and C++ standards require all char types to have the same binary layout with no padding bits, so conversions between char, unsigned char and signed char (which are all distinct types, unlike signed int and int being the same type) preserve bit patterns and thus are safe.

[basic.fundamental/1]

Plain char, signed char, and unsigned char are three distinct types, collectively called narrow character types. A char, a signed char, and an unsigned char occupy the same amount of storage and have the same alignment requirements; that is, they have the same object representation... For narrow character types, all bits of the object representation participate in the value representation... For unsigned narrow character types, each possible bit pattern of the value representation represents a distinct number. These requirements do not hold for other types. In any particular implementation, a plain char object can take on either the same values as a signed char or an unsigned char; which one is implementation-defined. For each value i of type unsigned char in the range 0 to 255 inclusive, there exists a value j of type char such that the result of an integral conversion from i to char is j, and the result of an integral conversion from j to unsigned char is i.

Maxim Egorushkin
  • 131,725
  • 17
  • 180
  • 271
  • The standards don't require that `char c = -1; unsigned char u = c;` results in `c` and `u` having the same bit pattern. In theory signed chars could use 1's complement or sign-magnitude. – M.M Feb 09 '18 at 01:53
  • *Non-negative* values of signed char must have the same representation as the corresponding unsigned char. But in one's complement for example, `char c = -1;` has bit pattern 11111110 whereas `unsigned char u = c;` has bit pattern 11111111. This is mostly academic as I'm not aware of any C++ implementation ever that didn't use 2's complement – M.M Feb 09 '18 at 02:07
  • @M.M Added the quote for you. – Maxim Egorushkin Feb 09 '18 at 02:34
  • They clearly don't have the same value representation ; the value `-1` does have a value representation in `signed char` but not in `unsigned char` – M.M Feb 09 '18 at 02:41
  • @M.M Added a longer quote for you. _Value representation_ is different (the sign bit). _Object representation_ is the same. – Maxim Egorushkin Feb 09 '18 at 02:42
  • @MaximEgorushkin that text (added in C++14) appears to require that *if plain char is signed* it must follow 2's complement. But firstly, there is no equivalent requirement in C as you claim, and secondly, it still permits `signed char c = -1;` to use one's complement (i.e. get bit pattern 11111110) and have plain char be unsigned – M.M Feb 09 '18 at 03:38