Question

I am a little confused about what happens when I copy functors and/or initializers. In the following code I thought I would copy/move the objects all the time but regardsless it Segfaults. I seem to be doing something wrong but haven’t figured out yet, what my wrong asumptions are.
Strangely at cppreference.com I could not find copy or move constructor for initializer_list so I wonder what actually happens in these cases.

#include <string>
#include <vector>
#include <functional>
#include <iostream>

std::initializer_list<std::function<std::string()>> getInitializer() {
  return {
    []() -> std::string {
      return "If";
    }
  };
}

int main() {
    std::function<int(std::string)> func;
    {
        auto init = getInitializer();

        func = [init](std::string text) -> int {
            std::vector<std::function<std::string()>> vec(init);

            for( auto& el : vec ) {
                std::cout << el();
            }
            std::cout << text << std::endl;
            return 5;
        };
    }

    return func(" you see this - the world is all right!");
}

Answer 1

I don’t have much experience with initializer_lists, but the standard seems to suggest the implementation of an initializer_list is as if its a pair of pointers to an array. The list at getInitializer has automatic lifetime, and so does the array that backs it. You end up returning a pair of pointers to an array that no longer exists.

The relevant sections of the standard are 8.5.4 [decl.init.list] items 5 and 6:

5.- An object of type std::initializer_list<E> is constructed from an initializer list as if the implementation allocated an array of N elements of type E, where N is the number of elements in the initializer list. Each element of that array is copy-initialized with the corresponding element of the initializer list, and the std::initializer_list<E> object is constructed to refer to that array. If a narrowing conversion is required to initialize any of the elements, the program is ill-formed.

6.- The lifetime of the array is the same as that of the initializer_list object.

---

So for your particular case, the implementation would be roughly equivalent to this:

std::initializer_list<std::function<std::string()>> getInitializer() {
  std::function<std::string()> __a[1] = {
    []() -> std::string {
      return "If";
    }
  };
  return std::initializer_list<std::function<std::string()>>(__a, __a+1);
}