héritage, redéfinition « relaxed », fonction statique

(excusez moi pour le titre qui laisse un peu à désirer)

étant donné cette hiérarchie de classes

struct Shape
{
virtual Shape* clone() const =0;
virtual ~Shape()
{ }
};

struct Foo
: public Shape
{

Foo* clone() const
{
return new Foo(*this);
}

static Foo* create()
{
return new Foo();
}
};


ce morceau de code

Foo foo;
Foo *shape1 = foo.clone();
Shape *shape2 = shape1->clone();

ne pose aucun problème
et celui-là

typedef Foo* (&refFooCreator)();
typedef Foo* (*ptrFooCreator)();

refFooCreator rfoo(Foo::create);
ptrFooCreator pfoo(&Foo::create);

non plus
par contre ce dernier

typedef Shape* (&refShapeCreator)();
typedef Shape* (*ptrShapeCreator)();

refShapeCreator rshape(Foo::create);
ptrShapeCreator pshape(Foo::create);

pose problème, les convertions

'Foo*()() -> Shape*(&)()'
et
'Foo*(*)() -> Shape*(*)()'

n'étant pas définies ce que je comprends parfaitement.

y a t il une erreur de ma part ?
sinon, je trouve cela un peu regrettable, car je suis obligé d'utiliser
des instances de sous-types de Shape, et d'utiliser ptrShape->create()
pour appeler la bonne fonction create (alors définie non-static virtuelle
pure const).

Merci