Convert a vector<T> to initializer_list<T>

Everyone creates std::vector from std::initializer_list, but what about the other way around?

eg. if you use a std::initializer_list as a parameter:

void someThing(std::initializer_list<int> items)
{
...
}

There are times when you have your items in a vector<T> instead of a literal list:

std::vector<int> v;
// populate v with values
someThing(v); // boom! No viable conversion etc.

The more general question is: how to create an stl::initializer_list from a STL iterable, not just std::vector.

The answer is NO, you cannot do that.

An object of type std::initializer_list<T> is a lightweight proxy object that provides access to an array of objects of type T. A std::initializer_list object is automatically constructed when:

• a braced-init-list is used in list-initialization, including function-call list initialization and assignment expressions (not to be confused with constructor initializer lists)
• a braced-init-list is bound to auto, including in a ranged for loop

As far as library support goes, std::initializer_list only has a default constructor that constructs an empty list, and its iterators are constant. The lack of a push_back() member means you cannot apply e.g. a std::copy with a std::back_inserter iterator adaptor to fill it, and neither can you assign through such iterators directly:

#include <algorithm>
#include <initializer_list>
#include <iterator>
#include <vector>

int main() 
{
    auto v = std::vector<int> { 1, 2 };
    std::initializer_list<int> i;
    auto it = std::begin(i);
    *it = begin(v); // error: read-only variable is not assignable
}

Live Example

If you look at the Standard Containers, in addition to accepting std::initializer_list in their constructors / inserters, they all have constructors / inserters taking an iterator pair, and the implementation is likely to delegate the initializer_list function to the corresponding iterator pair function. E.g. the std::vector<T>::insert function in libc++ is this simple one-liner:

 iterator insert(const_iterator __position, initializer_list<value_type> __il)
        {return insert(__position, __il.begin(), __il.end());}

You should modify your code along similar lines:

void someThing(std::initializer_list<int> items)
{
    someThing(items.begin(), items.end()); // delegate
}

template<class It>
void someThing(It first, It last)
{
    for (auto it = first, it != last; ++it) // do your thing
}

In times when you have your items in a vector instead of a literal list:

std::vector<int> v = { 1, 2 };
auto i = { 1, 2 };
someThing(begin(v), end(v)); // OK
someThing(i); // also OK
someThing({1, 2}); // even better

Apparently no, it is not possible. There is no such constructor (and I believe for good reasons), std::initializer_list is a weird creature.

What you could do instead is to change someThing() to accept a pair of iterators. In that way you get what you want, provided you can change the signature of that function (it isn't in a third party library, etc).

Yes you can do this, but you don't want to do it, because how you have to do it is pretty silly.

First, determine what the max length of your list is. There must be a max length, because size_t is not unbounded. Ideally find a better (smaller) one, like 10.

Second, write magic switch code that takes a run-time integer, and maps it to a compile time integer, and then invokes a template class or function with that compile time integer. Such code needs a max integer size -- use the max length above.

Now, magic switch the size of the vector into a compile time length.

Create a compile time sequence of integers, from 0 to length-1. Unpack that sequence in a initializer_list construction, each time invoking [] on the std::vector. Call your function with that resulting initializer_list.

The above is tricky and ridiculous and most compilers will blow up on it. There is one step I'm uncertain of the legality of -- is the construction of an initializer_list a legal spot to do varardic argument unpacking?

Here is an example of a magic switch: https://stackoverflow.com/questions/16067537/can-i-separate-creation-and-usage-locations-of-compile-time-strategies

Here is an example of the indices, or sequence, trick: https://stackoverflow.com/questions/14897527/constructor-arguments-from-tuple

This post should only be of theoretical interest, because practically this is a really silly way to solve this problem.

Doing it with an arbitrary iterable is harder, without doing n^2 work. But as the above is already ridiculous enough, and the arbitrary iterable version would be more ridiculous... (Maybe with a pack of lambdas -- getting it so that the arguments are evaluated in order could be tricky. Is there a sequence point between the evaluation of the various arguments to an initializer list?)

I posted a way that seemed to work but unfortunately caused memory access violations because of how initializer_lists are treated as references to locally-scoped copies of values.

Here's an alternative. A separate function and a separate static initializer list is generated for each possible number of items, which are counted with a parameter pack. This is not thread safe and uses a const_cast (which is considered very bad) to write into the static initializer_list memory. However, it works cleanly in both gcc and clang.

If for some obscure reason you need this problem solved and have no other options, you could try this hack.

#include <initializer_list>
#include <iostream>
#include <stdexcept>
#include <type_traits>
#include <vector>

namespace __range_to_initializer_list {

	constexpr size_t DEFAULT_MAX_LENGTH = 128;
	
	template <typename V> struct backingValue { static V value; };
	template <typename V> V backingValue<V>::value;

	template <typename V, typename... Vcount> struct backingList { static std::initializer_list<V> list; };
	template <typename V, typename... Vcount>
	std::initializer_list<V> backingList<V, Vcount...>::list = {(Vcount)backingValue<V>::value...};

	template <size_t maxLength, typename It, typename V = typename It::value_type, typename... Vcount>
	static typename std::enable_if< sizeof...(Vcount) >= maxLength,
	std::initializer_list<V> >::type generate_n(It begin, It end, It current)
	{
		throw std::length_error("More than maxLength elements in range.");
	}
	
	template <size_t maxLength = DEFAULT_MAX_LENGTH, typename It, typename V = typename It::value_type, typename... Vcount>
	static typename std::enable_if< sizeof...(Vcount) < maxLength,
	std::initializer_list<V> >::type generate_n(It begin, It end, It current)
	{
		if (current != end)
			return generate_n<maxLength, It, V, V, Vcount...>(begin, end, ++current);
		
		current = begin;
		for (auto it = backingList<V,Vcount...>::list.begin();
		     it != backingList<V,Vcount...>::list.end();
		     ++current, ++it)
			*const_cast<V*>(&*it) = *current;
	
		return backingList<V,Vcount...>::list;
	}

}

template <typename It>
std::initializer_list<typename It::value_type> range_to_initializer_list(It begin, It end)
{
	return __range_to_initializer_list::generate_n(begin, end, begin);
}

int main()
{
	std::vector<int> vec = {1,2,3,4,5,6,7,8,9,10};
	std::initializer_list<int> list = range_to_initializer_list(vec.begin(), vec.end());
	for (int i : list)
		std::cout << i << std::endl;
	return 0;
}

If you don't mind copies, then I think something like this would work:

template<class Iterator>
using iterator_init_list = std::initializer_list<typename std::iterator_traits<Iterator>::value_type>;

template<class Iterator, class... Ts>
iterator_init_list<Iterator> to_initializer_list(Iterator start, Iterator last, Ts... xs)
{
    if (start == last) return iterator_init_list<Iterator>{xs...};
    else return to_initializer_list(start+1, last, xs..., *start);
}

I think that the best solution without templating obscure iterator classes for the good of passing vector using its two methods returning iterators is just to implement your function logic in a function taking vector.

void someThing(std::initializer_list<int> items)
{
     std::vector<int> v;
     for(int i:items)
     {
             v.push_back(i);
     }
     someThing(v);
}

void someThing(std::vector<int> items)
{
...
}