typedefs, internes ou externes à une classe ?

Hello,

Typedefs internes :

Code:

---

1 2 3 4 5

class Foo { public: using Ptr = std::shared_ptr<Foo>; using WkPtr = std::weak_ptr<Foo>; };

---

Typedefs externes :

Code:

---

1 2 3

class Foo; using FooPtr = std::shared_ptr<Foo>; using FooWkPtr = std::weak_ptr<Foo>;

---

J'avais commencé par utiliser des typedefs internes, qui me semblaient plus propres.
Puis je me suis rapidement retrouvé dans un cas d'interdépendances

Code:

---

1 2 3 4 5 6

class A { std::vector<B::Ptr> vec; }; class B { A::WkPtr a; };

---

Donc 2 solutions :
- ne pas utiliser le typedef dans un des cas (ce qui me plais pas trop)
- utiliser des typedefs externes (ce qui me plais pas trop non plus, mais sur le coup ça semblait la meilleure solution)

J'ai donc utilisé des typedefs externes partout (ce qui permet pas mal de déclarations anticipées du coup :))

Et puis aujourd'hui, je me retrouve avec le problème inverse

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template <class T> struct Foo { // pourrait être // static typename T::Ptr create(sfg::Desktop& d) { // avec des typedefs internes static std::shared_ptr<T> create(sfg::Desktop& d) { auto obj = std::make_shared<T>(d); obj->setUp(); return obj; } };

---

Ce qui relance le débat...

C'est impossible de pouvoir utiliser des typedefs partout ?
Je suppose que du coup les typedefs internes sont une meilleure solution ?

Une troisième solution serait d'utiliser une classe de trait :

Code:

---

1 2 3 4 5

template<typename T> struct pointer_traits { using Ptr = std::shared_ptr<T>; using WkPtr = std::weak_ptr<T>; };

---

Code:

---

1 2 3 4 5 6 7 8

class B;   template<> struct pointer_traits<B> { // ça n'a pas forcément de sens, mais juste pour l'exemple using Ptr = std::unique_ptr<B>; using WkPtr = B*; };

---

Code:

---

1 2 3 4 5 6

class A { std::vector<pointer_traits<B>::Ptr> vec; }; class B { pointer_traits<A>::WkPtr a; };

---

Code:

---

1 2 3 4 5 6 7 8

template <class T> struct Foo { static typename pointer_traits<T>::Ptr create(sfg::Desktop& d) { auto obj = std::make_shared<T>(d); obj->setUp(); return obj; } };

---

Si le but est vraiment d'avoir à éviter de taper quelques caractères en plus à chaque shared_ptr (ce qui tendrait à indiquer une utilisation probablement abusive de shared_ptr mais bon... :mouarf:) peut être qu'un alias de template suffit ?

Code:

---

1 2 3

template <typename T> using Ptr = std::shared_ptr<T>;

---

Ce qui donne le code suivant, qui n'est pas trop mal finalement :

Code:

---

1 2 3 4 5 6 7 8

template <class T> struct Foo { static Ptr<T> create(int t) { auto obj = std::make_shared<T>(t); return obj; } };

---

Ou peut être un mélange des deux, pour les type fixes, sans template la convention serait d'avoir un typedef avec un Ptr accolé au bout, comme FooPtr, histoire d’éviter d’encombrer le code avec trop de chevron et pour le reste se rabattre sur une utilisation de Ptr<T>.

Citation:

---

Envoyé par Arzar

Si le but est vraiment d'avoir à éviter de taper quelques caractères en plus à chaque shared_ptr (ce qui tendrait à indiquer une utilisation probablement abusive de shared_ptr mais bon... :mouarf:)

---

Le but n'est pas d'économiser quelques caractères, mais d'avoir le même type, nommé de la même façon partout. :)
(Tu me diras que dans ce cas j'ai juste à ne pas utiliser de typedefs, donc oui il y a aussi le but de donner un nom significatif, et si possible moins long à ces shared_ptr)

@Kalith : pile ce qu'il me faut, merci !