Re: Compile time executed functions

[Jean-Marc Bourguet <jbourguet@free.fr>]

Ken Garlington wrote:
> 
> "Jean-Marc Bourguet" <jbourguet@free.fr> wrote in message
> news:3AC6ED5F.9F2F51A5@free.fr...
> 
> : I think there are NO requirement about generated code excepted the
> : observable behavior for conforming program.  Everybody would be
> : surprised that the generated code for the factorial template I gave
> : produced something other than what is generated for
> :
> : int main() {
> :    std::cout << 3628800 << std::endl;
> : }
> 
> Well, I think you've answered your question, then.
> You're not talking about comparing the C++ language with Ada;

My question? Me comparing C++ and Ada?  I think you are confusing me
with somebody else. I came into this thread when you asked for an
example of using template in C++ for computing things at compile time to
give you one.  Then you asked for a formal guarantee that it was
computed at compile time.  The level at which the C++ standard describe
semantic make it impossible to have such guarantee.  Do you have a
formal guarantee that an Ada compiler does not generate a function to
calculate the 10! when you use the litteral 3628800?  I don't think so
and there is no such guarantee for C++. What the C++ standard does is
constraint the expression to be a constant integer expression and allows
the defined named and such expressions to be used in place like case
labels, array sizes and template parameters where no C++ programmer
would expect the expression be evaluated at run-time, where no sane C++
compiler would evaluate the expression at run-time. 

> So, if you want a particular optimization with an Ada
> compiler, then you need to look at the object code generated by that
> compiler, and tweak it as needed (and possibly work with the vendor to get
> what you want).

I think the success of "template meta programming" (as this abuse of the
template system is called by some) is the fact that there is no need to
count on compiler optimization to get the effect, and you may also do
some other things like computing type.  So running this 

#include <iostream>

template <int F>
struct factorial {
   enum { RET = factorial<F-1>::RET*F };
};

template <>
struct factorial<1> {
   enum { RET = 1 };
};

template <int F>
struct ken {
  typedef int T;
};

template <>
struct ken<3628800> {
  typedef double T;
};

int main() {
  ken<factorial<10>::RET >::T x10 = 0.5;
  ken<factorial<11>::RET >::T x11 = 0.5;
  std::cout << "x10=" << x10
	    << "\nx11=" << x11 << std::endl;
}

produces

x10=0.5
x11=0

because x10 is a double while x11 is an int.  But I agree, that is still
not a formal guarantee that the compiler does not compute the type of
x10 and x11 at run time :-)

Some seems to think that the biggest difference between Ada generic and
C++ template is the fact that the templates are instanciated
automatically or that they are constrained by use.  My point of view is
that these differences are syntaxic differences and do not modify
significantly the expressing power.  I think that the ability to
specialize template is a point where the C++ templates are more
powerfull than the Ada generics.

Yours,

-- Jean-Marc