c++ - size_type - Converting(void*) to std::vector<unsigned char>




vector size_type (4)

The only time this would be legitimate is if you had already created a vector, and simply wanted to get it back.

void SomeFunc(void* input);

main() {
  std::vector< unsigned char > v;
  SomeFunc((void*) &v);
}

SomeFunc(void* input) {
  // Now, you could cast that void* into a vector
  std::vector< unsigned char >* v_ = (vector<unsigned char>*)input
}

I haven't actually tried to see if this will run, but that's the spirit of it. That said, if you are making this from scratch, you are definitely doing it wrong. This is really bad. The only time this could be even remotely understandable is if you are forced to implement the already defined "SomeFunc()".

I have a (void*) buffer that I need to convert to std::vector<unsigned char> before I can pass it on. Unfortunately, my C++ casting skills a little weak. Any suggestions?


You can't simply cast a void* to a std::vector<unsigned char> because the memory layout of the latter includes other objects, such as the size and the number of bytes currently allocated.

Assuming the buffer is pointed to by buf and its length is n:

vector<unsigned char> vuc(static_cast<char*>(buf), static_cast<char*>(buf) + n);

will create a copy of the buffer that you can safely use.

[EDIT: Added static_cast<char*>, which is needed for pointer arithmetic.]


You will need the length of the buffer. Once you do, we can do this:

unsigned char *charBuf = (unsigned char*)voidBuf;
/* create a vector by copying out the contents of charBuf */
std::vector<unsigned char> v(charBuf, charBuf + len);

Okay, the comment got me started on why I did not use reinterpret_cast:

  • In C++, the C-style cast is a convenience function -- it asks the compiler to choose the safest and most portable form of conversion over the set of available cast operators.

  • The reinterpret_cast is implementation defined and should always be the last thing on your mind (and used when you are necessarily doing a non-portable thing knowingly).

  • The conversion between (unsigned doesn't change the type) char * and void * is portable (you could actually use static_cast if you are really picky).

The problem with the C-style cast is: the added flexibility can cause heartaches when the pointer type changes.

Note: I agree with the general convention of not casting as much as possible. However, without any source provided, this is the best I could do.


using std::vector class for an already allocated buffer is not a solution. A std::vector object manages the memory and deallocates it at destruction time.

A complicated solution might be to write your own allocator, that uses an already allocated buffer, but you have to be very careful on several scenarios, like vector resizing, etc.

If you have that void* buffer bound through some C API functions, then you can forget about conversion to std::vector.

If you need only a copy of that buffer, it can be done like this:

std::vector< unsigned char> cpy( 
    (unsigned char*)buffer, (unsigned char*)buffer + bufferSize);

where bufferSize is the size in chars of the copied buffer.





types