lambda 返回 initializer_list 中的奇怪值

Question

考虑一下这个 C++11 代码 sn-p：

#include <iostream>
#include <set>
#include <stdexcept>
#include <initializer_list>


int main(int argc, char ** argv)
{
    enum Switch {
        Switch_1,
        Switch_2,
        Switch_3,
        Switch_XXXX,
    };

    int foo_1 = 1;
    int foo_2 = 2;
    int foo_3 = 3;
    int foo_4 = 4;
    int foo_5 = 5;
    int foo_6 = 6;
    int foo_7 = 7;

    auto get_foos = [=] (Switch ss) -> std::initializer_list<int> {
        switch (ss) {
            case Switch_1:
                return {foo_1, foo_2, foo_3};
            case Switch_2:
                return {foo_4, foo_5};
            case Switch_3:
                return {foo_6, foo_7};
            default:
                throw std::logic_error("invalid switch");
        }
    };

    std::set<int> foos = get_foos(Switch_1);
    for (auto && foo : foos) {
        std::cout << foo << " ";
    }
    std::cout << std::endl;
    return 0;
}

无论我尝试什么编译器，似乎都处理不正确。这让我觉得我做错了什么，而不是跨多个编译器的常见错误。

clang 3.5 输出：

-1078533848 -1078533752 134518134

gcc 4.8.2 输出：

-1078845996 -1078845984 3

gcc 4.8.3 输出（编译在http://www.tutorialspoint.com）：

1 2 267998238

gcc（未知版本） 输出（编译于http://coliru.stacked-crooked.com）

-1785083736 0 6297428 

问题似乎是由于使用std::initializer_list<int> 作为 lambda 的返回值引起的。将 lambda 定义更改为 [=] (Switch ss) -> std::set<int> {...} 时，返回值正确。

请帮我解开这个谜。

Answer 1

发件人：http://en.cppreference.com/w/cpp/utility/initializer_list

在原始初始化列表对象的生命周期结束后，不能保证底层数组存在。 std::initializer_list 的存储是未指定的（即它可以是自动、临时或静态只读内存，具体取决于具体情况）。

我不认为初始化列表是可复制构造的。 std::set 和其他容器都是。基本上，您的代码的行为类似于“返回对临时的引用”。

C++14 对底层存储的说法略有不同——延长 its 生命周期——但这并不能解决与 initializer_list 对象生命周期有关的任何问题，更不用说其副本。因此，即使在 C++14 中，问题仍然存在。

底层数组是一个临时数组，其中每个元素都是从原始初始化列表的相应元素复制初始化的（除了缩小转换无效）。底层数组的生命周期与任何其他临时对象相同，除了从数组初始化一个 initializer_list 对象会延长数组的生命周期，就像绑定一个临时对象的引用（有相同的例外，例如用于初始化非静态类成员）。底层数组可以分配在只读内存中。

Answer 2

问题是您正在引用一个不再存在的对象，因此您正在调用undefined behavior。 initializer_list 似乎在 C++11 draft standard 中未指定，没有规范部分实际指定此行为。尽管有很多注释表明这是行不通的，而且总的来说，尽管注释如果不与规范性文本冲突，则不是规范性的，但它们具有很强的指示性。

如果我们转到 18.9 部分 Initializer lists 它有一个注释说：

复制初始化列表不会复制底层元素。

在8.5.4 部分我们有以下示例：

typedef std::complex<double> cmplx;
std::vector<cmplx> v1 = { 1, 2, 3 };

void f() {
    std::vector<cmplx> v2{ 1, 2, 3 };
    std::initializer_list<int> i3 = { 1, 2, 3 };
}

带有以下注释：

对于 v1 和 v2，为 { 1, 2, 3 } 创建的 initializer_list 对象和数组具有完整表达式 寿命。对于 i3，initializer_list 对象和数组具有自动生命周期。

这些注释与给出以下示例的initializer_list proposal: N2215 一致：

std::vector<double> v = {1, 2, 3.14};

然后说：

现在将vector(initializer_list<E>) 添加到vector<E>，如上所示。现在， 该示例有效。初始化列表 {1, 2, 3.14} 被解释为 像这样构造的临时：

const double temp[] = {double(1), double(2), 3.14 } ;
initializer_list<double> tmp(temp,
sizeof(temp)/sizeof(double));
vector<double> v(tmp);

[...]

请注意，initializer_list 是一个小对象（可能是两个词）， 所以按值传递它是有道理的。按值传递也简化了 begin() 和 end() 的内联以及对的常量表达式求值 大小（）。

一个 initializer_list 将由编译器创建，但可以 被用户复制。把它想象成一对指针。

在这种情况下，initializer_list 只是保存指向自动变量的指针，该变量在退出范围后将不存在。

