将vector <T>转换为initializer_list <T>

Question

每个人都创建std::vector从std::initializer_list,但对于周围的其他方式？

例如.如果你使用a 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::initializer_list从STL可迭代创建,而不仅仅是std::vector.

Answer 1

答案是否定的,你不能这样做.

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

• 在列表初始化中使用了braced-init-list,包括函数调用列表初始化和赋值表达式(不要与构造函数初始化列表混淆)
• braced-init-list绑定到auto,包括在ranged for循环中

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

#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函数委托给相应的迭代器对函数.例如std::vector<T>::insert,libc ++中的函数就是这个简单的单行程序:

 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一个合法的地方做varardic论证拆包？

这是一个神奇的开关示例:我可以分离编译时策略的创建和使用位置吗？

下面是索引或序列,技巧的示例:来自元组的构造函数参数

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

使用任意迭代执行它更难,而不需要执行n ^ 2工作.但是由于上面已经足够荒谬了,并且任意可迭代版本会更加荒谬......(也许有一堆lambdas - 得到它以便按顺序评估参数可能会很棘手.是否有一个序列点评估初始化列表的各种参数？)

Answer 4

我发布了一种似乎有效的方法，但不幸的是由于初始化程序列表被视为对本地范围的值副本的引用而导致内存访问冲突。

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

如果由于某种不明原因你需要解决这个问题并且没有其他选择，你可以尝试这个技巧。

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