type imbriqué dans la classe modèle

Question

J'ai une classe Foo modèle, dont je veux typedef pointeurs intelligents. Autant que je sache, je ne peux pas le dactylographier en dehors de la classe. Le code ci-dessous (ou ses variantes) ne fonctionnera pas. Donc, j'ai typedefed shared_ptr et weak_ptr à l'intérieur de la classe

template<typename T> 
class Foo { 
public: 
    typedef shared_ptr< Foo<T> > Ptr; 
    typedef weak_ptr< Foo<T> > WeakPtr; 
}; 

Ce qui est ennuyeux parce que je ne peux pas transmettre le déclarer maintenant dans d'autres en-têtes. Mais ma question est, chaque fois que je veux déclarer un Foo :: Ptr, je dois le précéder de typename. par exemple.

template<typename T> 
class Bar { 
    void do(typename Foo<T>::Ptr p); 
} 

Cette syntaxe est un peu encombrant, il est en fait plus rapide à écrire shared_ptr<Foo<T>>

Y at-il des alternatives? C'est à dire. une manière de déclarer Foo :: Ptr (ou même Foo :: Ptr) dans n'importe quel contexte qui est modélisé à T? (par exemple à l'intérieur de la classe Bar?)

---

EDIT.

Sur la base de la réponse de Denis, je pense à aller avec ce

types.h

template<typename T> 
class Foo; 

template<typename T> 
using Foo_Ptr = std::shared_ptr< Foo<T> >; 

template<typename T> 
class Bar; 

template<typename T> 
using Bar_Ptr = std::shared_ptr< Bar<T> >; 

.h

#include "types.h" 
template<typename T> 
class Foo { 
public: 

}; 

ailleurs

#include "Foo.h" 

template<typename T> 
void do_sth(Foo_Ptr<T> p) { 
} 

Answer 1

Vous pourrait introduire un alias avec using comme le stdlib il le fait pour type_traits (like std_enable_if_t), qui ne nécessite pas le mot-clé typename:

using foo_ptr_t = typename Node<T>::Ptr; 

Un exemple possible est:

#include <memory> 

template<typename> 
struct Foo { }; 

template<typename T> 
class Node { 
public: 
    typedef std::shared_ptr<Foo<T>> Ptr; 
    typedef std::weak_ptr<Foo<T>> WeakPtr; 
}; 

template<typename T> 
using foo_ptr_t = typename Node<T>::Ptr; 

void do_sth(foo_ptr_t<int> p) { } 

Demo