Hi all, personally I'd love to be able to do something like this:
vector<int> v;
v.assign(1, 2, 5, 9, 8, 7) etc
without having to manually add elements by doing v[0] = 1, v[1] = 2 ..
etc.
it would make for much more readable code that is faster to write in
some situations. I've not seen this feature documented anywhere
though which I find curious. is there another way to achieve this?
If you have a predefined set of elements (and that's all the vector will
need to hold) you might want to look into using TR1::array instead of a
vector (the same class is in the current draft for C++ 0x as std::array
as well).
If you will/might need to expand the collection later, you'll still need
to use a vector, but you can initialize the array from the constants,
and then initialize the vector from the array:
TR1::array<int> a = {1, 2, 5, 9, 8, 7};
std::vector<int>v(a.begin(), a.end());
That may not be perfect, but it's still pretty decent.
There have been a number of other methods invented, but none of them is
particularly clean. I once wrote a bit of code to deal with this
problem, but it's sufficiently ugly that I never use it myself, so I'd
have some difficulty recommending that anybody else do so either:
template<class T>
class fill_vector {
std::vector<T> data;
public:
fill_vector(T const &val) {
data.push_back(val);
}
fill_vector<T> &operator,(T const &t) {
data.push_back(t);
return *this;
}
operator std::vector<T>() { return data; }
};
template<class T>
fill_vector<T> fillVect(T const &t) {
return fill_vector<T>(t);
}
std::vector<int> iv = (fillVect(1), 2, 5, 9, 8, 7);
I wouldn't mind if the code for fill_vector or fill_vect was ugly, but
the code to use them needs those seemingly extraneous parentheses, so
the code that uses this technique is unavoidably rather ugly. That
really _does_ bother me.
Another direction is to start with an array, and just have a reasonably
clean way of supplying iterators to the beginning and end of the array
so you can initialize the vector from it cleanly:
template <class T, size_t N>
T *end(T (&input)[N]) {
return input+N;
}
int init[] = { 1, 2, 5, 9, 8, 7};
std::vector<int> v(init, end(init));
Like the version that initializes a vector from a TR1::array, this
separates creation of the vector from defining its initial data, and
requires a name for the object holding that initial data. That's not
really ideal, but in practice I've never really run into a major problem
with it either.
Choosing between TR1::array and/or std::array and this last version,
isn't necessarily simple. If you already have the array class available
(on all compilers you need to target), you might as well use it. If you
don't have it available, you need to decide whether the number of times
you could use an array object directly (rather than just to initialize a
vector) justifies finding and installing an implementation. That'll
depend on circumstances about which I know too little to comment
intelligently.
stream_iterator<int>(std::cout,