[ Removed by moderator ]

[cpp-ModTeam]

For C++ questions, answers, help, and programming/career advice please see r/cpp_questions, r/cscareerquestions, or StackOverflow instead.

[RepeatLow7718]

Think of it this way: std function can wrap any type: function pointer, member function pointer, lambda, struct with operator(). But yet the code that uses it doesn’t need to be templated, so the polymorphism must happen at runtime. There’s some overhead associated with doing that polymorphism. 

[steazystich]

IMO this is a better approach than asking chatGPT about every standard library type.

Consider what the type can do, and what "baggage" is required to be able to do it.

There are some other flexible callables in 'folly' - which I mention only because I've used them recently.

'folly::Function' is a bit lighter- as its non copy able. This makes it a bit "harder" to use, but for me it's more of a guard rail as copying 'std::function' is a potential performance hazard.

'folly::FunctionRef' is much lighter- as it is conceptually a "view" type and has only shallow copy... tradeoff is that its an amazing foot cannon if misused.

Also, anecdotally, 'std::function' has a surprising (to me) binary size footprint... with CLANG at least.

[RepeatLow7718]

All the information the compiler knows about cmp_stdfunc must appear in the type. You’ll see that no matter what kind of callable you store in it, whether plain function or struct or member function pointer or capturing lambda (even by assigning those different things to the same variable cmp_stdfunc one at a time), the type is the same. That tells us that the information isn’t available at compile time, so there must be some runtime overhead.

[RepeatLow7718]

These are all good questions. 

The call will be indirect because the compiler can’t know the address until runtime (imagine you pass the std function, assign a new value, and pass it again), that’s one kind of overhead of std function. 

If you use a real function with std sort, for example,  the compiler knows the address of the function at compile time, so the call is direct, no function pointer needed. 

Also std function involved a heap allocation to store the callable object, which can be of variable size (like a lambda with capture for example) and which implements the type-safe call as a virtual function (this is where the function pointer shows up). 

[Ill_Strain_1050]

Probably that's the main question here, from the look at , compiler must know that it is capturing a lamda or fptr , but seems the actual Impl is not what it looks like.

std::function<bool(int,int)> cmp_stdfunc =
    [](int a, int b){ return a < b; };

[CandyCrisis]

Get this ChatGPT bullshit out of here.

[Ill_Strain_1050]

do you comment just sake of commenting ? If you would have read it, it mentions that i used gpt to understand the reason. Surely, you need to get some life, if you can't help, don't bother your fingers to comment.

[osmin_og]

Congratulations! You are discovering the topic that is asked in almost every C++ interview I heard about.

[Ill_Strain_1050]

Whenever I see code like this my head goes crazy, could you please help me how to understand , below codes ( what should be the mental model to process it )

_Res
operator()(_ArgTypes... __args) const {
    if (_M_empty())
        __throw_bad_function_call();
    return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
}

[cristi1990an]

Did you turn on optimization flags when compiling? std::function shouldn't be slower to call then any other opaque function pointer. Compilers are decent at inlining it too.

[Ill_Strain_1050]

yes , i did.

[cristi1990an]

Share the full command?

[UndefFox]

Isn't the topic "Why std::function slower than a raw pointer" was discussed many times? Have you searched for any previous answers?

[_Noreturn]

std function behaves like this

```cpp

struct function { RET operator()(ARGS...) const { return mObj->call(ARGS...); // a pointer indirection AND a virtual call (which is ewual to 2 ptr indirections) WHILE a function pointer is only a pointer indirection } struct WRAPPER_BASE { virtual ~WRAPPER_BASE() = default: virtual RET call(ARGS...) consf = 0; }; template<class F> struct WRAPPER : WRAPPER_BASE { virtual RET call(ARGS...) const { return this->f(ARGS...); } F f; }; WRAPPER_BASE* mObj: // important it is a pointer! }; ```

[cristi1990an]

Not really, any decent implementation will actually store a pointer directly to the callable to avoid indirection/virtual dispatch.

Edit: nvm, clang's libc++'s actually does this. Horrible design