将4字节整数放入向量的前4个char元素中

Question

I have a vector<unsigned char> and want to put a 4 byte Integer into the first 4 elements. Is there a simpler way in C++ than masking like this:

myVector.at(0) = myInt & 0x000000FF;
myVector.at(1) = myInt & 0x0000FF00;
myVector.at(2) = myInt & 0x00FF0000;
myVector.at(3) = myInt & 0xFF000000;

Answer 1

A std::vector is guaranteed to be stored as one contiguous block of data ^(‡) . Hence it is possible to treat a std::vector<unsigned char> in basically the same way as an unsigned char buffer. This means, you can memcpy your data into the vector, provided you are sure it is large enough:

#include <vector>
#include <cstring>
#include <cstdint>

int main()
{
  std::int32_t k = 1294323;
  std::vector<unsigned char> charvec;

  if (charvec.size() < sizeof(k))
    charvec.resize(sizeof(k));

  std::memcpy(charvec.data(), &k, sizeof(k));

  return 0;
}

Note: The data() function of std::vector returns a void* to the internal buffer of the vector. It is available in C++11 – in earlier versions it is possible to use the address of the first element of the vector, &charvec[0] , instead.

Of course this is a very unusual way of using a std::vector , and (due to the necessary resize() ) slightly dangerous. I trust you have good reasons for wanting to do it.

---

^(‡) Or, as the Standard puts it:

(§23.3.6.1/1) [...] The elements of a vector are stored contiguously, meaning that if v is a vector<T, Allocator> where T is some type other than bool , then it obeys the identity

  &v[n] == &v[0] + n for all 0 <= n < v.size(). 

Answer 2

You have to binary shift your values for this to work:

myVector.at(0) = (myInt & 0xFF);
myVector.at(1) = (myInt >> 8) & 0xFF;
myVector.at(2) = (myInt >> 16) & 0xFF;
myVector.at(3) = (myInt >> 24) & 0xFF;

Your code is wrong:

int myInt = 0x12345678;
myVector.at(0) = myInt & 0x000000FF; // puts 0x78 
myVector.at(1) = myInt & 0x0000FF00; // tries to put 0x5600 but puts 0x00
myVector.at(2) = myInt & 0x00FF0000; // tries to put 0x340000 but puts 0x00
myVector.at(3) = myInt & 0xFF000000; // tries to put 0x12000000 but puts 0x00

Answer 3

you can do something similar to the following:

#include <vector>
#include <cstdio>

void
insert_int(std::vector<unsigned char>* container, int integer)
{
    char* chars = reinterpret_cast<char*>(&integer);
    container->insert(container->end(), chars, chars+sizeof(int));
}

int main(void)
{
    std::vector<unsigned char> test_vector;
    int test_int = 0x01020304;

    insert_int(&test_vector, test_int);

    return 0;
}

just remember to account for endieness. My machine prints the int in reverse order. 4,3,2,1

Answer 4

Your solution is incorrect as you currently have it. Something like:

std::vector<unsigned char> v(sizeof(int));
int myInt = 0x12345678;

for(unsigned i = 0; i < sizeof(int); ++i) {
    v[i] = myInt & 0xFF;
    myInt >>= 8;
}

Should work. It's also more portable (doesn't assume int is 4 bytes).

Answer 5

Here is the most compact way:

myVector.at(0) = *((char*)&myInt+0);
myVector.at(1) = *((char*)&myInt+1);
myVector.at(2) = *((char*)&myInt+2);
myVector.at(3) = *((char*)&myInt+3);