Why the initializer of std::function has to be CopyConstructible?

by

std::function uses type erasure internally, so F has to be CopyConstructible even if the particular std::function object you are using is never copied.

A simplification on how type erasure works:

class Function
{
    struct Concept {
        virtual ~Concept() = default;
        virtual Concept* clone() const = 0;
        //...
    }

    template<typename F>
    struct Model final : Concept {

        explicit Model(F f) : data(std::move(f)) {}
        Model* clone() const override { return new Model(*this); }
        //...

        F data;
    };

    std::unique_ptr<Concept> object;

public:
    template<typename F>
    explicit Function(F f) : object(new Model<F>(std::move(f))) {}

    Function(Function const& that) : object(that.object->clone()) {}
    //...

};

You have to be able to generate Model<F>::clone(), which forces F to be CopyConstructible.

More Related Contents:

  1. Optimization code for a debug function (c++11 with templates) [closed]
  2. How to convert a lambda to an std::function using templates
  3. Forwarding all constructors in C++0x
  4. Using generic std::function objects with member functions in one class
  5. using extern template (C++11)
  6. SFINAE working in return type but not as template parameter
  7. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  8. Detecting constexpr with SFINAE
  9. Alias template specialisation
  10. What do compilers do with compile-time branching?
  11. std::bind a bound function
  12. Is it possible to “store” a template parameter pack without expanding it?
  13. C++11: Compile Time Calculation of Array
  14. How to reverse the order of arguments of a variadic template function?
  15. Doing a static_assert that a template type is another template
  16. Template specialization and enable_if problems [duplicate]
  17. Select class constructor using enable_if
  18. Populate An Array Using Constexpr at Compile-time
  19. Why do auto and template type deduction differ for braced initializers?
  20. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  21. Lambda expressions as class template parameters
  22. Different ways of initializing an object in c++
  23. Using export keyword with templates
  24. How to make a variadic is_same?
  25. Conflict between copy constructor and forwarding constructor
  26. How to typedef a template class? [duplicate]
  27. Using C++ base class constructors?
  28. using SFINAE for template class specialisation
  29. Why does the template-id in “A=0” not compile without space because of the greater-or-equal-than operator “>=”?
  30. Specializing a template on a lambda in C++0x

Leave a Comment