Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Converting (void*) to std::vector<unsigned char>

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?

like image 218
Mike Douglas Avatar asked Apr 07 '09 10:04

Mike Douglas


4 Answers

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.

like image 127
dirkgently Avatar answered Nov 03 '22 18:11

dirkgently


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.]

like image 21
j_random_hacker Avatar answered Nov 03 '22 18:11

j_random_hacker


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()".

like image 3
teeks99 Avatar answered Nov 03 '22 19:11

teeks99


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.

like image 2
Cătălin Pitiș Avatar answered Nov 03 '22 17:11

Cătălin Pitiș