For one, the functor can contain internal state; a state that is valid for this invocation of the function object only. You could add static variables to your function, but those would be used for any invocation of the function. Second, the compiler can inline calls to the functor; it cannot do the same for … Read more
The C standard does not allow to cast function pointers to void*. You may only cast to another function pointer type. In the C11 standard, 6.3.2.3 §8: A pointer to a function of one type may be converted to a pointer to a function of another type and back again Importantly, you must cast back … Read more
Here’s the relevant paragraph from the Standard. It pretty much speaks for itself. 8.3.5/10 A typedef of function type may be used to declare a function but shall not be used to define a function (8.4). Example: typedef void F(); F fv; // OK: equivalent to void fv(); F fv { } // ill-formed void … Read more
You cannot, at least it won’t be only a pointer to a function. Member functions are common for all instances of this class. All member functions have the implicit (first) parameter, this. In order to call a member function for a specific instance you need a pointer to this member function and this instance. class … Read more
On some processors an indirect branch will always clear at least part of the pipeline, because it will always mispredict. This is especially the case for in-order processors. For example, I ran some timings on the processor we develop for, comparing the overhead of an inline function call, versus a direct function call, versus an … Read more
At compile time, the compiler doesn’t know the address of sqrt. However, you cannot do anything at compile time with a constexpr function pointer that would allow you to access that pointer’s address. Therefore, a function pointer at compile time can be treated as an opaque value. And since you can’t change a constexpr variable … Read more
You can’t fix the warning. In fact, in my opinion it should be a hard error since it’s illegal to cast function pointers to other pointers because there are architectures out there today where this isn’t just a violation of the C standard but an actual error that will make the code not work. Compilers … Read more
Both assertions succeed because they are applied to the type T deduced from function argument. In both cases it will be deduced as a pointer to function because functions decay to a pointer to function. However if you rewrite assertions to accept types directly then first one will fail: static_assert(is_same<void(*)(), decltype(fun)>::value); static_assert(is_same<void(*)(), decltype(&fun)>::value); online compiler
The difference between a captured argument and a passing argument could be seen with an analogy. Consider the following function object: struct Capture { int &i; int const j; public: Capture(int &_i, int &_j) : i(_i), j(_j) {} int operator()(int const a, int const b) { i *= j; return a * b; } }; … Read more
There is no such thing as a template function in C++ — what people casually mention as “template functions” are actually function templates : templates which define functions. As such, func in your second example above is not a function, it’s a (function) template, and it cannot be used in the same way as a … Read more