Shortening series of push_back's on a byte-vector

Question

In my code, I want to use a byte-vector to store some data in memory. The problem is, that my current approach uses many lines of code:

std::vector<byte> v;
v.push_back(0x13);
v.push_back(0x37);
v.push_back(0xf0);
v.push_back(0x0d);

How can I shorten this procedure so that I have for example something like:

std::vector<byte> v(4) = "\x13\x37\xf0\x0d"; // example code - not working

?

Answer 1

copy_n("\x13\x37\xf0\x0d",4,std::back_inserter(v));

Answer 2

The boost assignment library provides many useful helpers for this sort of thing. The first example in the docs is

#include <vector>
#include <boost/assign/std/vector.hpp> // for 'operator+=()'
#include <boost/assert.hpp>; 
using namespace std;
using namespace boost::assign; // bring 'operator+=()' into scope

vector<int> v; 
v += 1,2,3,4,5,6,7,8,9;

Answer 3

I have found one solution for my own now:

std::vector<byte> pattern(5);
memcpy(&pattern[0], "\xDE\xAD\xBE\xEF", 4);

Now the question transforms to: Which of the answers is the cleanest and "best" one?

Answer 4

Some newer compilers support brace initialization of vectors:

vector<byte> v = {0x13, 0x37, 0xf0, 0x0d};

If you compiler doesn't support that construct you can do what you were trying to do like this:

const byte initData[] = {0x13, 0x37, 0xf0, 0x0d};
std::vector<byte> v(initData, initData + sizeof(initData));

This just copies from const readonly memory into your live vector.

Answer 5

This solution gets the string length from the literal itself, meaning you don't need extra 5s and 4s lying around:

const unsigned char src[] = "\xDE\xAD\xBE\xEF";
std::vector<unsigned char> pattern(src, src+sizeof(src));

Note that a null terminator (extra zero byte) is added to the array; sizeof(src) is 5 because it's a string literal. The null terminator can be discarded by saying sizeof(src)-1, or by doing this:

const unsigned char src[] = {0xDE, 0xAD, 0xBE, 0xEF};

Answer 6

As an alternative to boost assignment (see my other answer), simply define a helper

inline std::vector<byte>& operator<<(std::vector<byte>& v,byte x)
  {v.push_back(x);return v;}

then you can write

 std::vector<byte> v;
 v << 0x13 << 0x37 << 0xf0 << 0x0d;

Obviously you could template the helper on the container and/or contained type to make this more general (but then eventually you'd just be reimplementing boost assignment anyway).