reuse function logic in a const expression

I think my question is, is there anyway to emulate the behaviour that we'll gain from C++0x's constexpr ke开发者_JAVA技巧yword with the current C++ standard (that is if I understand what constexpr is supposed to do correctly).

To be more clear, there are times when it is useful to calculate a value at compile time but it is also useful to be able to calculate it at runtime too, for e.g. if we want to calculate powers, we could use the code below.

template<int X, unsigned int Y>
struct xPowerY_const {
    static const int value = X*xPowerY_const<X,Y-1>::value;
};

template<int X>
struct xPowerY_const<X, 1> {
    static const int value = X;
};

int xPowerY(int x, unsigned int y) {
    return (y==1) ? x : x*xPowerY(x,y-1);
}

This is a simple example but in more complicated cases being able to reuse the code would be helpful. Even if, for runtime performance, the recursive nature of the function is suboptimal and a better algorithm could be devised it would be useful for testing the logic if the templated version could be expressed in a function, as I can't see a reasonable method of testing the validity of the constant template method in a wide range of cases (although perhaps there is one and i just can't see it, and perhaps that's another question).

Thanks.

Edit Forgot to mention, I don't want to #define

Edit2 Also my code above is wrong, it doesn't deal with x^0, but that doesn't affect the question.

Template metaprogramming implements logic in an entirely different (and incompatible) way from "normal" C++ code. You're not defining a function, you're defining a type. It just happens that the type has a value associated with it, which is built up from a combination of other types.

Because the templates define types, there is no program logic involved. The logic is simply a side effect of the compiler trying to resolve relationships between the templated types. There really isn't any way to automatically extract the high level logic from a template "program" into a function.

FWIW, template metaprogramming wasn't even a glimmer in Bjarne's eye when templates were first implemented. They were actually discovered later on in the language's life by users of the language. It's an "unintended" side-effect of the type system that just happened to become very popular. It's precisely because of this discovery that new features are being added to the language to more thoroughly support the idioms that have evolved.