转换向量<t>到 initializer_list<t></t></t>

Question

每个人都从std::initializer_list创建std::vector ，但反过来呢？

例如。 如果您使用std::initializer_list作为参数：

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

有时您将项目放在vector<T>而不是文字列表中：

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

更普遍的问题是：如何从 STL 可迭代创建stl::initializer_list ，而不仅仅是std::vector 。

Answer 1

答案是否定的，你不能那样做。

std::initializer_list<T>类型的对象是轻量级代理对象，它提供对 T 类型对象数组的访问。 std::initializer_list对象在以下情况下自动构造：

• 花括号初始化列表用于列表初始化，包括函数调用列表初始化和赋值表达式（不要与构造函数初始化列表混淆）
• 花括号初始化列表绑定到自动，包括在范围 for 循环中

就库支持而言， std::initializer_list只有一个构造空列表的默认构造函数，并且其迭代器是 constant 。 缺少push_back()成员意味着您不能应用例如带有std::back_inserter迭代器适配器的std::copy来填充它，也不能直接通过此类迭代器进行分配：

#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
}

现场示例

如果您查看标准容器，除了在其构造函数/插入器中接受std::initializer_list之外，它们都有采用迭代器对的构造函数/插入器，并且实现很可能将initializer_list函数委托给相应的迭代器对函数。 例如，libc++ 中的std::vector<T>::insert函数就是这个简单的单行函数：

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

您应该按照类似的方式修改您的代码：

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
}

当您将项目放在向量中而不是文字列表中时：

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

Answer 2

显然不，这是不可能的。 没有这样的构造函数（我相信有充分的理由）， std::initializer_list是一个奇怪的生物。

您可以做的是更改someThing()以接受一对迭代器。 这样你就可以得到你想要的东西，只要你能改变那个函数的签名（它不在第三方库中，等等）。

Answer 3

是的，您可以这样做，但您不想这样做，因为您必须这样做非常愚蠢。

首先，确定列表的最大长度是多少。 必须有一个最大长度，因为size_t不是无限的。 理想情况下，找到一个更好（更小）的，例如 10。

其次，编写采用运行时整数的魔术开关代码，并将其映射到编译时整数，然后使用该编译时整数调用模板类或函数。 这样的代码需要一个最大整数大小——使用上面的最大长度。

现在，魔术般地将向量的大小转换为编译时间长度。

创建一个整数的编译时间序列，从0到length-1 。 在一个initializer_list构造中解压该序列，每次在std::vector上调用[] 。 使用生成的initializer_list调用您的函数。

以上是棘手和荒谬的，大多数编译器都会炸毁它。 有一个步骤我不确定它的合法性——构造一个initializer_list是进行可变参数解包的合法位置吗？

下面是一个魔术开关的例子： 我可以将编译时策略的创建和使用位置分开吗？

这是索引或序列技巧的示例： 来自元组的构造函数参数

这篇文章应该只是理论上的兴趣，因为实际上这是解决这个问题的一种非常愚蠢的方法。

在不做 n^2 工作的情况下，使用任意可迭代对象进行操作会更困难。 但是由于上面已经足够荒谬了，而任意的可迭代版本会更荒谬......（也许有一组 lambdas - 得到它以便按顺序评估参数可能会很棘手。之间是否有序列点对初始化列表的各种参数的评估？）

Answer 4

我发布了一种似乎有效的方法，但不幸的是，由于如何将 initializer_lists 视为对本地范围的值副本的引用，因此导致内存访问冲突。

这是一个替代方案。 为每个可能的项目数量生成一个单独的函数和一个单独的静态初始化列表，这些项目用参数包进行计数。 这不是线程安全的，并且使用 const_cast（这被认为是非常糟糕的）写入静态初始化列表内存。 但是，它在 gcc 和 clang 中都能正常工作。

如果出于某种晦涩的原因，您需要解决此问题并且没有其他选择，则可以尝试此 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;
}

Answer 5

对于矢量，您可以使用指针算法。

Foo( std::initializer_list< _Type >( aVector.data(), aVector.data() + aVector.size() ) ) ;

您可以将其包装在通用函数中。

template< typename _Type >
auto    InitList( const _Type * begin, size_t size )
{
  return std::initializer_list< _Type >( begin, begin + size ) ;
}

像这样调用函数。

Foo( InitList( aVector.data(), aVector.size() ) ) ;

Answer 6

如果你不介意复制，那么我认为这样的事情会奏效：

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);
}

Answer 7

我认为最好的解决方案没有模板化晦涩的迭代器类以便使用其返回迭代器的两种方法传递向量，只是在函数接受向量中实现您的函数逻辑。

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)
{
...
}

Answer 8

std::vector<int> v;
someThing(std::initializer_list<int>(&v.front(), &v.front() + v.size()));