C++ function pointer optimization

Quote:

Original post by Ro_Akira Is there any chance of function calls via a pointer will be inlined and optimised away? Hypothetically speaking?

int function(int param){   return param+1;}int main(int argc, char* argv[]){   int i;      i = function(100);   i = (true ? function : NULL) (i);   std::cout << "i = " << i << std::endl;   return 0;}

int function(int param){   return param+1;// 00401000  mov         eax,dword ptr [esp+4] // 00401004  inc         eax  }// 00401005  ret// ----------------------int main(int argc, char* argv[]){// 004018D0  push        esi     int i;      i = function(100);   i = (true ? function : NULL) (i);// 004018D1  push        65h                 // this is i = function(100);// 004018D3  call        function (401000h)  // function is called, due to the function pointer// 004018D8  add         esp,4 // ...

Quote:

Original post by Ro_Akira Is there any chance of function calls via a pointer will be inlined and optimised away? Hypothetically speaking?

Quote:

Original post by Ro_Akira Is there any chance of function calls via a pointer will be inlined and optimised away? Hypothetically speaking?

Quote:

// const here should make the function pointer const, I believe SimpleFunctionPointerType const SimpleFunctionLocalPointer (&SimpleFunction);

Quote:

Presumably there's greater difficulty involved in inlining the GlobalPointer, because the compiler has more trouble in general, determining if the pointer is safe/const?

Quote:

Original post by Fruny Taking the address of a function makes it unsuitable for inlining. The compiler should not be inlining the call.

Quote:

C++ Standard, Final Draft, Section 1.8, Paragraph 1 The semantic descriptions in this International Standard define a parameterized nondeterministic abstract machine. This International Standard places no requirement on the structure of conforming implementations. In particular, they need not copy or emulate the structure of the abstract machine. Rather, conforming implementations are required to emulate (only) the observable behavior of the abstract machine as explained below.3) 3) This provision is sometimes called the "as-if" rule, because an implementation is free to disregard any requirement of the Standard as long as the result is as if the requirement had been obeyed, as far as can be determined from the observable behavior of the program.

Quote:

Original post by Fruny Not just more difficulty, it's impossible. For all the compiler knows, you could link against a DLL that modifies that global variable.

Quote:

Is there any chance of function calls via a pointer will be inlined and optimised away? Hypothetically speaking?

Quote:

Hélas, no....

Quote:

Yes...

Quote:

There is no difference between const Foo and Foo const. There is a difference, however, between const Foo*, Foo const* on one hand, and Foo* const on the other.

typedef int (*const SimpleFunctionPointerType) ();

Quote:

The function pointer was declared const. Therefore any attempt to modify it is undefined behaviour, thus allowing the compiler to inline the function call.

Quote:

Anyhow, OP, you probably shouldn't even worry about it. The odds that will be the bottleneck of your program are VERY small.

Quote:

I'll see if I can check out gcc...

mov eax, 2400

Quote:

GCC 3.3.1 fully inlines every example given in this thread.

i = (true ? function : NULL) (i);// 004018D1  push        65h                 // this is i = function(100);// 004018D3  call        function (401000h)  // function is called, due to the function pointer// 004018D8  add         esp,4 

Derived d;int Derived::VirtualFunction () const{    return simple_expression;}void Function (const Base& b){    cout << b->VirtualFunction () << endl;}int main (){    Derived d;    Function (d);    return 0;}

base_pointer_to_base_object->VirtualFunction ()

struct myfunctor {  int operator()() const { printf("I ran my functor!\n"); return 1200; };};int main() {  myfunctor const func;  k += func();  k += myfunctor()();};

Quote:

Original post by Ro_Akira Unless Hélas has a meaning of 'Opposite of ' or similar, these two arguments appear to be in conflict.

Quote:

A compiler never ever has to inline. A compiler is allowed to inline in those cases.

struct Functor{	virtual int operator() () const = 0;};struct MyFunctor : public Functor{	int operator() () const { cout << "I ran my functor!" << endl; return 1800; }};struct YourFunctor : public Functor{	int operator() () const { cout << "I ran your functor!" << endl; return 1700; }};int UseFunctor (const Functor& f){	return f ();}

		MyFunctor	my;		YourFunctor	your;		k += UseFunctor (my);0040134C  lea         ecx,[esp+0Ch] 00401350  lea         esi,[eax+eax+1] 00401354  mov         dword ptr [esp+0Ch],offset MyFunctor::`vftable' (403210h) 0040135C  mov         dword ptr [esp+8],offset YourFunctor::`vftable' (403218h) 00401364  call        dword ptr [MyFunctor::`vftable' (403210h)] 0040136A  add         esi,eax 		k += UseFunctor (your);0040136C  mov         eax,dword ptr [esp+8] 00401370  mov         edx,dword ptr [eax] 00401372  lea         ecx,[esp+8] 00401376  call        edx  

template<typename functor>void do_something_to_data( data d, functor const& func ) {  func(d);}

Quote:

In addition I'd like anyone to suggest a possible reason, apart from not having to, that MSVC++ appeared to fail to fully inline the LocalPointer mentioned earlier.

static SimpleFunctionPointerType const SimpleFunctionGlobalPointer (&SimpleFunction);

Quote:

The typical use of functors as a replacement for function pointers, but allowing inlining, is you template the code that uses the functor.

Quote:

Out of curiosity, does: static SimpleFunctionPointerType const SimpleFunctionGlobalPointer (&SimpleFunction); make any difference? (doubt it, but I am curious).

Quote:

I wonder why C++ doesn't have a "compile_time" keyword (incidating that this value can be determined at compile_time, or the function can be evaluated at compile_time if all the arguments are compile_time.)

template<int a>struct MyClass{    static const int static_a = a;};template<int b>struct OtherClass{    OtherClass (const MyClass& other) {}};template<typename T>void Use (T& var){    OtherClass<T::static_a> temp (var);    temp.DoStuff ();}int main (){    MyClass var;    Use (var);}

Quote:

Original post by NotAYakk I wonder why C++ doesn't have a "compile_time" keyword (incidating that this value can be determined at compile_time, or the function can be evaluated at compile_time if all the arguments are compile_time.)

static const int my_int = numeric_limits<int>::max ();

Quote:

Original post by NotAYakk You can't even implement a compile_time factorial calculator using their system. No loops or recursion is allowed. :(

template<int N>class Factorial {public:    enum { value = N * Factorial<N-1>::value };};class Factorial<1> {public:    enum { value = 1 };};

Quote:

Original post by mfawcett Quote: Original post by NotAYakk You can't even implement a compile_time factorial calculator using their system. No loops or recursion is allowed. :( Well, you can, only it would be a class, not a function, but I understand what you are saying. *** Source Snippet Removed ***

static const int my_int = numeric_limits<int>::max ();

enum{ my_int = numeric_limits<int>::max };

compile_time int max( int, int ) { return a>b?a:b; }compile_time int min( int a, int b) { return a<b?a:b; }compile_time int bound( int bottom, int value, int top ) { return max(bottom, min(value, top) ); }compile_time int factorial( int n ) { if (n==0) return 1; return n*factorial(n-1); }compile_time double sin( double radians ); // in a .cpp file somewherecompile_time double cos( double radians ); // in a .cpp file somewherecompile_time double tan( double radians ); // in a .cpp file somewherecompile_time double sqrt( double src ); // in a .cpp file somewhere

void do_stuff( compile_time int n );