2

Are floating point calculations, which use compile-time constant integers, performed during compile-time or during run-time? For example, when is the division operation calculated in:

template <int A, int B>
inline float fraction()
{
    return static_cast<float>(A) / B;
}
zeroes00
  • 531
  • 3
  • 16
  • 3
    AFAIK the standard doesn't define this and it depends on the compiler and optimization flags. – khachik Dec 11 '10 at 14:23
  • 1
    BTW, don't forget that you can check the assembler output of your compiler. You're asking about compiler-specific, not language-specific thing. My bet is that a good compiler (esp. with optimizations on) will calculate in compile time everything it can. – Kos Dec 11 '10 at 14:58

5 Answers5

2

For something this simple, the compiler will probably do it at compile time. In fact, the compiler will probably do it at compile time even without templates, as long as all the values are known at compile time: i.e. if we have inline float fraction(int A, int B), it will probably do the division at compile time if we call fraction(1,2) .

If you want to force the compiler to do stuff at compile-time, you will have to use some template metaprogramming tricks, and I'm not sure you can get it to work with floating-point arithmetic at all. But here is a basic example of the technique:

// Something similarly simple that doesn't use floating-point ;)
template <int A, int B>
struct Product {
    enum { value = A * B };
};

// Later:
... Product<3, 4>::value ...
Karl Knechtel
  • 62,466
  • 11
  • 102
  • 153
1

Your best bet is to look at the generated code - there is no guarantee that floating-point operations will be performed at compile time, but at higher optimisation levels they potentially could be, particularly for something simple like this.

(Some compilers might avoid doing this because for some architectures the floating point behaviour is configurable at runtime. The results for the operation performed at compile time could then potentially differ from those from the same operation performed at runtime.)

1

You should wait for gcc 4.6 with C++0x constexpr keyword implementation.

Abyx
  • 12,345
  • 5
  • 44
  • 76
  • 2
    And while we wait, and every other compiler simply ignores C++0x, and *if* it ever gets ratified, how are we to get work done? ;) – Clifford Dec 12 '10 at 09:27
1

I believe it is implementation defined, but most compilers will evaluate constant expressions at compile time. However even if yours does not the following modification:

template <int A, int B>
inline float fraction()
{
    static const float f = static_cast<float>(A) / B;
    return f ;
}

will at least ensure that the expression is evaluated just once if it is evaluated at runtime.

Clifford
  • 88,407
  • 13
  • 85
  • 165
1

Neither the C or C++ standards require that constant expressions of any stripe be evaluated at compile time, but they do allow it. Most compilers released in the last 20 years will evaluate arithmetic expressions, so if not incurring a function call or inlining the code is important, keep it as simple as possble.

If the scope of these expressions is limited to a single file, you can always take advantage of the preprocessor and #define FRACTION(a,b) (float(a)/float(b)) for convenience. I don't recommend doing this in a header unless you have a good scheme to prevent polluting any file that #includes it.

Blrfl
  • 6,817
  • 1
  • 25
  • 25