72

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

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

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

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

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

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

4

6 回答 6

38

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

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

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

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

#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
于 2013-09-19T14:10:31.807 回答
9

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

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

于 2013-09-19T14:04:21.787 回答
5

是的，你可以这样做，但你不想这样做，因为你必须这样做是很愚蠢的。

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

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

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

创建一个整数的编译时间序列，从0到length-1。在构造中解压缩该序列initializer_list，每次调用[]. std::vector用结果调用你的函数initializer_list。

以上内容既棘手又荒谬，大多数编译器都会对此感到震惊。有一个步骤我不确定其合法性 - 是否构建了initializer_list一个合法的地点来进行 varardic 论证拆包？

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

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

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

不做 n^2 的工作，用任意的可迭代做它更难。但是由于上述内容已经足够荒谬了，并且任意可迭代的版本会更加荒谬......（也许有一组 lambdas - 获取它以便按顺序评估参数可能很棘手。之间是否有一个序列点对初始化列表的各种参数的评估？）

于 2013-09-19T17:29:44.760 回答
2

我发布了一种似乎可行的方法，但不幸的是，由于 initializer_lists 被视为对值的本地范围副本的引用而导致内存访问冲突。

这是一个替代方案。为每个可能的项目数生成一个单独的函数和一个单独的静态初始化器列表，这些项目使用参数包进行计数。这不是线程安全的，并且使用 const_cast（这被认为非常糟糕）写入静态 initializer_list 内存。但是，它在 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;
}
于 2015-08-26T02:15:23.257 回答
0

如果您不介意副本，那么我认为这样的事情会起作用：

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);
}
于 2016-10-03T06:10:07.447 回答
0

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

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)
{
...
}
于 2020-11-18T11:01:10.170 回答