Could somebody explain the template resolution order rules to me?

Question

Ok, complete pseudo code here.

template <typename T>
void fun(/*...*/)
{
    some_meta_typelist pushback T;
}

So the idea is that at any point this function is instantiated it grows the some_meta_typelist object. If this is done across boundaries, is there any guarantee all calls to this template building mechanism will be compiled before the type list is used in maybe an MPL::fold function. When are these evaluated and when can you be sure they are done? Should this be limited to compilation units and never across .cpp boundaries? Is there an equivalent to calling a function with a static variable to ensure the object has been created before use?

Update

I'm looking at the idea that objects calling into a system will then build the typelist that system needs to do its work. My feeling is that the type list will depend entirely on the compilation order and so not be a valid approach beyond a single file CPP. I know MSVC compiles in alphabetical order, or at least it used to, so I could name the final file ZZZZ.cpp, by final I mean the one that needs the fully built typelist. This is not a safe or compatible solution. Is this the case? and is there a work around?

Thanks all

Answer 1

Here is a simplistic, watered-down version of how template instantiation works (I'll work through the Boost documentation for fold).

Say you're a C++ compiler (let's call you clang...that's a pretty cool name) and you're happily reading in a .cpp file in order to compile it. You see all these normal functions like void foo(), float magic(int x, double p) and int main(int argc, char** argv). Then, you come across something like this:

template <typename T>
struct is_fun
{
    typedef some_other_type<T> something_else;
    typedef typename something_else::value value;
}

Here, clang says: Cool, I know about this structure named is_fun, which is a template with a single type as a parameter. At this point, is_fun is an uninitialized template. It is important to note that it is not compiling anything here. When clang sees a templated anything, it checks the syntax (to the degree that it is capable of) and moves on. There is not a way to emit an uninitialized template in object code - it is purely C++ and not compiled.

Later, it comes along and sees is_fun getting used in a statement like this:

typedef vector<long,float,short,double,float,long,long double> types;
typedef fold<
             types,
             int_<0>,
             if_< is_fun<_2>,next<_1>,_1 >
            >
        ::type number_of_fun;

Now, clang is lazy and just says "Okay, number_of_fun is just an alias for that hideous thing." Once again, it doesn't do anything. Later in your code, it sees this:

int foo()
{
    const int fun = number_of_fun::value;
    return fun;
}

Now, it has do do something with the number_of_fun template. Now, the template parameters will be filled in with values (because using number_of_fun::value requires it). clang will step through all the Boost stuff and eventually end up at your templated is_fun. The first thing on the list that it needs is a long (that's what folding a vector does), so it creates a new type based on long, with all the Ts filled in:

struct is_fun<long>
{
    typedef some_other_type<long> something_else;
    static const int value = typename something_else::value;
}

This type will get compiled, because it has been used. The basic rule of C++ templates is: When you use it during compilation, it will be instantiated, which means it will get compiled. There is nothing special you need to do at run-time.