Dual factories

Now, say for instance I have a class like this:

class foo
{
public:
    virtual bool check() = 0;
}

template<class T, class U>
class foo_impl : public foo
{
    virtual bool check()
   {
   }
}

Now, i want to instantiate foo in two phases, first when i know what
type T is, and then again when i know what type U is. Well if i use a
generic factory to create it i get this:
class factory
{
public:
    virtual foo * create() = 0;
}
I create a special factory when i know what type T is, but i really
need to use templated virtual:
template<class T>
class factory_t
{
public:
    template<class U>
    virtual foo * create()
    {
        return new foo_impl<T, U>();
    }
}

What i would like to do is pass the factory through to an interface
like this:

class bar
{
    virtual void use(factory * f) = 0;
}

template<class U>
class bar_impl
{
    virtual void use(factory * f)
   {
      foo * x = f->create<U>(); //Of course not possible
   }
}
And of course this wont work. So instead maybe i could use two
factories, the first one would keep the type T, and the second one
would keep type U:

template<class T>
class first_factory
{
public:
    virtual factory * create()
    {
    }
}

template<class U>
class second_factory
{
public:
    virtual factory * create()
    {
    }
}

Hopefully this makes sense, i just need a way to put the two factories
together, maybe its not possible. Does anyone have any ideas? Maybe a
different approach?

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]