Initialisation of static vector

Question

I wonder if there is the "nicer" way of initialising a static vector than below?

class Foo
{
    static std::vector<int> MyVector;
    Foo()
    {
        if (MyVector.empty())
        {
            MyVector.push_back(4);
            MyVector.push_back(17);
            MyVector.push_back(20);
        }
    }
}

It's an example code :)

The values in push_back() are declared independly; not in array or something.

Edit: if it isn't possible, tell me that also :)

Answer 1

Typically, I have a class for constructing containers that I use (like this one from boost), such that you can do:

const list<int> primes = list_of(2)(3)(5)(7)(11);

That way, you can make the static const as well, to avoid accidental modifications.

For a static, you could define this in the .cc file:

// Foo.h

class Foo {
  static const vector<int> something;
}

// Foo.cc

const vector<int> Foo::something = list_of(3)(5);

In C++Ox, we'll have a language mechanism to do this, using initializer lists, so you could just do:

const vector<int> primes({2, 3, 5, 7, 11});

See here.

Answer 2

In C++03, the easiest way was to use a factory function:

std::vector<int> MakeVector()
{
    std::vector v;
    v.push_back(4);
    v.push_back(17);
    v.push_back(20);
    return v;
}

std::vector Foo::MyVector = MakeVector(); // can be const if you like

"Return value optimisation" should mean that the array is filled in place, and not copied, if that is a concern. Alternatively, you could initialise from an array:

int a[] = {4,17,20};
std::vector Foo::MyVector(a, a + (sizeof a / sizeof a[0]));

If you don't mind using a non-standard library, you can use Boost.Assignment:

#include <boost/assign/list_of.hpp>

std::vector Foo::MyVector = boost::list_of(4,17,20);

In C++11 or later, you can use brace-initialisation:

std::vector Foo::MyVector = {4,17,20};

Answer 3

With C++11:

std::vector<int> Foo::MyVector = {4, 17, 20};

Answer 4

You could try this one:

int arr[] = { 1,2,3,4,5,6,7,8,9 };
MyVector.insert(MyVector.begin(), arr, &arr[sizeof(arr)/ sizeof(*arr)]);

But it's probably only worth when you have a really long vector, and it doesn't look much nicer, either. However, you get rid of the repeated push_back() calls. Of course, if your values are "not in an array" you'd have to put them into there first, but you'd be able to do that statically (or at least references/pointers), depending on the context.

Answer 5

How about initializing using a static object. In its constuctor it could call a static function in the object to do the initalization.

Answer 6

with boost you can use the +=() operator defined in the boost::assign namespace.

#include <boost/assign.hpp>

using namespace boost::assign;

int main()
{
    static std::vector<int> MyVector;
    MyVector += 4,17,20;
    return 0;
}

or with static initialization:

#include <boost/assign.hpp>

using namespace boost::assign;

static std::vector<int> myVector = list_of(4)(17)(2);

int main()
{
    return 0;
}

or even better, if your compiler supports C++ 11, use initialization lists.