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

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<b>& 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 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 );