更新

我刚刚意识到提案实际上指出了这种误用场景：

其中一个含义是 initializer_list 是“类似指针”的 就底层数组而言，它的行为就像一个指针。为了 示例：

int * f(int a)
{ 
   int* p = &a;
   return p; //bug waiting to happen
}

initializer_list<int> g(int a, int b, int c)
{
   initializer_list<int> v = { a, b, c };
   return v; // bug waiting to happen
} 

实际上需要一点聪明才智来滥用 initializer_list 这样。特别是，类型变量 initializer_list 将很少见。

我觉得最后一句话（强调我的）特别讽刺。

更新 2

所以defect report 1290 修正了规范措辞，因此它现在涵盖了这种行为，尽管复制案例可能更明确。它说：

当初始化器列表时，出现了一个关于预期行为的问题 是类的非静态数据成员。初始化一个 initializer_list 是根据从一个 隐式分配的数组，其生命周期“与 initializer_list 对象”。这意味着该数组需要存在 只要 initializer_list 确实如此，从表面上看 似乎需要将数组存储在类似 同一类中的 std::unique_ptr （如果成员是 以这种方式初始化）。

如果这是本意，那将是令人惊讶的，但它会让 在此上下文中可用的 initializer_list。

决议修正了措辞，我们可以在N3485 version of the draft standard 中找到新措辞。所以8.5.4 [dcl.init.list] 部分现在说：

该数组与任何其他临时对象 (12.2) 具有相同的生命周期， 除了从数组中初始化一个 initializer_- 列表对象 延长数组的生命周期，就像绑定一个引用一样 临时的。

和12.2 [class.temporary] 说：

临时绑定到函数中返回值的生命周期 return 语句 (6.6.3) 未扩展；临时被毁 在 return 语句中的完整表达式的末尾。

Answer 3

因此，initializer_lists 在自身被复制或移动到复制/移动的结果时不会延长其引用数组的生命周期。这使得退货成为问题。 （它们确实将引用数组的生命周期延长到它们自己的生命周期，但这种扩展不能传递到省略或列表副本）。

要解决此问题，请手动存储数据并管理其生命周期：

template<size_t size, class T>
std::array<T, size> partial_array( T const* begin, T const* end ) {
  std::array<T, size> retval;
  size_t delta = (std::min)( size, end-begin );
  end = begin+delta;
  std::copy( begin, end, retval.begin() );
  return retval;
}
template<class T, size_t max_size>
struct capped_array {
  std::array<T, max_size> storage;
  size_t used = 0;
  template<size_t osize, class=std::enable_if_t< (size<=max_size) >>
  capped_array( std::array<T, osize> const& rhs ):
    capped_array( rhs.data(), rhs.data()+osize )
  {}
  template<size_t osize, class=std::enable_if_t< (size<=max_size) >>
  capped_array( capped_array<T, osize> const& rhs ):
    capped_array( rhs.data(), rhs.data()+rhs.used )
  {}
  capped_array(capped_array const& o)=default;
  capped_array(capped_array & o)=default;
  capped_array(capped_array && o)=default;
  capped_array(capped_array const&& o)=default;
  capped_array& operator=(capped_array const& o)=default;
  capped_array& operator=(capped_array & o)=default;
  capped_array& operator=(capped_array && o)=default;
  capped_array& operator=(capped_array const&& o)=default;

  // finish-start MUST be less than max_size, or we will truncate
  capped_array( T const* start, T const* finish ):
    storage( partial_array(start, finish) ),
    used((std::min)(finish-start, size))
  {}
  T* begin() { return storage.data(); }
  T* end() { return storage.data()+used; }
  T const* begin() const { return storage.data(); }
  T const* end() const { return storage.data()+used; }
  size_t size() const { return used; }
  bool empty() const { return !used; }
  T& front() { return *begin(); }
  T const& front() const { return *begin(); }
  T& back() { return *std::prev(end()); }
  T const& back() const { return *std::prev(end()); }

  capped_array( std::initializer_list<T> il ):
    capped_array(il.begin(), il.end() )
  {}
};

这里的目标很简单。创建一个基于堆栈的数据类型，存储一堆Ts，最多可以处理一个上限，并且可以处理更少。

现在我们将您的 std::initializer_list 替换为：

auto get_foos = [=] (Switch ss) -> capped_array<int,3> {
    switch (ss) {
        case Switch_1:
            return {foo_1, foo_2, foo_3};
        case Switch_2:
            return {foo_4, foo_5};
        case Switch_3:
            return {foo_6, foo_7};
        default:
            throw std::logic_error("invalid switch");
    }
};

并且您的代码有效。未使用空闲存储（无堆分配）。

更高级的版本将使用一组未初始化的数据并手动构造每个T。